30006ad0 <CPU_usage_Per_thread_handler>:
static void CPU_usage_Per_thread_handler(
Thread_Control *the_thread
)
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
30006ad0: e3a03000 mov r3, #0 <== NOT EXECUTED 30006ad4: e5803084 str r3, [r0, #132] ; 0x84 <== NOT EXECUTED 30006ad8: e5803088 str r3, [r0, #136] ; 0x88 <== NOT EXECUTED
#else
the_thread->cpu_time_used = 0;
#endif
}
30006adc: e12fff1e bx lr <== NOT EXECUTED
30005a04 <Dump_Line>:
static inline void Dump_Line(
const unsigned char *buffer,
int length
)
{
30005a04: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30005a08: e24dd078 sub sp, sp, #120 ; 0x78 <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30005a0c: e3a04000 mov r4, #0 <== NOT EXECUTED 30005a10: e28d7078 add r7, sp, #120 ; 0x78 <== NOT EXECUTED
static inline void Dump_Line(
const unsigned char *buffer,
int length
)
{
30005a14: e1a05000 mov r5, r0 <== NOT EXECUTED 30005a18: e1a06001 mov r6, r1 <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30005a1c: e5674078 strb r4, [r7, #-120]! ; 0x78 <== NOT EXECUTED
for( i=0 ; i<length ; i++ )
30005a20: ea000005 b 30005a3c <Dump_Line+0x38> <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
30005a24: e7d53004 ldrb r3, [r5, r4] <== NOT EXECUTED 30005a28: e1a0000d mov r0, sp <== NOT EXECUTED 30005a2c: e59f10bc ldr r1, [pc, #188] ; 30005af0 <Dump_Line+0xec> <== NOT EXECUTED 30005a30: e1a0200d mov r2, sp <== NOT EXECUTED 30005a34: eb002cdf bl 30010db8 <sprintf> <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30005a38: e2844001 add r4, r4, #1 <== NOT EXECUTED 30005a3c: e1540006 cmp r4, r6 <== NOT EXECUTED 30005a40: bafffff7 blt 30005a24 <Dump_Line+0x20> <== NOT EXECUTED 30005a44: ea000003 b 30005a58 <Dump_Line+0x54> <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
30005a48: e1a0000d mov r0, sp <== NOT EXECUTED 30005a4c: e59f10a0 ldr r1, [pc, #160] ; 30005af4 <Dump_Line+0xf0> <== NOT EXECUTED 30005a50: eb002d33 bl 30010f24 <strcat> <== NOT EXECUTED
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
30005a54: e2844001 add r4, r4, #1 <== NOT EXECUTED 30005a58: e354000f cmp r4, #15 <== NOT EXECUTED 30005a5c: dafffff9 ble 30005a48 <Dump_Line+0x44> <== NOT EXECUTED
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
30005a60: e1a0000d mov r0, sp <== NOT EXECUTED 30005a64: e59f108c ldr r1, [pc, #140] ; 30005af8 <Dump_Line+0xf4> <== NOT EXECUTED 30005a68: eb002d2d bl 30010f24 <strcat> <== NOT EXECUTED
for( i=0 ; i<length ; i++ )
30005a6c: e3a04000 mov r4, #0 <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005a70: e59f7084 ldr r7, [pc, #132] ; 30005afc <Dump_Line+0xf8> <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
30005a74: e1a0800d mov r8, sp <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30005a78: ea00000a b 30005aa8 <Dump_Line+0xa4> <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005a7c: e7d53004 ldrb r3, [r5, r4] <== NOT EXECUTED 30005a80: e5972000 ldr r2, [r7] <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
30005a84: e1a0000d mov r0, sp <== NOT EXECUTED
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005a88: e0822003 add r2, r2, r3 <== NOT EXECUTED 30005a8c: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
30005a90: e59f1068 ldr r1, [pc, #104] ; 30005b00 <Dump_Line+0xfc> <== NOT EXECUTED 30005a94: e3120097 tst r2, #151 ; 0x97 <== NOT EXECUTED 30005a98: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED 30005a9c: e1a0200d mov r2, sp <== NOT EXECUTED 30005aa0: eb002cc4 bl 30010db8 <sprintf> <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30005aa4: e2844001 add r4, r4, #1 <== NOT EXECUTED 30005aa8: e1540006 cmp r4, r6 <== NOT EXECUTED 30005aac: bafffff2 blt 30005a7c <Dump_Line+0x78> <== NOT EXECUTED 30005ab0: ea000004 b 30005ac8 <Dump_Line+0xc4> <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
30005ab4: e1a0000d mov r0, sp <== NOT EXECUTED 30005ab8: e59f1044 ldr r1, [pc, #68] ; 30005b04 <Dump_Line+0x100> <== NOT EXECUTED 30005abc: eb002d18 bl 30010f24 <strcat> <== NOT EXECUTED
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
30005ac0: e2844001 add r4, r4, #1 <== NOT EXECUTED 30005ac4: ea000000 b 30005acc <Dump_Line+0xc8> <== NOT EXECUTED 30005ac8: e1a0500d mov r5, sp <== NOT EXECUTED 30005acc: e354000f cmp r4, #15 <== NOT EXECUTED 30005ad0: dafffff7 ble 30005ab4 <Dump_Line+0xb0> <== NOT EXECUTED
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
30005ad4: e1a0000d mov r0, sp <== NOT EXECUTED 30005ad8: e59f1028 ldr r1, [pc, #40] ; 30005b08 <Dump_Line+0x104> <== NOT EXECUTED 30005adc: eb002d10 bl 30010f24 <strcat> <== NOT EXECUTED
printk( line_buffer );
30005ae0: e1a0000d mov r0, sp <== NOT EXECUTED 30005ae4: eb0005ad bl 300071a0 <printk> <== NOT EXECUTED
}
30005ae8: e28dd078 add sp, sp, #120 ; 0x78 <== NOT EXECUTED
30005aec: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000cef4 <IMFS_Set_handlers>:
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
3000cef4: e5902000 ldr r2, [r0]
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
3000cef8: e5903010 ldr r3, [r0, #16]
switch( node->type ) {
3000cefc: e592204c ldr r2, [r2, #76] ; 0x4c
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
3000cf00: e5933034 ldr r3, [r3, #52] ; 0x34
switch( node->type ) {
3000cf04: e2422001 sub r2, r2, #1 3000cf08: e3520006 cmp r2, #6 3000cf0c: 979ff102 ldrls pc, [pc, r2, lsl #2]
3000cf10: ea000010 b 3000cf58 <IMFS_Set_handlers+0x64> <== NOT EXECUTED 3000cf14: 3000cf30 .word 0x3000cf30 <== NOT EXECUTED 3000cf18: 3000cf38 .word 0x3000cf38 <== NOT EXECUTED 3000cf1c: 3000cf40 .word 0x3000cf40 <== NOT EXECUTED 3000cf20: 3000cf40 .word 0x3000cf40 <== NOT EXECUTED 3000cf24: 3000cf48 .word 0x3000cf48 <== NOT EXECUTED 3000cf28: 3000cf48 .word 0x3000cf48 <== NOT EXECUTED 3000cf2c: 3000cf50 .word 0x3000cf50 <== NOT EXECUTED
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
3000cf30: e593300c ldr r3, [r3, #12] 3000cf34: ea000006 b 3000cf54 <IMFS_Set_handlers+0x60>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
3000cf38: e59f3020 ldr r3, [pc, #32] ; 3000cf60 <IMFS_Set_handlers+0x6c> 3000cf3c: ea000004 b 3000cf54 <IMFS_Set_handlers+0x60>
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
3000cf40: e59f301c ldr r3, [pc, #28] ; 3000cf64 <IMFS_Set_handlers+0x70> 3000cf44: ea000002 b 3000cf54 <IMFS_Set_handlers+0x60>
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
3000cf48: e5933008 ldr r3, [r3, #8] 3000cf4c: ea000000 b 3000cf54 <IMFS_Set_handlers+0x60>
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
3000cf50: e5933010 ldr r3, [r3, #16] 3000cf54: e5803008 str r3, [r0, #8]
break;
}
return 0;
}
3000cf58: e3a00000 mov r0, #0 3000cf5c: e12fff1e bx lr
3000ccd4 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
3000ccd4: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
3000ccd8: e5904000 ldr r4, [r0] <== NOT EXECUTED
#endif
jnode->st_uid = owner;
jnode->st_gid = group;
IMFS_update_ctime( jnode );
3000ccdc: e1a0000d mov r0, sp <== NOT EXECUTED
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
3000cce0: e1c413bc strh r1, [r4, #60] ; 0x3c <== NOT EXECUTED
jnode->st_gid = group;
3000cce4: e1c423be strh r2, [r4, #62] ; 0x3e <== NOT EXECUTED
IMFS_update_ctime( jnode );
3000cce8: e3a01000 mov r1, #0 <== NOT EXECUTED 3000ccec: ebffe595 bl 30006348 <gettimeofday> <== NOT EXECUTED 3000ccf0: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
}
3000ccf4: e3a00000 mov r0, #0 <== NOT EXECUTED
#endif
jnode->st_uid = owner;
jnode->st_gid = group;
IMFS_update_ctime( jnode );
3000ccf8: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
3000ccfc: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED
3000cff4 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
3000cff4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
3000cff8: e3d27007 bics r7, r2, #7
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
3000cffc: e24dd040 sub sp, sp, #64 ; 0x40 3000d000: e58d0000 str r0, [sp] 3000d004: e1a06001 mov r6, r1 3000d008: e1a08002 mov r8, r2 3000d00c: e1a04003 mov r4, r3
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
3000d010: 05935000 ldreq r5, [r3]
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
int len;
IMFS_token_types type = IMFS_CURRENT_DIR;
3000d014: 03a09001 moveq r9, #1
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
3000d018: 028da004 addeq sl, sp, #4
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
3000d01c: 0a000057 beq 3000d180 <IMFS_eval_path+0x18c>
rtems_set_errno_and_return_minus_one( EIO );
3000d020: eb000c85 bl 3001023c <__errno> <== NOT EXECUTED 3000d024: e3a03005 mov r3, #5 <== NOT EXECUTED 3000d028: ea00007e b 3000d228 <IMFS_eval_path+0x234> <== NOT EXECUTED
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
3000d02c: e59d2000 ldr r2, [sp] 3000d030: e28d303c add r3, sp, #60 ; 0x3c 3000d034: e0820007 add r0, r2, r7 3000d038: e1a01006 mov r1, r6 3000d03c: e1a0200a mov r2, sl 3000d040: eb0001ae bl 3000d700 <IMFS_get_token>
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
3000d044: e5943000 ldr r3, [r4]
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
3000d048: e1a09000 mov r9, r0
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
3000d04c: e3530000 cmp r3, #0
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
3000d050: e59db03c ldr fp, [sp, #60] ; 0x3c
i += len;
if ( !pathloc->node_access )
3000d054: 0a000041 beq 3000d160 <IMFS_eval_path+0x16c>
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
3000d058: e3500000 cmp r0, #0
3000d05c: 0a000006 beq 3000d07c <IMFS_eval_path+0x88>
if ( node->type == IMFS_DIRECTORY )
3000d060: e595104c ldr r1, [r5, #76] ; 0x4c 3000d064: e3510001 cmp r1, #1
3000d068: 1a000003 bne 3000d07c <IMFS_eval_path+0x88>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
3000d06c: e1a00004 mov r0, r4 3000d070: ebffffbc bl 3000cf68 <IMFS_evaluate_permission> 3000d074: e3500000 cmp r0, #0
3000d078: 0a000068 beq 3000d220 <IMFS_eval_path+0x22c>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
3000d07c: e3590003 cmp r9, #3
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
3000d080: e06b6006 rsb r6, fp, r6
i += len;
3000d084: e087700b add r7, r7, fp
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
3000d088: e5945000 ldr r5, [r4]
switch( type ) {
3000d08c: 0a000014 beq 3000d0e4 <IMFS_eval_path+0xf0>
3000d090: e3590004 cmp r9, #4
3000d094: 0a000036 beq 3000d174 <IMFS_eval_path+0x180>
3000d098: e3590002 cmp r9, #2
3000d09c: 1a000037 bne 3000d180 <IMFS_eval_path+0x18c>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
3000d0a0: e59fc194 ldr ip, [pc, #404] ; 3000d23c <IMFS_eval_path+0x248> 3000d0a4: e59c3000 ldr r3, [ip] 3000d0a8: e5933018 ldr r3, [r3, #24] 3000d0ac: e1550003 cmp r5, r3
3000d0b0: 0a000032 beq 3000d180 <IMFS_eval_path+0x18c>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
3000d0b4: e594e010 ldr lr, [r4, #16]
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
3000d0b8: e59e301c ldr r3, [lr, #28] 3000d0bc: e1550003 cmp r5, r3
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
3000d0c0: 028dc028 addeq ip, sp, #40 ; 0x28 3000d0c4: 028ee008 addeq lr, lr, #8
3000d0c8: 0a000037 beq 3000d1ac <IMFS_eval_path+0x1b8>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
3000d0cc: e5955008 ldr r5, [r5, #8] 3000d0d0: e3550000 cmp r5, #0
3000d0d4: 1a000024 bne 3000d16c <IMFS_eval_path+0x178>
rtems_set_errno_and_return_minus_one( ENOENT );
3000d0d8: eb000c57 bl 3001023c <__errno> <== NOT EXECUTED 3000d0dc: e5809000 str r9, [r0] <== NOT EXECUTED 3000d0e0: ea000051 b 3000d22c <IMFS_eval_path+0x238> <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
3000d0e4: e595304c ldr r3, [r5, #76] ; 0x4c 3000d0e8: e3530003 cmp r3, #3
3000d0ec: 1a000004 bne 3000d104 <IMFS_eval_path+0x110>
IMFS_evaluate_hard_link( pathloc, 0 );
3000d0f0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d0f4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000d0f8: ebffffaa bl 3000cfa8 <IMFS_evaluate_hard_link> <== NOT EXECUTED
node = pathloc->node_access;
3000d0fc: e5945000 ldr r5, [r4] <== NOT EXECUTED 3000d100: ea000008 b 3000d128 <IMFS_eval_path+0x134> <== NOT EXECUTED
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
3000d104: e3530004 cmp r3, #4
3000d108: 1a000006 bne 3000d128 <IMFS_eval_path+0x134>
result = IMFS_evaluate_sym_link( pathloc, 0 );
3000d10c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d110: e3a01000 mov r1, #0 <== NOT EXECUTED 3000d114: eb000049 bl 3000d240 <IMFS_evaluate_sym_link> <== NOT EXECUTED
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
if ( result == -1 )
3000d118: e3700001 cmn r0, #1 <== NOT EXECUTED
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
3000d11c: e1a0b000 mov fp, r0 <== NOT EXECUTED
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
3000d120: e5945000 ldr r5, [r4] <== NOT EXECUTED
if ( result == -1 )
3000d124: 0a000041 beq 3000d230 <IMFS_eval_path+0x23c> <== NOT EXECUTED
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
3000d128: e595304c ldr r3, [r5, #76] ; 0x4c 3000d12c: e3530001 cmp r3, #1
3000d130: 0a000002 beq 3000d140 <IMFS_eval_path+0x14c>
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000d134: eb000c40 bl 3001023c <__errno> <== NOT EXECUTED 3000d138: e3a03014 mov r3, #20 <== NOT EXECUTED 3000d13c: ea000039 b 3000d228 <IMFS_eval_path+0x234> <== NOT EXECUTED
/*
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
3000d140: e595e05c ldr lr, [r5, #92] ; 0x5c 3000d144: e35e0000 cmp lr, #0
3000d148: 1a000015 bne 3000d1a4 <IMFS_eval_path+0x1b0>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
3000d14c: e1a00005 mov r0, r5 3000d150: e1a0100a mov r1, sl 3000d154: eb000149 bl 3000d680 <IMFS_find_match_in_dir>
if ( !node )
3000d158: e2505000 subs r5, r0, #0
3000d15c: 1a000002 bne 3000d16c <IMFS_eval_path+0x178>
rtems_set_errno_and_return_minus_one( ENOENT );
3000d160: eb000c35 bl 3001023c <__errno> 3000d164: e3a03002 mov r3, #2 3000d168: ea00002e b 3000d228 <IMFS_eval_path+0x234>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
3000d16c: e5845000 str r5, [r4] 3000d170: ea000002 b 3000d180 <IMFS_eval_path+0x18c>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
3000d174: eb000c30 bl 3001023c <__errno> <== NOT EXECUTED 3000d178: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 3000d17c: ea000029 b 3000d228 <IMFS_eval_path+0x234> <== NOT EXECUTED
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
3000d180: e3590004 cmp r9, #4 3000d184: 13590000 cmpne r9, #0
3000d188: 1affffa7 bne 3000d02c <IMFS_eval_path+0x38>
* new fs root node and let let the mounted filesystem set the handlers.
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
3000d18c: e595304c ldr r3, [r5, #76] ; 0x4c 3000d190: e3530001 cmp r3, #1
3000d194: 1a000019 bne 3000d200 <IMFS_eval_path+0x20c>
if ( node->info.directory.mt_fs != NULL ) {
3000d198: e595e05c ldr lr, [r5, #92] ; 0x5c 3000d19c: e35e0000 cmp lr, #0
3000d1a0: 0a000016 beq 3000d200 <IMFS_eval_path+0x20c>
newloc = node->info.directory.mt_fs->mt_fs_root;
3000d1a4: e28dc028 add ip, sp, #40 ; 0x28
3000d1a8: e28ee01c add lr, lr, #28
3000d1ac: e8be000f ldm lr!, {r0, r1, r2, r3}
3000d1b0: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000d1b4: e59ee000 ldr lr, [lr]
3000d1b8: e58ce000 str lr, [ip]
*pathloc = newloc;
3000d1bc: e28dc028 add ip, sp, #40 ; 0x28
3000d1c0: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000d1c4: e1a0c004 mov ip, r4
3000d1c8: e8ac000f stmia ip!, {r0, r1, r2, r3}
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
3000d1cc: e59d103c ldr r1, [sp, #60] ; 0x3c 3000d1d0: e59d2000 ldr r2, [sp]
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
3000d1d4: e58ce000 str lr, [ip]
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
3000d1d8: e0610007 rsb r0, r1, r7 3000d1dc: e0820000 add r0, r2, r0 3000d1e0: e594c00c ldr ip, [r4, #12] 3000d1e4: e0861001 add r1, r6, r1 3000d1e8: e1a02008 mov r2, r8 3000d1ec: e1a03004 mov r3, r4 3000d1f0: e1a0e00f mov lr, pc 3000d1f4: e59cf000 ldr pc, [ip] 3000d1f8: e1a0b000 mov fp, r0 3000d1fc: ea00000b b 3000d230 <IMFS_eval_path+0x23c>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
3000d200: e1a00004 mov r0, r4 3000d204: ebffff3a bl 3000cef4 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
3000d208: e1a01008 mov r1, r8
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
3000d20c: e1a0b000 mov fp, r0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
3000d210: e1a00004 mov r0, r4 3000d214: ebffff53 bl 3000cf68 <IMFS_evaluate_permission> 3000d218: e3500000 cmp r0, #0
3000d21c: 1a000003 bne 3000d230 <IMFS_eval_path+0x23c>
rtems_set_errno_and_return_minus_one( EACCES );
3000d220: eb000c05 bl 3001023c <__errno> <== NOT EXECUTED 3000d224: e3a0300d mov r3, #13 <== NOT EXECUTED
3000d228: e5803000 str r3, [r0] 3000d22c: e3e0b000 mvn fp, #0
return result;
}
3000d230: e1a0000b mov r0, fp
3000d234: e28dd040 add sp, sp, #64 ; 0x40
3000d238: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000d37c <IMFS_evaluate_for_make>:
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
3000d37c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000d380: e24dd03c sub sp, sp, #60 ; 0x3c
3000d384: e1a07000 mov r7, r0
3000d388: e1a04001 mov r4, r1
3000d38c: e1a0a002 mov sl, r2
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
3000d390: e5916000 ldr r6, [r1]
/*
* Get the path length.
*/
pathlen = strlen( path );
3000d394: eb000f92 bl 300111e4 <strlen>
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
3000d398: e3a05000 mov r5, #0
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
3000d39c: e1a08000 mov r8, r0
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
3000d3a0: e1a01008 mov r1, r8 3000d3a4: e28d3038 add r3, sp, #56 ; 0x38 3000d3a8: e0870005 add r0, r7, r5 3000d3ac: e1a0200d mov r2, sp 3000d3b0: eb0000d2 bl 3000d700 <IMFS_get_token>
pathlen -= len;
i += len;
if ( !pathloc->node_access )
3000d3b4: e5943000 ldr r3, [r4]
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
3000d3b8: e59db038 ldr fp, [sp, #56] ; 0x38
i += len;
if ( !pathloc->node_access )
3000d3bc: e3530000 cmp r3, #0
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
3000d3c0: e1a09000 mov r9, r0
pathlen -= len;
3000d3c4: e06b8008 rsb r8, fp, r8
i += len;
if ( !pathloc->node_access )
3000d3c8: 0a000060 beq 3000d550 <IMFS_evaluate_for_make+0x1d4>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
3000d3cc: e3500000 cmp r0, #0
3000d3d0: 0a000006 beq 3000d3f0 <IMFS_evaluate_for_make+0x74>
if ( node->type == IMFS_DIRECTORY )
3000d3d4: e596104c ldr r1, [r6, #76] ; 0x4c 3000d3d8: e3510001 cmp r1, #1
3000d3dc: 1a000003 bne 3000d3f0 <IMFS_evaluate_for_make+0x74>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
3000d3e0: e1a00004 mov r0, r4 3000d3e4: ebfffedf bl 3000cf68 <IMFS_evaluate_permission> 3000d3e8: e3500000 cmp r0, #0
3000d3ec: 0a00006c beq 3000d5a4 <IMFS_evaluate_for_make+0x228>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
3000d3f0: e5943000 ldr r3, [r4]
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
3000d3f4: e085500b add r5, r5, fp
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
3000d3f8: e1a06003 mov r6, r3
switch( type ) {
3000d3fc: e3590004 cmp r9, #4 3000d400: 979ff109 ldrls pc, [pc, r9, lsl #2]
3000d404: eaffffe5 b 3000d3a0 <IMFS_evaluate_for_make+0x24> <== NOT EXECUTED 3000d408: 3000d514 .word 0x3000d514 <== NOT EXECUTED 3000d40c: 3000d3a0 .word 0x3000d3a0 <== NOT EXECUTED 3000d410: 3000d41c .word 0x3000d41c <== NOT EXECUTED 3000d414: 3000d458 .word 0x3000d458 <== NOT EXECUTED 3000d418: 3000d520 .word 0x3000d520 <== NOT EXECUTED
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
3000d41c: e59f119c ldr r1, [pc, #412] ; 3000d5c0 <IMFS_evaluate_for_make+0x244> 3000d420: e5912000 ldr r2, [r1] 3000d424: e5922018 ldr r2, [r2, #24] 3000d428: e1530002 cmp r3, r2
3000d42c: 0affffdb beq 3000d3a0 <IMFS_evaluate_for_make+0x24>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
3000d430: e594e010 ldr lr, [r4, #16] 3000d434: e59e201c ldr r2, [lr, #28] 3000d438: e1530002 cmp r3, r2
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
3000d43c: 028dc024 addeq ip, sp, #36 ; 0x24 3000d440: 028ee008 addeq lr, lr, #8
3000d444: 0a000019 beq 3000d4b0 <IMFS_evaluate_for_make+0x134>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
3000d448: e5936008 ldr r6, [r3, #8] 3000d44c: e3560000 cmp r6, #0
3000d450: 1a00002d bne 3000d50c <IMFS_evaluate_for_make+0x190>
3000d454: ea00003d b 3000d550 <IMFS_evaluate_for_make+0x1d4> <== NOT EXECUTED
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
3000d458: e593304c ldr r3, [r3, #76] ; 0x4c 3000d45c: e3530003 cmp r3, #3
3000d460: 0a000001 beq 3000d46c <IMFS_evaluate_for_make+0xf0>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
3000d464: e3530004 cmp r3, #4
3000d468: 1a000005 bne 3000d484 <IMFS_evaluate_for_make+0x108>
result = IMFS_evaluate_link( pathloc, 0 );
3000d46c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d470: e3a01000 mov r1, #0 <== NOT EXECUTED 3000d474: ebffff93 bl 3000d2c8 <IMFS_evaluate_link> <== NOT EXECUTED
if ( result == -1 )
3000d478: e3700001 cmn r0, #1 <== NOT EXECUTED
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
3000d47c: e1a06000 mov r6, r0 <== NOT EXECUTED
if ( result == -1 )
3000d480: 0a00004b beq 3000d5b4 <IMFS_evaluate_for_make+0x238> <== NOT EXECUTED
return -1;
}
node = pathloc->node_access;
3000d484: e5940000 ldr r0, [r4]
if ( !node )
3000d488: e3500000 cmp r0, #0
3000d48c: 0a00003c beq 3000d584 <IMFS_evaluate_for_make+0x208>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
3000d490: e590304c ldr r3, [r0, #76] ; 0x4c 3000d494: e3530001 cmp r3, #1
3000d498: 1a000039 bne 3000d584 <IMFS_evaluate_for_make+0x208>
/*
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
3000d49c: e590e05c ldr lr, [r0, #92] ; 0x5c 3000d4a0: e35e0000 cmp lr, #0
3000d4a4: 0a000014 beq 3000d4fc <IMFS_evaluate_for_make+0x180>
newloc = node->info.directory.mt_fs->mt_fs_root;
3000d4a8: e28dc024 add ip, sp, #36 ; 0x24
3000d4ac: e28ee01c add lr, lr, #28
3000d4b0: e8be000f ldm lr!, {r0, r1, r2, r3}
3000d4b4: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000d4b8: e59ee000 ldr lr, [lr]
3000d4bc: e58ce000 str lr, [ip]
*pathloc = newloc;
3000d4c0: e28dc024 add ip, sp, #36 ; 0x24
3000d4c4: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000d4c8: e1a0c004 mov ip, r4
3000d4cc: e8ac000f stmia ip!, {r0, r1, r2, r3}
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
3000d4d0: e59d2038 ldr r2, [sp, #56] ; 0x38
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
3000d4d4: e58ce000 str lr, [ip]
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
3000d4d8: e0625005 rsb r5, r2, r5 3000d4dc: e594300c ldr r3, [r4, #12] 3000d4e0: e0870005 add r0, r7, r5 3000d4e4: e1a01004 mov r1, r4 3000d4e8: e1a0200a mov r2, sl 3000d4ec: e1a0e00f mov lr, pc 3000d4f0: e593f004 ldr pc, [r3, #4] 3000d4f4: e1a06000 mov r6, r0 3000d4f8: ea00002d b 3000d5b4 <IMFS_evaluate_for_make+0x238>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
3000d4fc: e1a0100d mov r1, sp 3000d500: eb00005e bl 3000d680 <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
3000d504: e2506000 subs r6, r0, #0
3000d508: 0a000007 beq 3000d52c <IMFS_evaluate_for_make+0x1b0>
done = true;
else
pathloc->node_access = node;
3000d50c: e5846000 str r6, [r4] 3000d510: eaffffa2 b 3000d3a0 <IMFS_evaluate_for_make+0x24>
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
3000d514: eb000b48 bl 3001023c <__errno> 3000d518: e3a03011 mov r3, #17 3000d51c: ea000022 b 3000d5ac <IMFS_evaluate_for_make+0x230>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
3000d520: eb000b45 bl 3001023c <__errno> <== NOT EXECUTED 3000d524: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 3000d528: ea00001f b 3000d5ac <IMFS_evaluate_for_make+0x230> <== NOT EXECUTED
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
3000d52c: e59d3038 ldr r3, [sp, #56] ; 0x38 3000d530: e0633005 rsb r3, r3, r5 3000d534: e0873003 add r3, r7, r3 3000d538: e58a3000 str r3, [sl]
* pathloc is returned with a pointer to the parent of the new node.
* name is returned with a pointer to the first character in the
* new node name. The parent node is verified to be a directory.
*/
int IMFS_evaluate_for_make(
3000d53c: e0875005 add r5, r7, r5
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
3000d540: ea000005 b 3000d55c <IMFS_evaluate_for_make+0x1e0>
if ( !IMFS_is_separator( path[ i ] ) )
3000d544: ebffe6de bl 300070c4 <rtems_filesystem_is_separator> <== NOT EXECUTED 3000d548: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d54c: 1a000002 bne 3000d55c <IMFS_evaluate_for_make+0x1e0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
3000d550: eb000b39 bl 3001023c <__errno> <== NOT EXECUTED 3000d554: e3a03002 mov r3, #2 <== NOT EXECUTED 3000d558: ea000013 b 3000d5ac <IMFS_evaluate_for_make+0x230> <== NOT EXECUTED
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
3000d55c: e4d50001 ldrb r0, [r5], #1 3000d560: e3500000 cmp r0, #0
3000d564: 1afffff6 bne 3000d544 <IMFS_evaluate_for_make+0x1c8>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
3000d568: e1a00004 mov r0, r4 3000d56c: ebfffe60 bl 3000cef4 <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
3000d570: e5943000 ldr r3, [r4]
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
3000d574: e1a06000 mov r6, r0
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
3000d578: e593304c ldr r3, [r3, #76] ; 0x4c 3000d57c: e3530001 cmp r3, #1
3000d580: 0a000002 beq 3000d590 <IMFS_evaluate_for_make+0x214>
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000d584: eb000b2c bl 3001023c <__errno> <== NOT EXECUTED 3000d588: e3a03014 mov r3, #20 <== NOT EXECUTED 3000d58c: ea000006 b 3000d5ac <IMFS_evaluate_for_make+0x230> <== NOT EXECUTED
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
3000d590: e1a00004 mov r0, r4 3000d594: e3a01003 mov r1, #3 3000d598: ebfffe72 bl 3000cf68 <IMFS_evaluate_permission> 3000d59c: e3500000 cmp r0, #0
3000d5a0: 1a000003 bne 3000d5b4 <IMFS_evaluate_for_make+0x238>
rtems_set_errno_and_return_minus_one( EACCES );
3000d5a4: eb000b24 bl 3001023c <__errno> 3000d5a8: e3a0300d mov r3, #13 3000d5ac: e5803000 str r3, [r0] 3000d5b0: e3e06000 mvn r6, #0
return result;
}
3000d5b4: e1a00006 mov r0, r6
3000d5b8: e28dd03c add sp, sp, #60 ; 0x3c
3000d5bc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000cfa8 <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000cfa8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
IMFS_assert( jnode->type == IMFS_HARD_LINK );
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
3000cfac: e5903000 ldr r3, [r0] <== NOT EXECUTED
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000cfb0: e1a04000 mov r4, r0 <== NOT EXECUTED
IMFS_assert( jnode->type == IMFS_HARD_LINK );
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
3000cfb4: e5933050 ldr r3, [r3, #80] ; 0x50 <== NOT EXECUTED
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000cfb8: e1a05001 mov r5, r1 <== NOT EXECUTED
IMFS_assert( jnode->type == IMFS_HARD_LINK );
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
3000cfbc: e5803000 str r3, [r0] <== NOT EXECUTED
IMFS_Set_handlers( node );
3000cfc0: ebffffcb bl 3000cef4 <IMFS_Set_handlers> <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
3000cfc4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cfc8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000cfcc: ebffffe5 bl 3000cf68 <IMFS_evaluate_permission> <== NOT EXECUTED 3000cfd0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000cfd4: 1a000004 bne 3000cfec <IMFS_evaluate_hard_link+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
3000cfd8: eb000c97 bl 3001023c <__errno> <== NOT EXECUTED
3000cfdc: e3a0300d mov r3, #13 <== NOT EXECUTED
3000cfe0: e5803000 str r3, [r0] <== NOT EXECUTED
3000cfe4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000cfe8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
return result;
3000cfec: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000cff0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000d2c8 <IMFS_evaluate_link>:
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d2c8: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000d2cc: e59f70a4 ldr r7, [pc, #164] ; 3000d378 <IMFS_evaluate_link+0xb0>
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d2d0: e1a04000 mov r4, r0 3000d2d4: e1a05001 mov r5, r1
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000d2d8: e5973000 ldr r3, [r7]
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
3000d2dc: e5946000 ldr r6, [r4]
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000d2e0: e1d323b0 ldrh r2, [r3, #48] ; 0x30 3000d2e4: e2822001 add r2, r2, #1 3000d2e8: e1a02802 lsl r2, r2, #16 3000d2ec: e1a02822 lsr r2, r2, #16
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
3000d2f0: e3520005 cmp r2, #5
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000d2f4: e1c323b0 strh r2, [r3, #48] ; 0x30
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
3000d2f8: 9a000006 bls 3000d318 <IMFS_evaluate_link+0x50>
rtems_filesystem_link_counts = 0;
3000d2fc: e3a02000 mov r2, #0 <== NOT EXECUTED 3000d300: e1c323b0 strh r2, [r3, #48] ; 0x30 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ELOOP );
3000d304: eb000bcc bl 3001023c <__errno> <== NOT EXECUTED
3000d308: e3a0305c mov r3, #92 ; 0x5c <== NOT EXECUTED
3000d30c: e5803000 str r3, [r0] <== NOT EXECUTED
3000d310: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d314: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
3000d318: e596304c ldr r3, [r6, #76] ; 0x4c 3000d31c: e3530003 cmp r3, #3
3000d320: 1a000003 bne 3000d334 <IMFS_evaluate_link+0x6c>
result = IMFS_evaluate_hard_link( node, flags );
3000d324: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d328: e1a01005 mov r1, r5 <== NOT EXECUTED 3000d32c: ebffff1d bl 3000cfa8 <IMFS_evaluate_hard_link> <== NOT EXECUTED 3000d330: ea000004 b 3000d348 <IMFS_evaluate_link+0x80> <== NOT EXECUTED
else if (jnode->type == IMFS_SYM_LINK )
3000d334: e3530004 cmp r3, #4
3000d338: 1a000004 bne 3000d350 <IMFS_evaluate_link+0x88>
result = IMFS_evaluate_sym_link( node, flags );
3000d33c: e1a00004 mov r0, r4 3000d340: e1a01005 mov r1, r5 3000d344: ebffffbd bl 3000d240 <IMFS_evaluate_sym_link>
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
3000d348: e3500000 cmp r0, #0
3000d34c: 1a000004 bne 3000d364 <IMFS_evaluate_link+0x9c>
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
3000d350: e596304c ldr r3, [r6, #76] ; 0x4c 3000d354: e2433003 sub r3, r3, #3 3000d358: e3530001 cmp r3, #1
3000d35c: 9affffdd bls 3000d2d8 <IMFS_evaluate_link+0x10>
3000d360: e3a00000 mov r0, #0
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
3000d364: e59f300c ldr r3, [pc, #12] ; 3000d378 <IMFS_evaluate_link+0xb0> 3000d368: e3a02000 mov r2, #0 3000d36c: e5933000 ldr r3, [r3] 3000d370: e1c323b0 strh r2, [r3, #48] ; 0x30
return result;
}
3000d374: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000cf68 <IMFS_evaluate_permission>:
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
3000cf68: e3d13007 bics r3, r1, #7
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
3000cf6c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
3000cf70: 0a000004 beq 3000cf88 <IMFS_evaluate_permission+0x20>
rtems_set_errno_and_return_minus_one( EPERM );
3000cf74: eb000cb0 bl 3001023c <__errno> <== NOT EXECUTED
3000cf78: e3a03001 mov r3, #1 <== NOT EXECUTED
3000cf7c: e5803000 str r3, [r0] <== NOT EXECUTED
3000cf80: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000cf84: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
3000cf88: e5903000 ldr r3, [r0]
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
flags_to_test <<= 6;
3000cf8c: e1a01301 lsl r1, r1, #6
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
3000cf90: e5930030 ldr r0, [r3, #48] ; 0x30 3000cf94: e0010000 and r0, r1, r0
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
3000cf98: e1500001 cmp r0, r1 3000cf9c: 13a00000 movne r0, #0 3000cfa0: 03a00001 moveq r0, #1
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
3000cfa4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
3000d240 <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d240: e92d4071 push {r0, r4, r5, r6, lr}
IMFS_jnode_t *jnode = node->node_access;
3000d244: e5906000 ldr r6, [r0]
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d248: e1a04000 mov r4, r0
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
3000d24c: e5963008 ldr r3, [r6, #8]
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d250: e1a05001 mov r5, r1
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
3000d254: e5803000 str r3, [r0]
rtems_filesystem_get_sym_start_loc(
3000d258: e5960050 ldr r0, [r6, #80] ; 0x50 3000d25c: e1a0100d mov r1, sp 3000d260: e1a02004 mov r2, r4 3000d264: eb000341 bl 3000df70 <rtems_filesystem_get_sym_start_loc>
);
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
3000d268: e59d3000 ldr r3, [sp] 3000d26c: e5966050 ldr r6, [r6, #80] ; 0x50 3000d270: e0866003 add r6, r6, r3 3000d274: e1a00006 mov r0, r6 3000d278: eb000fd9 bl 300111e4 <strlen> 3000d27c: e1a02005 mov r2, r5 3000d280: e1a01000 mov r1, r0 3000d284: e1a03004 mov r3, r4 3000d288: e1a00006 mov r0, r6 3000d28c: ebffff58 bl 3000cff4 <IMFS_eval_path> 3000d290: e1a06000 mov r6, r0
strlen( &jnode->info.sym_link.name[i] ),
flags,
node
);
IMFS_Set_handlers( node );
3000d294: e1a00004 mov r0, r4 3000d298: ebffff15 bl 3000cef4 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
3000d29c: e1a00004 mov r0, r4 3000d2a0: e1a01005 mov r1, r5 3000d2a4: ebffff2f bl 3000cf68 <IMFS_evaluate_permission> 3000d2a8: e3500000 cmp r0, #0
3000d2ac: 1a000003 bne 3000d2c0 <IMFS_evaluate_sym_link+0x80>
rtems_set_errno_and_return_minus_one( EACCES );
3000d2b0: eb000be1 bl 3001023c <__errno> <== NOT EXECUTED 3000d2b4: e3a0300d mov r3, #13 <== NOT EXECUTED 3000d2b8: e5803000 str r3, [r0] <== NOT EXECUTED 3000d2bc: e3e06000 mvn r6, #0 <== NOT EXECUTED
return result;
}
3000d2c0: e1a00006 mov r0, r6
3000d2c4: e8bd8078 pop {r3, r4, r5, r6, pc}
3000fcf8 <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
3000fcf8: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
3000fcfc: e5904000 ldr r4, [r0] <== NOT EXECUTED
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
3000fd00: e1a01a01 lsl r1, r1, #20 <== NOT EXECUTED
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
3000fd04: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
IMFS_update_ctime( jnode );
3000fd08: e1a0000d mov r0, sp <== NOT EXECUTED
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
3000fd0c: e3c33eff bic r3, r3, #4080 ; 0xff0 <== NOT EXECUTED 3000fd10: e3c3300f bic r3, r3, #15 <== NOT EXECUTED
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
3000fd14: e1833a21 orr r3, r3, r1, lsr #20 <== NOT EXECUTED 3000fd18: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
IMFS_update_ctime( jnode );
3000fd1c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000fd20: ebffd988 bl 30006348 <gettimeofday> <== NOT EXECUTED 3000fd24: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
}
3000fd28: e3a00000 mov r0, #0 <== NOT EXECUTED
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
IMFS_update_ctime( jnode );
3000fd2c: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
3000fd30: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED
3000fd34 <IMFS_fdatasync>:
int IMFS_fdatasync(
rtems_libio_t *iop
)
{
return 0;
}
3000fd34: e3a00000 mov r0, #0 <== NOT EXECUTED 3000fd38: e12fff1e bx lr <== NOT EXECUTED
30006d04 <IMFS_fifo_ioctl>:
void *buffer
)
{
int err;
if (command == FIONBIO) {
30006d04: e59fc06c ldr ip, [pc, #108] ; 30006d78 <IMFS_fifo_ioctl+0x74>
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30006d08: e92d4010 push {r4, lr}
int err;
if (command == FIONBIO) {
30006d0c: e151000c cmp r1, ip
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30006d10: e1a03000 mov r3, r0
int err;
if (command == FIONBIO) {
30006d14: 1a00000a bne 30006d44 <IMFS_fifo_ioctl+0x40>
if (buffer == NULL)
30006d18: e3520000 cmp r2, #0
30006d1c: 0a00000e beq 30006d5c <IMFS_fifo_ioctl+0x58>
err = -EFAULT;
else {
if (*(int *)buffer)
30006d20: e5924000 ldr r4, [r2] 30006d24: e5932014 ldr r2, [r3, #20] 30006d28: e3540000 cmp r4, #0
iop->flags |= LIBIO_FLAGS_NO_DELAY;
30006d2c: 13822001 orrne r2, r2, #1
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
30006d30: 03c22001 biceq r2, r2, #1
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
30006d34: 15832014 strne r2, [r3, #20]
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
return 0;
30006d38: 13a04000 movne r4, #0
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
30006d3c: 05832014 streq r2, [r3, #20] 30006d40: ea00000a b 30006d70 <IMFS_fifo_ioctl+0x6c>
return 0;
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
30006d44: e5930018 ldr r0, [r3, #24] <== NOT EXECUTED 30006d48: e5900050 ldr r0, [r0, #80] ; 0x50 <== NOT EXECUTED 30006d4c: eb002475 bl 3000ff28 <pipe_ioctl> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30006d50: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30006d54: aa000005 bge 30006d70 <IMFS_fifo_ioctl+0x6c> <== NOT EXECUTED 30006d58: ea000000 b 30006d60 <IMFS_fifo_ioctl+0x5c> <== NOT EXECUTED
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
30006d5c: e3e0400d mvn r4, #13 <== NOT EXECUTED
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
30006d60: eb002c30 bl 30011e28 <__errno> <== NOT EXECUTED 30006d64: e2644000 rsb r4, r4, #0 <== NOT EXECUTED 30006d68: e5804000 str r4, [r0] <== NOT EXECUTED 30006d6c: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
30006d70: e1a00004 mov r0, r4
30006d74: e8bd8010 pop {r4, pc}
30006cb4 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
30006cb4: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
30006cb8: e590c018 ldr ip, [r0, #24] <== NOT EXECUTED 30006cbc: e58d0000 str r0, [sp] <== NOT EXECUTED 30006cc0: e59c0050 ldr r0, [ip, #80] ; 0x50 <== NOT EXECUTED 30006cc4: eb0024b0 bl 3000ff8c <pipe_lseek> <== NOT EXECUTED 30006cc8: e1a02000 mov r2, r0 <== NOT EXECUTED 30006ccc: e1a03fc2 asr r3, r2, #31 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30006cd0: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
30006cd4: e1a04000 mov r4, r0 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30006cd8: a1a04003 movge r4, r3 <== NOT EXECUTED 30006cdc: a1a03002 movge r3, r2 <== NOT EXECUTED 30006ce0: aa000004 bge 30006cf8 <IMFS_fifo_lseek+0x44> <== NOT EXECUTED 30006ce4: eb002c4f bl 30011e28 <__errno> <== NOT EXECUTED 30006ce8: e2644000 rsb r4, r4, #0 <== NOT EXECUTED 30006cec: e5804000 str r4, [r0] <== NOT EXECUTED 30006cf0: e3e03000 mvn r3, #0 <== NOT EXECUTED 30006cf4: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
30006cf8: e1a00003 mov r0, r3 <== NOT EXECUTED
30006cfc: e1a01004 mov r1, r4 <== NOT EXECUTED
30006d00: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
30006e5c <IMFS_fifo_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
30006e5c: e1a01000 mov r1, r0
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = fifo_open(&JNODE2PIPE(jnode), iop);
30006e60: e5900018 ldr r0, [r0, #24]
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
30006e64: e92d4010 push {r4, lr}
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = fifo_open(&JNODE2PIPE(jnode), iop);
30006e68: e2800050 add r0, r0, #80 ; 0x50 30006e6c: eb00227f bl 3000f870 <fifo_open>
IMFS_FIFO_RETURN(err);
30006e70: e2504000 subs r4, r0, #0
30006e74: aa000003 bge 30006e88 <IMFS_fifo_open+0x2c>
30006e78: eb002bea bl 30011e28 <__errno> <== NOT EXECUTED 30006e7c: e2644000 rsb r4, r4, #0 <== NOT EXECUTED 30006e80: e5804000 str r4, [r0] <== NOT EXECUTED 30006e84: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
30006e88: e1a00004 mov r0, r4
30006e8c: e8bd8010 pop {r4, pc}
3000d5c4 <IMFS_fsunmount>:
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
3000d5c4: e92d4070 push {r4, r5, r6, lr}
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
3000d5c8: e1a0c000 mov ip, r0
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
3000d5cc: e24dd014 sub sp, sp, #20
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
3000d5d0: e5bc401c ldr r4, [ip, #28]!
loc = temp_mt_entry->mt_fs_root;
3000d5d4: e1a0e00d mov lr, sp
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
3000d5d8: e1a05000 mov r5, r0
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
loc = temp_mt_entry->mt_fs_root;
3000d5dc: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000d5e0: e8ae000f stmia lr!, {r0, r1, r2, r3}
3000d5e4: e59c3000 ldr r3, [ip]
3000d5e8: e58e3000 str r3, [lr]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
3000d5ec: e3a03000 mov r3, #0 3000d5f0: e585301c str r3, [r5, #28]
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
3000d5f4: e1a0500d mov r5, sp 3000d5f8: e1a0000d mov r0, sp
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
3000d5fc: e5946008 ldr r6, [r4, #8]
loc.node_access = (void *)jnode;
3000d600: e58d4000 str r4, [sp]
IMFS_Set_handlers( &loc );
3000d604: ebfffe3a bl 3000cef4 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
3000d608: e594304c ldr r3, [r4, #76] ; 0x4c 3000d60c: e3530001 cmp r3, #1
3000d610: 1a000003 bne 3000d624 <IMFS_fsunmount+0x60>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
3000d614: e5942050 ldr r2, [r4, #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 );
3000d618: e2843054 add r3, r4, #84 ; 0x54 3000d61c: e1520003 cmp r2, r3
3000d620: 1a000005 bne 3000d63c <IMFS_fsunmount+0x78>
result = IMFS_unlink( NULL, &loc );
3000d624: e3a00000 mov r0, #0 3000d628: e1a0100d mov r1, sp 3000d62c: ebffe1ee bl 30005dec <IMFS_unlink>
if (result != 0)
3000d630: e3500000 cmp r0, #0
3000d634: 1a00000c bne 3000d66c <IMFS_fsunmount+0xa8>
return -1;
jnode = next;
3000d638: e1a04006 mov r4, r6
}
if ( jnode != NULL ) {
3000d63c: e3540000 cmp r4, #0
3000d640: 0a00000b beq 3000d674 <IMFS_fsunmount+0xb0>
if ( jnode->type == IMFS_DIRECTORY ) {
3000d644: e594304c ldr r3, [r4, #76] ; 0x4c 3000d648: e3530001 cmp r3, #1
3000d64c: 1affffe9 bne 3000d5f8 <IMFS_fsunmount+0x34>
}
}
} while (jnode != NULL);
return 0;
}
3000d650: e5943050 ldr r3, [r4, #80] ; 0x50 3000d654: e2842054 add r2, r4, #84 ; 0x54
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
3000d658: e1530002 cmp r3, r2
3000d65c: 0affffe5 beq 3000d5f8 <IMFS_fsunmount+0x34>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
3000d660: e2534000 subs r4, r3, #0
3000d664: 1affffe3 bne 3000d5f8 <IMFS_fsunmount+0x34>
3000d668: ea000001 b 3000d674 <IMFS_fsunmount+0xb0> <== NOT EXECUTED
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
3000d66c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000d670: ea000000 b 3000d678 <IMFS_fsunmount+0xb4> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
3000d674: e1a00004 mov r0, r4
}
3000d678: e28dd014 add sp, sp, #20
3000d67c: e8bd8070 pop {r4, r5, r6, pc}
3000d700 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
3000d700: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3000d704: e1a05001 mov r5, r1
3000d708: e1a04002 mov r4, r2
3000d70c: e1a0a003 mov sl, r3
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
3000d710: e5d07000 ldrb r7, [r0] 3000d714: e1a08000 mov r8, r0
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
3000d718: e3a06000 mov r6, #0
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
3000d71c: ea000004 b 3000d734 <IMFS_get_token+0x34>
token[i] = c;
if ( i == IMFS_NAME_MAX )
3000d720: e3560020 cmp r6, #32
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
3000d724: e7c47006 strb r7, [r4, r6]
if ( i == IMFS_NAME_MAX )
3000d728: 0a000024 beq 3000d7c0 <IMFS_get_token+0xc0>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
3000d72c: e5f87001 ldrb r7, [r8, #1]! 3000d730: e2866001 add r6, r6, #1
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
3000d734: e1a00007 mov r0, r7 3000d738: ebffe661 bl 300070c4 <rtems_filesystem_is_separator> 3000d73c: e3500000 cmp r0, #0
3000d740: 1a000001 bne 3000d74c <IMFS_get_token+0x4c>
3000d744: e1560005 cmp r6, r5
3000d748: bafffff4 blt 3000d720 <IMFS_get_token+0x20>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
3000d74c: e3560000 cmp r6, #0
3000d750: 1a000005 bne 3000d76c <IMFS_get_token+0x6c>
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
3000d754: e3570000 cmp r7, #0 3000d758: 13550000 cmpne r5, #0
i++;
type = IMFS_CURRENT_DIR;
3000d75c: 13a06001 movne r6, #1
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
token[i] = c;
3000d760: e5c47000 strb r7, [r4]
if ( (token[i] != '\0') && pathlen ) {
i++;
3000d764: e1a00006 mov r0, r6 3000d768: ea000005 b 3000d784 <IMFS_get_token+0x84>
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
3000d76c: e0843006 add r3, r4, r6 3000d770: e5533001 ldrb r3, [r3, #-1]
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
3000d774: e3a00003 mov r0, #3
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
3000d778: e3530000 cmp r3, #0
token[i] = '\0';
3000d77c: 13a03000 movne r3, #0 3000d780: 17c43006 strbne r3, [r4, r6]
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
3000d784: e3500003 cmp r0, #3
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
3000d788: e58a6000 str r6, [sl]
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
3000d78c: 18bd85f0 popne {r4, r5, r6, r7, r8, sl, pc}
if ( strcmp( token, "..") == 0 )
3000d790: e1a00004 mov r0, r4 3000d794: e59f1034 ldr r1, [pc, #52] ; 3000d7d0 <IMFS_get_token+0xd0> 3000d798: eb000db5 bl 30010e74 <strcmp> 3000d79c: e3500000 cmp r0, #0
3000d7a0: 0a000008 beq 3000d7c8 <IMFS_get_token+0xc8>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
3000d7a4: e1a00004 mov r0, r4 3000d7a8: e59f1024 ldr r1, [pc, #36] ; 3000d7d4 <IMFS_get_token+0xd4> 3000d7ac: eb000db0 bl 30010e74 <strcmp>
type = IMFS_CURRENT_DIR;
3000d7b0: e3500000 cmp r0, #0
3000d7b4: 13a00003 movne r0, #3
3000d7b8: 03a00001 moveq r0, #1
3000d7bc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
return IMFS_INVALID_TOKEN;
3000d7c0: e3a00004 mov r0, #4 <== NOT EXECUTED
3000d7c4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
3000d7c8: e3a00002 mov r0, #2
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
3000d7cc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
30005a34 <IMFS_initialize_support>:
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
30005a34: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30005a38: e1a07003 mov r7, r3
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
30005a3c: e59f30d0 ldr r3, [pc, #208] ; 30005b14 <IMFS_initialize_support+0xe0>
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
30005a40: e1a0a001 mov sl, r1
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
30005a44: e5933000 ldr r3, [r3]
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
30005a48: e1a08002 mov r8, r2 30005a4c: e1a04000 mov r4, r0
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
30005a50: e3a01006 mov r1, #6
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
30005a54: e3a02010 mov r2, #16
if (bit_mask == requested_bytes_per_block) {
30005a58: e1520003 cmp r2, r3
30005a5c: 0a000004 beq 30005a74 <IMFS_initialize_support+0x40>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
30005a60: ca000002 bgt 30005a70 <IMFS_initialize_support+0x3c>
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
30005a64: e2511001 subs r1, r1, #1 30005a68: e1a02082 lsl r2, r2, #1
30005a6c: 1afffff9 bne 30005a58 <IMFS_initialize_support+0x24>
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
30005a70: e3a03080 mov r3, #128 ; 0x80
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
30005a74: e59f609c ldr r6, [pc, #156] ; 30005b18 <IMFS_initialize_support+0xe4> 30005a78: e5863000 str r3, [r6]
/* * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
30005a7c: eb001d0c bl 3000ceb4 <IMFS_create_root_node>
temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table; temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
30005a80: e59fe094 ldr lr, [pc, #148] ; 30005b1c <IMFS_initialize_support+0xe8> 30005a84: e284c038 add ip, r4, #56 ; 0x38
/* * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
30005a88: e584001c str r0, [r4, #28] 30005a8c: e1a05000 mov r5, r0
temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table; temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
30005a90: e8be000f ldm lr!, {r0, r1, r2, r3}
30005a94: e8ac000f stmia ip!, {r0, r1, r2, r3}
30005a98: e8be000f ldm lr!, {r0, r1, r2, r3}
30005a9c: e8ac000f stmia ip!, {r0, r1, r2, r3}
30005aa0: e89e000f ldm lr, {r0, r1, r2, r3}
* Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node(); temp_mt_entry->mt_fs_root.handlers = directory_handlers;
30005aa4: e5847024 str r7, [r4, #36] ; 0x24
temp_mt_entry->mt_fs_root.ops = op_table; temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
30005aa8: e88c000f stm ip, {r0, r1, r2, r3}
* * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node(); temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table;
30005aac: e584a028 str sl, [r4, #40] ; 0x28
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
30005ab0: e3a00001 mov r0, #1 30005ab4: e3a01014 mov r1, #20 30005ab8: eb000195 bl 30006114 <calloc>
if ( !fs_info ) {
30005abc: e3500000 cmp r0, #0
30005ac0: 1a000006 bne 30005ae0 <IMFS_initialize_support+0xac>
free(temp_mt_entry->mt_fs_root.node_access);
30005ac4: e1a00005 mov r0, r5 <== NOT EXECUTED 30005ac8: eb0001f5 bl 300062a4 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
30005acc: eb0029da bl 3001023c <__errno> <== NOT EXECUTED
30005ad0: e3a0300c mov r3, #12 <== NOT EXECUTED
30005ad4: e5803000 str r3, [r0] <== NOT EXECUTED
30005ad8: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005adc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
30005ae0: e5963004 ldr r3, [r6, #4]
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ) {
free(temp_mt_entry->mt_fs_root.node_access);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
temp_mt_entry->fs_info = fs_info;
30005ae4: e5840034 str r0, [r4, #52] ; 0x34
fs_info->instance = imfs_instance++;
fs_info->ino_count = 1;
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
fs_info->fifo_handlers = fifo_handlers;
30005ae8: e59d201c ldr r2, [sp, #28]
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
30005aec: e5803000 str r3, [r0] 30005af0: e2833001 add r3, r3, #1 30005af4: e5863004 str r3, [r6, #4]
fs_info->ino_count = 1;
30005af8: e3a03001 mov r3, #1
30005afc: e9800108 stmib r0, {r3, r8}
fs_info->memfile_handlers = memfile_handlers; fs_info->directory_handlers = directory_handlers;
30005b00: e580700c str r7, [r0, #12]
fs_info->fifo_handlers = fifo_handlers;
30005b04: e5802010 str r2, [r0, #16]
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
30005b08: e5853038 str r3, [r5, #56] ; 0x38
return 0;
30005b0c: e3a00000 mov r0, #0
}
30005b10: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
30005b20 <IMFS_link>:
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
30005b20: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
30005b24: e5903000 ldr r3, [r0] <== NOT EXECUTED
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
30005b28: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
30005b2c: e58d3028 str r3, [sp, #40] ; 0x28 <== NOT EXECUTED
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
30005b30: e1d333b4 ldrh r3, [r3, #52] ; 0x34 <== NOT EXECUTED
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
30005b34: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
30005b38: e3530007 cmp r3, #7 <== NOT EXECUTED
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
30005b3c: e1a06002 mov r6, r2 <== NOT EXECUTED
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
30005b40: 9a000002 bls 30005b50 <IMFS_link+0x30> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMLINK );
30005b44: eb0029bc bl 3001023c <__errno> <== NOT EXECUTED 30005b48: e3a0301f mov r3, #31 <== NOT EXECUTED 30005b4c: ea000012 b 30005b9c <IMFS_link+0x7c> <== NOT EXECUTED
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( token, strlen( token ), new_name, &i );
30005b50: e1a00002 mov r0, r2 <== NOT EXECUTED 30005b54: eb002da2 bl 300111e4 <strlen> <== NOT EXECUTED 30005b58: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30005b5c: e1a01000 mov r1, r0 <== NOT EXECUTED 30005b60: e1a02004 mov r2, r4 <== NOT EXECUTED 30005b64: e28d3044 add r3, sp, #68 ; 0x44 <== NOT EXECUTED 30005b68: e1a00006 mov r0, r6 <== NOT EXECUTED 30005b6c: eb001ee3 bl 3000d700 <IMFS_get_token> <== NOT EXECUTED
new_node = IMFS_create_node(
parent_loc,
IMFS_HARD_LINK,
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
30005b70: e28d3028 add r3, sp, #40 ; 0x28 <== NOT EXECUTED
* was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node(
30005b74: e58d3000 str r3, [sp] <== NOT EXECUTED 30005b78: e1a00005 mov r0, r5 <== NOT EXECUTED 30005b7c: e3a01003 mov r1, #3 <== NOT EXECUTED 30005b80: e1a02004 mov r2, r4 <== NOT EXECUTED 30005b84: e59f3050 ldr r3, [pc, #80] ; 30005bdc <IMFS_link+0xbc> <== NOT EXECUTED 30005b88: eb001c79 bl 3000cd74 <IMFS_create_node> <== NOT EXECUTED
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
30005b8c: e3500000 cmp r0, #0 <== NOT EXECUTED 30005b90: 1a000004 bne 30005ba8 <IMFS_link+0x88> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
30005b94: eb0029a8 bl 3001023c <__errno> <== NOT EXECUTED 30005b98: e3a0300c mov r3, #12 <== NOT EXECUTED 30005b9c: e5803000 str r3, [r0] <== NOT EXECUTED 30005ba0: e3e00000 mvn r0, #0 <== NOT EXECUTED 30005ba4: ea00000a b 30005bd4 <IMFS_link+0xb4> <== NOT EXECUTED
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
30005ba8: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
IMFS_update_ctime( info.hard_link.link_node );
30005bac: e28d003c add r0, sp, #60 ; 0x3c <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
30005bb0: e1d323b4 ldrh r2, [r3, #52] ; 0x34 <== NOT EXECUTED
IMFS_update_ctime( info.hard_link.link_node );
30005bb4: e3a01000 mov r1, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
30005bb8: e2822001 add r2, r2, #1 <== NOT EXECUTED 30005bbc: e1c323b4 strh r2, [r3, #52] ; 0x34 <== NOT EXECUTED
IMFS_update_ctime( info.hard_link.link_node );
30005bc0: eb0001e0 bl 30006348 <gettimeofday> <== NOT EXECUTED 30005bc4: e59d203c ldr r2, [sp, #60] ; 0x3c <== NOT EXECUTED 30005bc8: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
return 0;
30005bcc: e3a00000 mov r0, #0 <== NOT EXECUTED
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
IMFS_update_ctime( info.hard_link.link_node );
30005bd0: e5832048 str r2, [r3, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
30005bd4: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
30005bd8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000f3b0 <IMFS_memfile_extend>:
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
3000f3b0: e59f3110 ldr r3, [pc, #272] ; 3000f4c8 <IMFS_memfile_extend+0x118>
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
3000f3b4: e92d4df1 push {r0, r4, r5, r6, r7, r8, sl, fp, lr}
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
3000f3b8: e593b000 ldr fp, [r3]
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
3000f3bc: e1a05002 mov r5, r2
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
3000f3c0: e1a0312b lsr r3, fp, #2 3000f3c4: e2832001 add r2, r3, #1 3000f3c8: e0020293 mul r2, r3, r2 3000f3cc: e2822001 add r2, r2, #1 3000f3d0: e0030392 mul r3, r2, r3 3000f3d4: e3a02000 mov r2, #0 3000f3d8: e2433001 sub r3, r3, #1 3000f3dc: e1520005 cmp r2, r5
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
3000f3e0: e1a04000 mov r4, r0 3000f3e4: e1a06001 mov r6, r1
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
3000f3e8: e003039b mul r3, fp, r3
3000f3ec: ca000005 bgt 3000f408 <IMFS_memfile_extend+0x58> 3000f3f0: 1a000001 bne 3000f3fc <IMFS_memfile_extend+0x4c>
3000f3f4: e1530001 cmp r3, r1
3000f3f8: 8a000002 bhi 3000f408 <IMFS_memfile_extend+0x58>
rtems_set_errno_and_return_minus_one( EINVAL );
3000f3fc: eb00038e bl 3001023c <__errno> <== NOT EXECUTED 3000f400: e3a03016 mov r3, #22 <== NOT EXECUTED 3000f404: ea000025 b 3000f4a0 <IMFS_memfile_extend+0xf0> <== NOT EXECUTED
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
3000f408: e5948054 ldr r8, [r4, #84] ; 0x54 3000f40c: e5947050 ldr r7, [r4, #80] ; 0x50 3000f410: e1550008 cmp r5, r8
3000f414: ca000002 bgt 3000f424 <IMFS_memfile_extend+0x74> 3000f418: 1a000028 bne 3000f4c0 <IMFS_memfile_extend+0x110>
3000f41c: e1560007 cmp r6, r7
3000f420: 9a000026 bls 3000f4c0 <IMFS_memfile_extend+0x110>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000f424: e1a0cfcb asr ip, fp, #31 3000f428: e1a0300c mov r3, ip 3000f42c: e1a0200b mov r2, fp 3000f430: e1a00006 mov r0, r6 3000f434: e1a01005 mov r1, r5 3000f438: e58dc000 str ip, [sp] 3000f43c: eb001439 bl 30014528 <__divdi3>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000f440: e59dc000 ldr ip, [sp] 3000f444: e1a01008 mov r1, r8
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000f448: e1a0a000 mov sl, r0
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000f44c: e1a0200b mov r2, fp 3000f450: e1a00007 mov r0, r7 3000f454: e1a0300c mov r3, ip 3000f458: eb001432 bl 30014528 <__divdi3> 3000f45c: e1a08000 mov r8, r0
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
3000f460: e1a07000 mov r7, r0 3000f464: ea000011 b 3000f4b0 <IMFS_memfile_extend+0x100>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
3000f468: e1a00004 mov r0, r4 3000f46c: e1a01007 mov r1, r7 3000f470: ebffff57 bl 3000f1d4 <IMFS_memfile_addblock> 3000f474: e3500000 cmp r0, #0
3000f478: 0a00000b beq 3000f4ac <IMFS_memfile_extend+0xfc>
3000f47c: ea000003 b 3000f490 <IMFS_memfile_extend+0xe0> <== NOT EXECUTED
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
3000f480: e1a01007 mov r1, r7 <== NOT EXECUTED 3000f484: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f488: ebffffbe bl 3000f388 <IMFS_memfile_remove_block> <== NOT EXECUTED
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
3000f48c: e2477001 sub r7, r7, #1 <== NOT EXECUTED 3000f490: e1570008 cmp r7, r8 <== NOT EXECUTED 3000f494: 2afffff9 bcs 3000f480 <IMFS_memfile_extend+0xd0> <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
3000f498: eb000367 bl 3001023c <__errno> <== NOT EXECUTED 3000f49c: e3a0301c mov r3, #28 <== NOT EXECUTED 3000f4a0: e5803000 str r3, [r0] <== NOT EXECUTED 3000f4a4: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000f4a8: ea000005 b 3000f4c4 <IMFS_memfile_extend+0x114> <== NOT EXECUTED
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
3000f4ac: e2877001 add r7, r7, #1 3000f4b0: e157000a cmp r7, sl
3000f4b4: 9affffeb bls 3000f468 <IMFS_memfile_extend+0xb8>
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
3000f4b8: e5846050 str r6, [r4, #80] ; 0x50 3000f4bc: e5845054 str r5, [r4, #84] ; 0x54
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
return 0;
3000f4c0: e3a00000 mov r0, #0
/* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; }
3000f4c4: e8bd8df8 pop {r3, r4, r5, r6, r7, r8, sl, fp, pc}
3000ede4 <IMFS_memfile_get_block_pointer>:
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000ede4: e59f31e4 ldr r3, [pc, #484] ; 3000efd0 <IMFS_memfile_get_block_pointer+0x1ec>
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000ede8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000edec: e5935000 ldr r5, [r3]
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000edf0: e1a04000 mov r4, r0
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000edf4: e1a05125 lsr r5, r5, #2 3000edf8: e2453001 sub r3, r5, #1 3000edfc: e1510003 cmp r1, r3
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000ee00: e1a06001 mov r6, r1 3000ee04: e1a08002 mov r8, r2
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000ee08: 8a00000e bhi 3000ee48 <IMFS_memfile_get_block_pointer+0x64>
p = info->indirect;
if ( malloc_it ) {
3000ee0c: e3520000 cmp r2, #0
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
3000ee10: e5900058 ldr r0, [r0, #88] ; 0x58
if ( malloc_it ) {
3000ee14: 0a000007 beq 3000ee38 <IMFS_memfile_get_block_pointer+0x54>
if ( !p ) {
3000ee18: e3500000 cmp r0, #0
3000ee1c: 1a000003 bne 3000ee30 <IMFS_memfile_get_block_pointer+0x4c>
p = memfile_alloc_block();
3000ee20: ebffffe2 bl 3000edb0 <memfile_alloc_block>
if ( !p )
3000ee24: e3500000 cmp r0, #0
3000ee28: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
info->indirect = p;
3000ee2c: e5840058 str r0, [r4, #88] ; 0x58
}
return &info->indirect[ my_block ];
3000ee30: e5940058 ldr r0, [r4, #88] ; 0x58 3000ee34: ea000001 b 3000ee40 <IMFS_memfile_get_block_pointer+0x5c>
}
if ( !p )
3000ee38: e3500000 cmp r0, #0
3000ee3c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
return &info->indirect[ my_block ];
3000ee40: e0800106 add r0, r0, r6, lsl #2
3000ee44: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
3000ee48: e2853001 add r3, r5, #1 3000ee4c: e0030395 mul r3, r5, r3 3000ee50: e2432001 sub r2, r3, #1 3000ee54: e1510002 cmp r1, r2
3000ee58: 8a000021 bhi 3000eee4 <IMFS_memfile_get_block_pointer+0x100>
my_block -= FIRST_DOUBLY_INDIRECT;
3000ee5c: e0656001 rsb r6, r5, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000ee60: e1a00006 mov r0, r6 3000ee64: e1a01005 mov r1, r5 3000ee68: eb00134e bl 30013ba8 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000ee6c: e1a01005 mov r1, r5
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000ee70: e1a07000 mov r7, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000ee74: e1a00006 mov r0, r6 3000ee78: eb0012b2 bl 30013948 <__aeabi_uidiv>
p = info->doubly_indirect;
if ( malloc_it ) {
3000ee7c: e3580000 cmp r8, #0
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000ee80: e1a05000 mov r5, r0
p = info->doubly_indirect;
3000ee84: e594005c ldr r0, [r4, #92] ; 0x5c
if ( malloc_it ) {
3000ee88: 0a00000e beq 3000eec8 <IMFS_memfile_get_block_pointer+0xe4>
if ( !p ) {
3000ee8c: e3500000 cmp r0, #0
3000ee90: 1a000003 bne 3000eea4 <IMFS_memfile_get_block_pointer+0xc0>
p = memfile_alloc_block();
3000ee94: ebffffc5 bl 3000edb0 <memfile_alloc_block>
if ( !p )
3000ee98: e3500000 cmp r0, #0
3000ee9c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
info->doubly_indirect = p;
3000eea0: e584005c str r0, [r4, #92] ; 0x5c
}
p1 = (block_p *)p[ doubly ];
3000eea4: e0804105 add r4, r0, r5, lsl #2 3000eea8: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !p1 ) {
3000eeac: e3500000 cmp r0, #0
3000eeb0: 1a000009 bne 3000eedc <IMFS_memfile_get_block_pointer+0xf8>
p1 = memfile_alloc_block();
3000eeb4: ebffffbd bl 3000edb0 <memfile_alloc_block>
if ( !p1 )
3000eeb8: e3500000 cmp r0, #0
return 0;
p[ doubly ] = (block_p) p1;
3000eebc: 15840000 strne r0, [r4]
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
3000eec0: 1a000005 bne 3000eedc <IMFS_memfile_get_block_pointer+0xf8>
3000eec4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
return (block_p *)&p1[ singly ];
}
if ( !p )
3000eec8: e3500000 cmp r0, #0
3000eecc: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
p = (block_p *)p[ doubly ];
3000eed0: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !p )
3000eed4: e3500000 cmp r0, #0
3000eed8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
return (block_p *)&p[ singly ];
3000eedc: e0800107 add r0, r0, r7, lsl #2
3000eee0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
3000eee4: e2832001 add r2, r3, #1 <== NOT EXECUTED 3000eee8: e0020295 mul r2, r5, r2 <== NOT EXECUTED 3000eeec: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000eef0: e1510002 cmp r1, r2 <== NOT EXECUTED 3000eef4: 8a000033 bhi 3000efc8 <IMFS_memfile_get_block_pointer+0x1e4><== NOT EXECUTED
my_block -= FIRST_TRIPLY_INDIRECT;
3000eef8: e0636001 rsb r6, r3, r1 <== NOT EXECUTED
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000eefc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ef00: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ef04: eb001327 bl 30013ba8 <__umodsi3> <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000ef08: e1a01005 mov r1, r5 <== NOT EXECUTED
* 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;
3000ef0c: e1a0a000 mov sl, r0 <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000ef10: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ef14: eb00128b bl 30013948 <__aeabi_uidiv> <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
3000ef18: e1a01005 mov r1, r5 <== NOT EXECUTED
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000ef1c: e1a06000 mov r6, r0 <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
3000ef20: eb001288 bl 30013948 <__aeabi_uidiv> <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
3000ef24: e1a01005 mov r1, r5 <== NOT EXECUTED
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
3000ef28: e1a07000 mov r7, r0 <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
3000ef2c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ef30: eb00131c bl 30013ba8 <__umodsi3> <== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
3000ef34: e3580000 cmp r8, #0 <== NOT EXECUTED
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
3000ef38: e1a05000 mov r5, r0 <== NOT EXECUTED
p = info->triply_indirect;
3000ef3c: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED
if ( malloc_it ) {
3000ef40: 0a000016 beq 3000efa0 <IMFS_memfile_get_block_pointer+0x1bc><== NOT EXECUTED
if ( !p ) {
3000ef44: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ef48: 1a000003 bne 3000ef5c <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
p = memfile_alloc_block();
3000ef4c: ebffff97 bl 3000edb0 <memfile_alloc_block> <== NOT EXECUTED
if ( !p )
3000ef50: e3500000 cmp r0, #0 <== NOT EXECUTED
3000ef54: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return 0;
info->triply_indirect = p;
3000ef58: e5840060 str r0, [r4, #96] ; 0x60 <== NOT EXECUTED
}
p1 = (block_p *) p[ triply ];
3000ef5c: e0804107 add r4, r0, r7, lsl #2 <== NOT EXECUTED 3000ef60: e7900107 ldr r0, [r0, r7, lsl #2] <== NOT EXECUTED
if ( !p1 ) {
3000ef64: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ef68: 1a000003 bne 3000ef7c <IMFS_memfile_get_block_pointer+0x198><== NOT EXECUTED
p1 = memfile_alloc_block();
3000ef6c: ebffff8f bl 3000edb0 <memfile_alloc_block> <== NOT EXECUTED
if ( !p1 )
3000ef70: e3500000 cmp r0, #0 <== NOT EXECUTED
3000ef74: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return 0;
p[ triply ] = (block_p) p1;
3000ef78: e5840000 str r0, [r4] <== NOT EXECUTED
}
p2 = (block_p *)p1[ doubly ];
3000ef7c: e0804105 add r4, r0, r5, lsl #2 <== NOT EXECUTED 3000ef80: e7900105 ldr r0, [r0, r5, lsl #2] <== NOT EXECUTED
if ( !p2 ) {
3000ef84: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ef88: 1a00000c bne 3000efc0 <IMFS_memfile_get_block_pointer+0x1dc><== NOT EXECUTED
p2 = memfile_alloc_block();
3000ef8c: ebffff87 bl 3000edb0 <memfile_alloc_block> <== NOT EXECUTED
if ( !p2 )
3000ef90: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
p1[ doubly ] = (block_p) p2;
3000ef94: 15840000 strne r0, [r4] <== NOT EXECUTED
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
3000ef98: 1a000008 bne 3000efc0 <IMFS_memfile_get_block_pointer+0x1dc><== NOT EXECUTED
3000ef9c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
3000efa0: e3500000 cmp r0, #0 <== NOT EXECUTED
3000efa4: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return 0;
p1 = (block_p *) p[ triply ];
3000efa8: e7900107 ldr r0, [r0, r7, lsl #2] <== NOT EXECUTED
if ( !p1 )
3000efac: e3500000 cmp r0, #0 <== NOT EXECUTED
3000efb0: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return 0;
p2 = (block_p *)p1[ doubly ];
3000efb4: e7900105 ldr r0, [r0, r5, lsl #2] <== NOT EXECUTED
if ( !p2 )
3000efb8: e3500000 cmp r0, #0 <== NOT EXECUTED
3000efbc: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return 0;
return (block_p *)&p2[ singly ];
3000efc0: e080010a add r0, r0, sl, lsl #2 <== NOT EXECUTED
3000efc4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
/*
* This means the requested block number is out of range.
*/
return 0;
3000efc8: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000efcc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
300087f8 <IMFS_memfile_maximum_size>:
* using the IMFS memory file type.
*
*/
int IMFS_memfile_maximum_size( void )
{
return IMFS_MEMFILE_MAXIMUM_SIZE;
300087f8: e59f3020 ldr r3, [pc, #32] ; 30008820 <IMFS_memfile_maximum_size+0x28><== NOT EXECUTED 300087fc: e5932000 ldr r2, [r3] <== NOT EXECUTED 30008800: e1a03122 lsr r3, r2, #2 <== NOT EXECUTED 30008804: e2830001 add r0, r3, #1 <== NOT EXECUTED 30008808: e0000093 mul r0, r3, r0 <== NOT EXECUTED 3000880c: e2800001 add r0, r0, #1 <== NOT EXECUTED 30008810: e0030390 mul r3, r0, r3 <== NOT EXECUTED 30008814: e2430001 sub r0, r3, #1 <== NOT EXECUTED
}
30008818: e0000092 mul r0, r2, r0 <== NOT EXECUTED 3000881c: e12fff1e bx lr <== NOT EXECUTED
3000f27c <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
3000f27c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
3000f280: e59f30fc ldr r3, [pc, #252] ; 3000f384 <IMFS_memfile_remove+0x108>
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
3000f284: e1a04000 mov r4, r0
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
3000f288: e5935000 ldr r5, [r3]
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
3000f28c: e5903058 ldr r3, [r0, #88] ; 0x58
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
3000f290: e1a05125 lsr r5, r5, #2
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
3000f294: e3530000 cmp r3, #0
memfile_free_blocks_in_table( &info->indirect, to_free );
3000f298: 12800058 addne r0, r0, #88 ; 0x58 3000f29c: 11a01005 movne r1, r5 3000f2a0: 1bffffe1 blne 3000f22c <memfile_free_blocks_in_table>
}
if ( info->doubly_indirect ) {
3000f2a4: e594305c ldr r3, [r4, #92] ; 0x5c 3000f2a8: e3530000 cmp r3, #0 3000f2ac: 13a06000 movne r6, #0
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
3000f2b0: 159f70cc ldrne r7, [pc, #204] ; 3000f384 <IMFS_memfile_remove+0x108>
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
3000f2b4: 1a000008 bne 3000f2dc <IMFS_memfile_remove+0x60>
3000f2b8: ea00000d b 3000f2f4 <IMFS_memfile_remove+0x78>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
3000f2bc: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED 3000f2c0: e1a00106 lsl r0, r6, #2 <== NOT EXECUTED 3000f2c4: e7932106 ldr r2, [r3, r6, lsl #2] <== NOT EXECUTED 3000f2c8: e3520000 cmp r2, #0 <== NOT EXECUTED
memfile_free_blocks_in_table(
3000f2cc: 10830000 addne r0, r3, r0 <== NOT EXECUTED 3000f2d0: 11a01005 movne r1, r5 <== NOT EXECUTED 3000f2d4: 1bffffd4 blne 3000f22c <memfile_free_blocks_in_table> <== NOT EXECUTED
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
3000f2d8: e2866001 add r6, r6, #1 <== NOT EXECUTED 3000f2dc: e5973000 ldr r3, [r7] <== NOT EXECUTED 3000f2e0: e1560123 cmp r6, r3, lsr #2 <== NOT EXECUTED 3000f2e4: 3afffff4 bcc 3000f2bc <IMFS_memfile_remove+0x40> <== NOT EXECUTED
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
3000f2e8: e284005c add r0, r4, #92 ; 0x5c <== NOT EXECUTED 3000f2ec: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f2f0: ebffffcd bl 3000f22c <memfile_free_blocks_in_table> <== NOT EXECUTED
}
if ( info->triply_indirect ) {
3000f2f4: e5943060 ldr r3, [r4, #96] ; 0x60 3000f2f8: e3530000 cmp r3, #0 3000f2fc: 13a06000 movne r6, #0
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
3000f300: 159fa07c ldrne sl, [pc, #124] ; 3000f384 <IMFS_memfile_remove+0x108>
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
3000f304: 1a000016 bne 3000f364 <IMFS_memfile_remove+0xe8>
3000f308: ea00001b b 3000f37c <IMFS_memfile_remove+0x100>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
3000f30c: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
3000f310: e1a09106 lsl r9, r6, #2 <== NOT EXECUTED
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
3000f314: e7938106 ldr r8, [r3, r6, lsl #2] <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
3000f318: e3580000 cmp r8, #0 <== NOT EXECUTED 3000f31c: 0a000013 beq 3000f370 <IMFS_memfile_remove+0xf4> <== NOT EXECUTED
* a significant difference in the performance of this routine. * * Regardless until the IMFS implementation is proven, it * is better to stick to simple, easy to understand algorithms. */ int IMFS_memfile_remove(
3000f320: e2488004 sub r8, r8, #4 <== NOT EXECUTED 3000f324: e3a07000 mov r7, #0 <== NOT EXECUTED 3000f328: ea000005 b 3000f344 <IMFS_memfile_remove+0xc8> <== NOT EXECUTED
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
3000f32c: e5b83004 ldr r3, [r8, #4]! <== NOT EXECUTED 3000f330: e3530000 cmp r3, #0 <== NOT EXECUTED
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
3000f334: 11a00008 movne r0, r8 <== NOT EXECUTED 3000f338: 11a01005 movne r1, r5 <== NOT EXECUTED 3000f33c: 1bffffba blne 3000f22c <memfile_free_blocks_in_table> <== NOT EXECUTED
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
3000f340: e2877001 add r7, r7, #1 <== NOT EXECUTED 3000f344: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3000f348: e1570123 cmp r7, r3, lsr #2 <== NOT EXECUTED 3000f34c: 3afffff6 bcc 3000f32c <IMFS_memfile_remove+0xb0> <== NOT EXECUTED
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
3000f350: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 3000f354: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f358: e0800009 add r0, r0, r9 <== NOT EXECUTED 3000f35c: ebffffb2 bl 3000f22c <memfile_free_blocks_in_table> <== NOT EXECUTED
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
3000f360: e2866001 add r6, r6, #1 <== NOT EXECUTED 3000f364: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3000f368: e1560123 cmp r6, r3, lsr #2 <== NOT EXECUTED 3000f36c: 3affffe6 bcc 3000f30c <IMFS_memfile_remove+0x90> <== NOT EXECUTED
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
3000f370: e2840060 add r0, r4, #96 ; 0x60 <== NOT EXECUTED 3000f374: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f378: ebffffab bl 3000f22c <memfile_free_blocks_in_table> <== NOT EXECUTED
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
3000f37c: e3a00000 mov r0, #0
3000f380: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
3000f388 <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
3000f388: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3000f38c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000f390: ebfffe93 bl 3000ede4 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
*block_ptr = 0;
3000f394: e3a02000 mov r2, #0 <== NOT EXECUTED
)
{
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3000f398: e1a03000 mov r3, r0 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
3000f39c: e5900000 ldr r0, [r0] <== NOT EXECUTED
*block_ptr = 0;
3000f3a0: e5832000 str r2, [r3] <== NOT EXECUTED
memfile_free_block( ptr );
3000f3a4: ebffff98 bl 3000f20c <memfile_free_block> <== NOT EXECUTED
return 1;
}
3000f3a8: e3a00001 mov r0, #1 <== NOT EXECUTED
3000f3ac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000f4cc <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
3000f4cc: e92d4ff7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000f4d0: e1a06003 mov r6, 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 ) {
3000f4d4: e5903054 ldr r3, [r0, #84] ; 0x54
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
3000f4d8: e59d8030 ldr r8, [sp, #48] ; 0x30
* 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 ) {
3000f4dc: e3530000 cmp r3, #0
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
3000f4e0: e1a07001 mov r7, r1 3000f4e4: e1a04000 mov r4, r0 3000f4e8: e1a0a002 mov sl, 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;
3000f4ec: e0881001 add r1, r8, r1
if ( last_byte > the_jnode->info.file.size ) {
3000f4f0: ba000003 blt 3000f504 <IMFS_memfile_write+0x38>
3000f4f4: 1a00000c bne 3000f52c <IMFS_memfile_write+0x60>
3000f4f8: e5903050 ldr r3, [r0, #80] ; 0x50 3000f4fc: e1530001 cmp r3, r1
3000f500: 2a000009 bcs 3000f52c <IMFS_memfile_write+0x60>
status = IMFS_memfile_extend( the_jnode, last_byte );
3000f504: e1a00004 mov r0, r4 3000f508: e3a02000 mov r2, #0 3000f50c: ebffffa7 bl 3000f3b0 <IMFS_memfile_extend>
if ( status )
3000f510: e3500000 cmp r0, #0
3000f514: 0a000004 beq 3000f52c <IMFS_memfile_write+0x60>
rtems_set_errno_and_return_minus_one( ENOSPC );
3000f518: eb000347 bl 3001023c <__errno> <== NOT EXECUTED 3000f51c: e3a0301c mov r3, #28 <== NOT EXECUTED 3000f520: e5803000 str r3, [r0] <== NOT EXECUTED 3000f524: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000f528: ea00004d b 3000f664 <IMFS_memfile_write+0x198> <== NOT EXECUTED
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
3000f52c: e59f3138 ldr r3, [pc, #312] ; 3000f66c <IMFS_memfile_write+0x1a0> 3000f530: e1a00007 mov r0, r7 3000f534: e5939000 ldr r9, [r3] 3000f538: e1a0100a mov r1, sl 3000f53c: e1a0b009 mov fp, r9 3000f540: e1a0cfcb asr ip, fp, #31 3000f544: e1a0300c mov r3, ip 3000f548: e1a0200b mov r2, fp 3000f54c: e58dc000 str ip, [sp] 3000f550: eb001521 bl 300149dc <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000f554: e59dc000 ldr ip, [sp]
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
3000f558: e1a05000 mov r5, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000f55c: e1a0100a mov r1, sl 3000f560: e1a00007 mov r0, r7 3000f564: e1a0200b mov r2, fp 3000f568: e1a0300c mov r3, ip 3000f56c: eb0013ed bl 30014528 <__divdi3>
if ( start_offset ) {
3000f570: e3550000 cmp r5, #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;
3000f574: e1a07000 mov r7, r0
if ( start_offset ) {
3000f578: 0a000012 beq 3000f5c8 <IMFS_memfile_write+0xfc>
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 );
3000f57c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f580: e1a01007 mov r1, r7 <== NOT EXECUTED 3000f584: e3a02000 mov r2, #0 <== NOT EXECUTED 3000f588: ebfffe15 bl 3000ede4 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
if ( !block_ptr )
3000f58c: e3500000 cmp r0, #0 <== NOT EXECUTED
return copied;
3000f590: 01a05000 moveq r5, r0 <== NOT EXECUTED
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
3000f594: 0a000032 beq 3000f664 <IMFS_memfile_write+0x198> <== NOT EXECUTED
* 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;
3000f598: e065a009 rsb sl, r5, r9 <== NOT EXECUTED
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
3000f59c: e5900000 ldr r0, [r0] <== NOT EXECUTED
* 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;
3000f5a0: e15a0008 cmp sl, r8 <== NOT EXECUTED 3000f5a4: 21a0a008 movcs sl, r8 <== NOT EXECUTED
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
3000f5a8: e0800005 add r0, r0, r5 <== NOT EXECUTED 3000f5ac: e1a01006 mov r1, r6 <== NOT EXECUTED 3000f5b0: e1a0200a mov r2, sl <== NOT EXECUTED 3000f5b4: eb00054e bl 30010af4 <memcpy> <== NOT EXECUTED
src += to_copy;
3000f5b8: e086600a add r6, r6, sl <== NOT EXECUTED
block++;
3000f5bc: e2877001 add r7, r7, #1 <== NOT EXECUTED
my_length -= to_copy;
3000f5c0: e06a8008 rsb r8, sl, r8 <== NOT EXECUTED
copied += to_copy;
3000f5c4: e1a0500a mov r5, sl <== NOT EXECUTED
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
3000f5c8: e59f909c ldr r9, [pc, #156] ; 3000f66c <IMFS_memfile_write+0x1a0> 3000f5cc: e599a000 ldr sl, [r9]
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
3000f5d0: ea00000d b 3000f60c <IMFS_memfile_write+0x140>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3000f5d4: e1a00004 mov r0, r4 3000f5d8: e1a01007 mov r1, r7 3000f5dc: e3a02000 mov r2, #0 3000f5e0: ebfffdff bl 3000ede4 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
3000f5e4: e3500000 cmp r0, #0
3000f5e8: 0a00001d beq 3000f664 <IMFS_memfile_write+0x198>
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 );
3000f5ec: e1a01006 mov r1, r6 3000f5f0: e5900000 ldr r0, [r0] 3000f5f4: e1a0200a mov r2, sl 3000f5f8: eb00053d bl 30010af4 <memcpy>
src += to_copy;
3000f5fc: e086600a add r6, r6, sl
block++;
3000f600: e2877001 add r7, r7, #1
my_length -= to_copy;
3000f604: e06a8008 rsb r8, sl, r8
* 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(
3000f608: e085500a add r5, r5, sl
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
3000f60c: e5993000 ldr r3, [r9] 3000f610: e1580003 cmp r8, r3
3000f614: 2affffee bcs 3000f5d4 <IMFS_memfile_write+0x108>
* 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 ) {
3000f618: e3580000 cmp r8, #0
3000f61c: 0a00000a beq 3000f64c <IMFS_memfile_write+0x180>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3000f620: e1a00004 mov r0, r4 3000f624: e1a01007 mov r1, r7 3000f628: e3a02000 mov r2, #0 3000f62c: ebfffdec bl 3000ede4 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
3000f630: e3500000 cmp r0, #0
3000f634: 0a00000a beq 3000f664 <IMFS_memfile_write+0x198>
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 );
3000f638: e5900000 ldr r0, [r0] 3000f63c: e1a01006 mov r1, r6 3000f640: e1a02008 mov r2, r8 3000f644: eb00052a bl 30010af4 <memcpy>
my_length = 0;
copied += to_copy;
3000f648: e0855008 add r5, r5, r8
}
IMFS_mtime_ctime_update( the_jnode );
3000f64c: e28d0004 add r0, sp, #4 3000f650: e3a01000 mov r1, #0 3000f654: ebffdb3b bl 30006348 <gettimeofday> 3000f658: e59d3004 ldr r3, [sp, #4] 3000f65c: e5843044 str r3, [r4, #68] ; 0x44 3000f660: e5843048 str r3, [r4, #72] ; 0x48
return copied;
}
3000f664: e1a00005 mov r0, r5
3000f668: e8bd8ffe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
30005c8c <IMFS_mount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
30005c8c: e5903008 ldr r3, [r0, #8]
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
30005c90: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
30005c94: e593204c ldr r2, [r3, #76] ; 0x4c 30005c98: e3520001 cmp r2, #1
30005c9c: 0a000004 beq 30005cb4 <IMFS_mount+0x28>
rtems_set_errno_and_return_minus_one( ENOTDIR );
30005ca0: eb002965 bl 3001023c <__errno> <== NOT EXECUTED
30005ca4: e3a03014 mov r3, #20 <== NOT EXECUTED
30005ca8: e5803000 str r3, [r0] <== NOT EXECUTED
30005cac: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005cb0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
30005cb4: e583005c str r0, [r3, #92] ; 0x5c
return 0;
30005cb8: e3a00000 mov r0, #0
}
30005cbc: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30008614 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
30008614: e92d4030 push {r4, r5, lr}
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
30008618: e59f50e0 ldr r5, [pc, #224] ; 30008700 <IMFS_print_jnode+0xec>
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
3000861c: e1a04000 mov r4, r0
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
30008620: e5953000 ldr r3, [r5] 30008624: e280000c add r0, r0, #12 30008628: e5931008 ldr r1, [r3, #8] 3000862c: eb0030dc bl 300149a4 <fputs>
switch( the_jnode->type ) {
30008630: e594204c ldr r2, [r4, #76] ; 0x4c 30008634: e2423001 sub r3, r2, #1 30008638: e3530006 cmp r3, #6 3000863c: 979ff103 ldrls pc, [pc, r3, lsl #2]
30008640: ea000026 b 300086e0 <IMFS_print_jnode+0xcc> <== NOT EXECUTED 30008644: 30008660 .word 0x30008660 <== NOT EXECUTED 30008648: 30008674 .word 0x30008674 <== NOT EXECUTED 3000864c: 300086c0 .word 0x300086c0 <== NOT EXECUTED 30008650: 300086c0 .word 0x300086c0 <== NOT EXECUTED 30008654: 300086a8 .word 0x300086a8 <== NOT EXECUTED 30008658: 3000868c .word 0x3000868c <== NOT EXECUTED 3000865c: 300086cc .word 0x300086cc <== NOT EXECUTED
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
30008660: e5953000 ldr r3, [r5] 30008664: e3a0002f mov r0, #47 ; 0x2f 30008668: e5931008 ldr r1, [r3, #8] 3000866c: eb003097 bl 300148d0 <fputc>
break;
30008670: ea00001f b 300086f4 <IMFS_print_jnode+0xe0>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
30008674: e5953000 ldr r3, [r5] 30008678: e59f1084 ldr r1, [pc, #132] ; 30008704 <IMFS_print_jnode+0xf0> 3000867c: e5930008 ldr r0, [r3, #8] 30008680: e5942050 ldr r2, [r4, #80] ; 0x50 30008684: e5943054 ldr r3, [r4, #84] ; 0x54 30008688: ea000004 b 300086a0 <IMFS_print_jnode+0x8c>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
3000868c: e5953000 ldr r3, [r5] 30008690: e59f1070 ldr r1, [pc, #112] ; 30008708 <IMFS_print_jnode+0xf4> 30008694: e5930008 ldr r0, [r3, #8] 30008698: e5942050 ldr r2, [r4, #80] ; 0x50 3000869c: e5943058 ldr r3, [r4, #88] ; 0x58 300086a0: eb00306a bl 30014850 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
300086a4: ea000012 b 300086f4 <IMFS_print_jnode+0xe0>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
300086a8: e5953000 ldr r3, [r5] <== NOT EXECUTED 300086ac: e59f1058 ldr r1, [pc, #88] ; 3000870c <IMFS_print_jnode+0xf8><== NOT EXECUTED 300086b0: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 300086b4: e5942050 ldr r2, [r4, #80] ; 0x50 <== NOT EXECUTED 300086b8: eb003064 bl 30014850 <fprintf> <== NOT EXECUTED
(uint32_t)the_jnode->info.file.size );
#endif
break;
300086bc: ea00000c b 300086f4 <IMFS_print_jnode+0xe0> <== NOT EXECUTED
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
300086c0: e5953000 ldr r3, [r5] <== NOT EXECUTED 300086c4: e59f0044 ldr r0, [pc, #68] ; 30008710 <IMFS_print_jnode+0xfc><== NOT EXECUTED 300086c8: ea000001 b 300086d4 <IMFS_print_jnode+0xc0> <== NOT EXECUTED
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
300086cc: e5953000 ldr r3, [r5] <== NOT EXECUTED 300086d0: e59f003c ldr r0, [pc, #60] ; 30008714 <IMFS_print_jnode+0x100><== NOT EXECUTED 300086d4: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
300086d8: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
300086dc: ea0030b0 b 300149a4 <fputs> <== NOT EXECUTED
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
300086e0: e5953000 ldr r3, [r5] <== NOT EXECUTED 300086e4: e59f102c ldr r1, [pc, #44] ; 30008718 <IMFS_print_jnode+0x104><== NOT EXECUTED 300086e8: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
return;
}
puts("");
}
300086ec: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
300086f0: ea003056 b 30014850 <fprintf> <== NOT EXECUTED
return;
}
puts("");
300086f4: e59f0020 ldr r0, [pc, #32] ; 3000871c <IMFS_print_jnode+0x108>
}
300086f8: e8bd4030 pop {r4, r5, lr}
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
300086fc: ea003782 b 3001650c <puts>
30005ccc <IMFS_readlink>:
)
{
IMFS_jnode_t *node;
ssize_t i;
node = loc->node_access;
30005ccc: e590c000 ldr ip, [r0] <== NOT EXECUTED
IMFS_assert( node->type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
30005cd0: e3a00000 mov r0, #0 <== NOT EXECUTED 30005cd4: ea000001 b 30005ce0 <IMFS_readlink+0x14> <== NOT EXECUTED
buf[i] = node->info.sym_link.name[i];
30005cd8: e7c13000 strb r3, [r1, r0] <== NOT EXECUTED
node = loc->node_access;
IMFS_assert( node->type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
30005cdc: e2800001 add r0, r0, #1 <== NOT EXECUTED 30005ce0: e1500002 cmp r0, r2 <== NOT EXECUTED 30005ce4: 212fff1e bxcs lr <== NOT EXECUTED 30005ce8: e59c3050 ldr r3, [ip, #80] ; 0x50 <== NOT EXECUTED 30005cec: e7d33000 ldrb r3, [r3, r0] <== NOT EXECUTED 30005cf0: e3530000 cmp r3, #0 <== NOT EXECUTED 30005cf4: 1afffff7 bne 30005cd8 <IMFS_readlink+0xc> <== NOT EXECUTED
buf[i] = node->info.sym_link.name[i];
return i;
}
30005cf8: e12fff1e bx lr <== NOT EXECUTED
30005cfc <IMFS_rename>:
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
30005cfc: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
30005d00: e5914000 ldr r4, [r1] <== NOT EXECUTED
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
30005d04: e1a05002 mov r5, r2 <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
30005d08: e1a01003 mov r1, r3 <== NOT EXECUTED 30005d0c: e284000c add r0, r4, #12 <== NOT EXECUTED 30005d10: e3a02020 mov r2, #32 <== NOT EXECUTED 30005d14: eb002d4a bl 30011244 <strncpy> <== NOT EXECUTED
if ( the_jnode->Parent != NULL )
30005d18: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30005d1c: e3530000 cmp r3, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
30005d20: 11a00004 movne r0, r4 <== NOT EXECUTED 30005d24: 1b00102e blne 30009de4 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
30005d28: e5950000 ldr r0, [r5] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
30005d2c: e1a01004 mov r1, r4 <== NOT EXECUTED
the_jnode->Parent = new_parent;
30005d30: e5840008 str r0, [r4, #8] <== NOT EXECUTED 30005d34: e2800050 add r0, r0, #80 ; 0x50 <== NOT EXECUTED 30005d38: eb00101e bl 30009db8 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
30005d3c: e1a0000d mov r0, sp <== NOT EXECUTED 30005d40: e3a01000 mov r1, #0 <== NOT EXECUTED 30005d44: eb00017f bl 30006348 <gettimeofday> <== NOT EXECUTED 30005d48: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
}
30005d4c: e3a00000 mov r0, #0 <== NOT EXECUTED
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
30005d50: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
30005d54: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED
3000d8a8 <IMFS_stat>:
{
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
3000d8a8: e5903000 ldr r3, [r0]
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
3000d8ac: e92d4800 push {fp, lr}
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
3000d8b0: e593204c ldr r2, [r3, #76] ; 0x4c 3000d8b4: e2422002 sub r2, r2, #2 3000d8b8: e3520005 cmp r2, #5 3000d8bc: 979ff102 ldrls pc, [pc, r2, lsl #2]
3000d8c0: ea000012 b 3000d910 <IMFS_stat+0x68> <== NOT EXECUTED 3000d8c4: 3000d8dc .word 0x3000d8dc <== NOT EXECUTED 3000d8c8: 3000d910 .word 0x3000d910 <== NOT EXECUTED 3000d8cc: 3000d8fc .word 0x3000d8fc <== NOT EXECUTED 3000d8d0: 3000d8f0 .word 0x3000d8f0 <== NOT EXECUTED 3000d8d4: 3000d8f0 .word 0x3000d8f0 <== NOT EXECUTED 3000d8d8: 3000d8fc .word 0x3000d8fc <== NOT EXECUTED
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
3000d8dc: e5932054 ldr r2, [r3, #84] ; 0x54
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
3000d8e0: e593c050 ldr ip, [r3, #80] ; 0x50 3000d8e4: e581201c str r2, [r1, #28] 3000d8e8: e581c018 str ip, [r1, #24]
break;
3000d8ec: ea00000c b 3000d924 <IMFS_stat+0x7c>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
3000d8f0: e283c050 add ip, r3, #80 ; 0x50
3000d8f4: e89c1800 ldm ip, {fp, ip}
3000d8f8: ea000001 b 3000d904 <IMFS_stat+0x5c>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
3000d8fc: e3a0b000 mov fp, #0 <== NOT EXECUTED 3000d900: e3a0c000 mov ip, #0 <== NOT EXECUTED
3000d904: e581b020 str fp, [r1, #32] 3000d908: e581c024 str ip, [r1, #36] ; 0x24
break;
3000d90c: ea000004 b 3000d924 <IMFS_stat+0x7c>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000d910: eb000a49 bl 3001023c <__errno> <== NOT EXECUTED
3000d914: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
3000d918: e5803000 str r3, [r0] <== NOT EXECUTED
3000d91c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d920: e8bd8800 pop {fp, pc} <== NOT EXECUTED
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
3000d924: e5902010 ldr r2, [r0, #16] 3000d928: e59f0050 ldr r0, [pc, #80] ; 3000d980 <IMFS_stat+0xd8>
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
3000d92c: e5922034 ldr r2, [r2, #52] ; 0x34 3000d930: e5922000 ldr r2, [r2]
/* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; buf->st_dev =
3000d934: e8810005 stm r1, {r0, r2}
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
3000d938: e5932030 ldr r2, [r3, #48] ; 0x30
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
return 0;
3000d93c: e3a00000 mov r0, #0
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
3000d940: e581200c str r2, [r1, #12]
buf->st_nlink = the_jnode->st_nlink;
3000d944: e1d323b4 ldrh r2, [r3, #52] ; 0x34 3000d948: e1c121b0 strh r2, [r1, #16]
buf->st_ino = the_jnode->st_ino;
3000d94c: e5932038 ldr r2, [r3, #56] ; 0x38 3000d950: e5812008 str r2, [r1, #8]
buf->st_uid = the_jnode->st_uid;
3000d954: e1d323bc ldrh r2, [r3, #60] ; 0x3c 3000d958: e1c121b2 strh r2, [r1, #18]
buf->st_gid = the_jnode->st_gid;
3000d95c: e1d323be ldrh r2, [r3, #62] ; 0x3e 3000d960: e1c121b4 strh r2, [r1, #20]
buf->st_atime = the_jnode->stat_atime;
3000d964: e5932040 ldr r2, [r3, #64] ; 0x40 3000d968: e5812028 str r2, [r1, #40] ; 0x28
buf->st_mtime = the_jnode->stat_mtime;
3000d96c: e5932044 ldr r2, [r3, #68] ; 0x44
buf->st_ctime = the_jnode->stat_ctime;
3000d970: e5933048 ldr r3, [r3, #72] ; 0x48
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
3000d974: e5812030 str r2, [r1, #48] ; 0x30
buf->st_ctime = the_jnode->stat_ctime;
3000d978: e5813038 str r3, [r1, #56] ; 0x38
return 0;
}
3000d97c: e8bd8800 pop {fp, pc}
30005d58 <IMFS_symlink>:
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
30005d58: e92d40f0 push {r4, r5, r6, r7, lr}
30005d5c: e1a05000 mov r5, r0
30005d60: e24dd040 sub sp, sp, #64 ; 0x40
int i;
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
30005d64: e1a00002 mov r0, r2
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
30005d68: e1a06001 mov r6, r1 30005d6c: e1a07002 mov r7, r2
int i;
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
30005d70: eb002d1b bl 300111e4 <strlen> 30005d74: e28d4004 add r4, sp, #4 30005d78: e1a01000 mov r1, r0 30005d7c: e1a02004 mov r2, r4 30005d80: e28d303c add r3, sp, #60 ; 0x3c 30005d84: e1a00007 mov r0, r7 30005d88: eb001e5c bl 3000d700 <IMFS_get_token>
/*
* Duplicate link name
*/
info.sym_link.name = strdup(link_name);
30005d8c: e1a00006 mov r0, r6 30005d90: eb002cff bl 30011194 <strdup>
if (info.sym_link.name == NULL) {
30005d94: e3500000 cmp r0, #0
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
/*
* Duplicate link name
*/
info.sym_link.name = strdup(link_name);
30005d98: e58d0028 str r0, [sp, #40] ; 0x28
if (info.sym_link.name == NULL) {
30005d9c: 0a00000b beq 30005dd0 <IMFS_symlink+0x78>
new_node = IMFS_create_node(
parent_loc,
IMFS_SYM_LINK,
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
30005da0: e28d3028 add r3, sp, #40 ; 0x28
* was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node(
30005da4: e58d3000 str r3, [sp] 30005da8: e1a00005 mov r0, r5 30005dac: e3a01004 mov r1, #4 30005db0: e1a02004 mov r2, r4 30005db4: e59f302c ldr r3, [pc, #44] ; 30005de8 <IMFS_symlink+0x90> 30005db8: eb001bed bl 3000cd74 <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
30005dbc: e3500000 cmp r0, #0
free(info.sym_link.name);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
return 0;
30005dc0: 13a00000 movne r0, #0
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
30005dc4: 1a000005 bne 30005de0 <IMFS_symlink+0x88>
free(info.sym_link.name);
30005dc8: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED 30005dcc: eb000134 bl 300062a4 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
30005dd0: eb002919 bl 3001023c <__errno> <== NOT EXECUTED 30005dd4: e3a0300c mov r3, #12 <== NOT EXECUTED 30005dd8: e5803000 str r3, [r0] <== NOT EXECUTED 30005ddc: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
30005de0: e28dd040 add sp, sp, #64 ; 0x40
30005de4: e8bd80f0 pop {r4, r5, r6, r7, pc}
30005dec <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005dec: e92d40f0 push {r4, r5, r6, r7, lr}
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
30005df0: e5915000 ldr r5, [r1]
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005df4: e24dd01c sub sp, sp, #28
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30005df8: e595304c ldr r3, [r5, #76] ; 0x4c
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005dfc: e1a06000 mov r6, r0
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30005e00: e3530003 cmp r3, #3
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005e04: e1a04001 mov r4, r1
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30005e08: 1a000024 bne 30005ea0 <IMFS_unlink+0xb4>
if ( !node->info.hard_link.link_node )
30005e0c: e595e050 ldr lr, [r5, #80] ; 0x50 <== NOT EXECUTED 30005e10: e35e0000 cmp lr, #0 <== NOT EXECUTED 30005e14: 1a000003 bne 30005e28 <IMFS_unlink+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30005e18: eb002907 bl 3001023c <__errno> <== NOT EXECUTED 30005e1c: e3a03016 mov r3, #22 <== NOT EXECUTED 30005e20: e5803000 str r3, [r0] <== NOT EXECUTED 30005e24: ea000023 b 30005eb8 <IMFS_unlink+0xcc> <== NOT EXECUTED
the_link = *loc;
30005e28: e1a0c00d mov ip, sp <== NOT EXECUTED
30005e2c: e1a07001 mov r7, r1 <== NOT EXECUTED
30005e30: e8b7000f ldm r7!, {r0, r1, r2, r3} <== NOT EXECUTED
30005e34: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30005e38: e5973000 ldr r3, [r7] <== NOT EXECUTED
the_link.node_access = node->info.hard_link.link_node;
30005e3c: e28d701c add r7, sp, #28 <== NOT EXECUTED 30005e40: e527e01c str lr, [r7, #-28]! <== NOT EXECUTED
IMFS_Set_handlers( &the_link );
30005e44: e1a0000d mov r0, sp <== NOT EXECUTED
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
30005e48: e58c3000 str r3, [ip] <== NOT EXECUTED
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
30005e4c: eb001c28 bl 3000cef4 <IMFS_Set_handlers> <== NOT EXECUTED
/*
* If removing the last hard link to a node, then we need
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
30005e50: e5953050 ldr r3, [r5, #80] ; 0x50 <== NOT EXECUTED 30005e54: e1d323b4 ldrh r2, [r3, #52] ; 0x34 <== NOT EXECUTED 30005e58: e3520001 cmp r2, #1 <== NOT EXECUTED 30005e5c: 1a000007 bne 30005e80 <IMFS_unlink+0x94> <== NOT EXECUTED
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
30005e60: e1a00006 mov r0, r6 <== NOT EXECUTED 30005e64: e1a0100d mov r1, sp <== NOT EXECUTED 30005e68: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30005e6c: e1a0e00f mov lr, pc <== NOT EXECUTED 30005e70: e593f034 ldr pc, [r3, #52] ; 0x34 <== NOT EXECUTED
if ( result != 0 )
30005e74: e3500000 cmp r0, #0 <== NOT EXECUTED 30005e78: 0a000008 beq 30005ea0 <IMFS_unlink+0xb4> <== NOT EXECUTED 30005e7c: ea00000d b 30005eb8 <IMFS_unlink+0xcc> <== NOT EXECUTED
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
30005e80: e2422001 sub r2, r2, #1 <== NOT EXECUTED 30005e84: e1c323b4 strh r2, [r3, #52] ; 0x34 <== NOT EXECUTED
IMFS_update_ctime( node->info.hard_link.link_node );
30005e88: e28d0014 add r0, sp, #20 <== NOT EXECUTED 30005e8c: e3a01000 mov r1, #0 <== NOT EXECUTED 30005e90: eb00012c bl 30006348 <gettimeofday> <== NOT EXECUTED 30005e94: e5953050 ldr r3, [r5, #80] ; 0x50 <== NOT EXECUTED 30005e98: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 30005e9c: e5832048 str r2, [r3, #72] ; 0x48 <== NOT EXECUTED
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
30005ea0: e5943008 ldr r3, [r4, #8] 30005ea4: e1a00006 mov r0, r6 30005ea8: e1a01004 mov r1, r4 30005eac: e1a0e00f mov lr, pc 30005eb0: e593f034 ldr pc, [r3, #52] ; 0x34
return result;
30005eb4: ea000000 b 30005ebc <IMFS_unlink+0xd0>
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
if ( result != 0 )
return -1;
30005eb8: e3e00000 mvn r0, #0 <== NOT EXECUTED
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
return result;
}
30005ebc: e28dd01c add sp, sp, #28
30005ec0: e8bd80f0 pop {r4, r5, r6, r7, pc}
30005ec4 <IMFS_unmount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
30005ec4: e5903008 ldr r3, [r0, #8]
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
30005ec8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
30005ecc: e593204c ldr r2, [r3, #76] ; 0x4c 30005ed0: e3520001 cmp r2, #1
30005ed4: 0a000002 beq 30005ee4 <IMFS_unmount+0x20>
rtems_set_errno_and_return_minus_one( ENOTDIR );
30005ed8: eb0028d7 bl 3001023c <__errno> <== NOT EXECUTED 30005edc: e3a03014 mov r3, #20 <== NOT EXECUTED 30005ee0: ea000004 b 30005ef8 <IMFS_unmount+0x34> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
30005ee4: e593205c ldr r2, [r3, #92] ; 0x5c 30005ee8: e3520000 cmp r2, #0
30005eec: 1a000004 bne 30005f04 <IMFS_unmount+0x40>
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
30005ef0: eb0028d1 bl 3001023c <__errno> <== NOT EXECUTED
30005ef4: e3a03016 mov r3, #22 <== NOT EXECUTED
30005ef8: e5803000 str r3, [r0] <== NOT EXECUTED
30005efc: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005f00: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Set the mt_fs pointer to indicate that there is no longer
* a file system mounted to this point.
*/
node->info.directory.mt_fs = NULL;
30005f04: e3a00000 mov r0, #0 30005f08: e583005c str r0, [r3, #92] ; 0x5c
return 0;
}
30005f0c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30005f10 <IMFS_utime>:
int IMFS_utime(
rtems_filesystem_location_info_t *pathloc, /* IN */
time_t actime, /* IN */
time_t modtime /* IN */
)
{
30005f10: e92d4010 push {r4, lr} <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
30005f14: e5904000 ldr r4, [r0] <== NOT EXECUTED
the_jnode->stat_atime = actime;
the_jnode->stat_mtime = modtime;
the_jnode->stat_ctime = time( NULL );
30005f18: e3a00000 mov r0, #0 <== NOT EXECUTED
{
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
the_jnode->stat_atime = actime;
30005f1c: e5841040 str r1, [r4, #64] ; 0x40 <== NOT EXECUTED
the_jnode->stat_mtime = modtime;
30005f20: e5842044 str r2, [r4, #68] ; 0x44 <== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
30005f24: eb002d01 bl 30011330 <time> <== NOT EXECUTED 30005f28: e5840048 str r0, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
30005f2c: e3a00000 mov r0, #0 <== NOT EXECUTED
30005f30: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300064fc <RTEMS_Malloc_Initialize>:
)
{
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
300064fc: e59f30c4 ldr r3, [pc, #196] ; 300065c8 <RTEMS_Malloc_Initialize+0xcc>
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
30006500: e92d4070 push {r4, r5, r6, lr}
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
30006504: e5933000 ldr r3, [r3]
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
30006508: e1a04000 mov r4, r0
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
3000650c: e3530000 cmp r3, #0
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
30006510: e1a05001 mov r5, r1 30006514: e1a06002 mov r6, r2
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
(*rtems_malloc_statistics_helpers->initialize)();
30006518: 11a0e00f movne lr, pc 3000651c: 1593f000 ldrne pc, [r3]
}
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
30006520: ebffffe1 bl 300064ac <malloc_deferred_frees_initialize>
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
30006524: e59f30a0 ldr r3, [pc, #160] ; 300065cc <RTEMS_Malloc_Initialize+0xd0> 30006528: e5933000 ldr r3, [r3] 3000652c: e3530000 cmp r3, #0
30006530: 0a000005 beq 3000654c <RTEMS_Malloc_Initialize+0x50>
heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
30006534: e1a00004 mov r0, r4 <== NOT EXECUTED 30006538: e1a01006 mov r1, r6 <== NOT EXECUTED 3000653c: e1a0e00f mov lr, pc <== NOT EXECUTED 30006540: e593f000 ldr pc, [r3] <== NOT EXECUTED
heap_begin,
sbrk_amount
);
heap_size = (uintptr_t) sbrk_amount;
30006544: e1a05006 mov r5, r6 <== NOT EXECUTED
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
30006548: e1a04000 mov r4, r0 <== NOT EXECUTED
* of the time under UNIX because zero'ing memory when it is first
* given to a process eliminates the chance of a process seeing data
* left over from another process. This would be a security violation.
*/
if (
3000654c: e59f307c ldr r3, [pc, #124] ; 300065d0 <RTEMS_Malloc_Initialize+0xd4> 30006550: e5d31000 ldrb r1, [r3] 30006554: e3510000 cmp r1, #0
30006558: 1a000005 bne 30006574 <RTEMS_Malloc_Initialize+0x78>
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
3000655c: e59f3070 ldr r3, [pc, #112] ; 300065d4 <RTEMS_Malloc_Initialize+0xd8> 30006560: e5d33028 ldrb r3, [r3, #40] ; 0x28 30006564: e3530000 cmp r3, #0
) {
memset( heap_begin, 0, heap_size );
30006568: 11a00004 movne r0, r4 3000656c: 11a02005 movne r2, r5 30006570: 1b002996 blne 30010bd0 <memset>
* Unfortunately we cannot use assert if this fails because if this
* has failed we do not have a heap and if we do not have a heap
* STDIO cannot work because there will be no buffers.
*/
if ( !rtems_unified_work_area ) {
30006574: e59f3054 ldr r3, [pc, #84] ; 300065d0 <RTEMS_Malloc_Initialize+0xd4> 30006578: e5d33000 ldrb r3, [r3] 3000657c: e3530000 cmp r3, #0
30006580: 1a000008 bne 300065a8 <RTEMS_Malloc_Initialize+0xac>
void *area_begin,
uintptr_t area_size,
uintptr_t page_size
)
{
return _Heap_Initialize( heap, area_begin, area_size, page_size );
30006584: e59f304c ldr r3, [pc, #76] ; 300065d8 <RTEMS_Malloc_Initialize+0xdc> 30006588: e1a01004 mov r1, r4 3000658c: e5930000 ldr r0, [r3] 30006590: e1a02005 mov r2, r5 30006594: e3a03008 mov r3, #8 30006598: eb000fad bl 3000a454 <_Heap_Initialize>
RTEMS_Malloc_Heap,
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
3000659c: e3500000 cmp r0, #0
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
300065a0: 0280001a addeq r0, r0, #26 300065a4: 0b000d57 bleq 30009b08 <rtems_fatal_error_occurred>
}
}
MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
300065a8: e59f3028 ldr r3, [pc, #40] ; 300065d8 <RTEMS_Malloc_Initialize+0xdc> 300065ac: e59f4028 ldr r4, [pc, #40] ; 300065dc <RTEMS_Malloc_Initialize+0xe0> 300065b0: e5930000 ldr r0, [r3] 300065b4: e5945000 ldr r5, [r4] 300065b8: eb001229 bl 3000ae64 <_Protected_heap_Get_size> 300065bc: e0800005 add r0, r0, r5 300065c0: e5840000 str r0, [r4]
}
300065c4: e8bd8070 pop {r4, r5, r6, pc}
300059e8 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
300059e8: e92d4fff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}<== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
300059ec: e59030b8 ldr r3, [r0, #184] ; 0xb8 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
300059f0: e59070b4 ldr r7, [r0, #180] ; 0xb4 <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
300059f4: e2832010 add r2, r3, #16 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
300059f8: e2477010 sub r7, r7, #16 <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
300059fc: e3c71003 bic r1, r7, #3 <== NOT EXECUTED
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
30005a00: e1a05000 mov r5, r0 <== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
30005a04: e590b0e4 ldr fp, [r0, #228] ; 0xe4 <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
30005a08: e2820010 add r0, r2, #16 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
30005a0c: e0800001 add r0, r0, r1 <== NOT EXECUTED
* Try to print out how much stack was actually used by the task.
*/
static void *print_context;
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
30005a10: e2833020 add r3, r3, #32 <== NOT EXECUTED
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
30005a14: e59f10c0 ldr r1, [pc, #192] ; 30005adc <Stack_check_Dump_threads_usage+0xf4><== NOT EXECUTED 30005a18: ea000002 b 30005a28 <Stack_check_Dump_threads_usage+0x40> <== NOT EXECUTED 30005a1c: e493c004 ldr ip, [r3], #4 <== NOT EXECUTED 30005a20: e15c0001 cmp ip, r1 <== NOT EXECUTED 30005a24: 1a000004 bne 30005a3c <Stack_check_Dump_threads_usage+0x54><== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
30005a28: e1530000 cmp r3, r0 <== NOT EXECUTED
if (*base != U32_PATTERN)
30005a2c: e1a06003 mov r6, r3 <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
30005a30: 3afffff9 bcc 30005a1c <Stack_check_Dump_threads_usage+0x34><== NOT EXECUTED
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;
30005a34: e3a06000 mov r6, #0 <== NOT EXECUTED 30005a38: ea000002 b 30005a48 <Stack_check_Dump_threads_usage+0x60> <== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
30005a3c: e3560000 cmp r6, #0 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
30005a40: 10822007 addne r2, r2, r7 <== NOT EXECUTED 30005a44: 10666002 rsbne r6, r6, r2 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
#endif
{
(*print_handler)(
30005a48: e5958008 ldr r8, [r5, #8] <== NOT EXECUTED
30005a4c: e59f408c ldr r4, [pc, #140] ; 30005ae0 <Stack_check_Dump_threads_usage+0xf8><== NOT EXECUTED
30005a50: e3a01005 mov r1, #5 <== NOT EXECUTED
30005a54: e28d2008 add r2, sp, #8 <== NOT EXECUTED
30005a58: e1a00008 mov r0, r8 <== NOT EXECUTED
30005a5c: e8940600 ldm r4, {r9, sl} <== NOT EXECUTED
30005a60: eb000eee bl 30009620 <rtems_object_get_name> <== NOT EXECUTED
30005a64: e59f1078 ldr r1, [pc, #120] ; 30005ae4 <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
30005a68: e1a03000 mov r3, r0 <== NOT EXECUTED
30005a6c: e1a02008 mov r2, r8 <== NOT EXECUTED
30005a70: e1a0000a mov r0, sl <== NOT EXECUTED
30005a74: e1a0e00f mov lr, pc <== NOT EXECUTED
30005a78: e12fff19 bx r9 <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
30005a7c: e59530b4 ldr r3, [r5, #180] ; 0xb4 <== NOT EXECUTED 30005a80: e59520b8 ldr r2, [r5, #184] ; 0xb8 <== NOT EXECUTED 30005a84: e2433001 sub r3, r3, #1 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
30005a88: e0823003 add r3, r2, r3 <== NOT EXECUTED 30005a8c: e58db000 str fp, [sp] <== NOT EXECUTED 30005a90: e58d7004 str r7, [sp, #4] <== NOT EXECUTED 30005a94: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30005a98: e59f1048 ldr r1, [pc, #72] ; 30005ae8 <Stack_check_Dump_threads_usage+0x100><== NOT EXECUTED 30005a9c: e1a0e00f mov lr, pc <== NOT EXECUTED 30005aa0: e594f000 ldr pc, [r4] <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
30005aa4: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30005aa8: e3530000 cmp r3, #0 <== NOT EXECUTED 30005aac: 1a000004 bne 30005ac4 <Stack_check_Dump_threads_usage+0xdc><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
30005ab0: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30005ab4: e59f1030 ldr r1, [pc, #48] ; 30005aec <Stack_check_Dump_threads_usage+0x104><== NOT EXECUTED 30005ab8: e1a0e00f mov lr, pc <== NOT EXECUTED 30005abc: e594f000 ldr pc, [r4] <== NOT EXECUTED 30005ac0: ea000004 b 30005ad8 <Stack_check_Dump_threads_usage+0xf0> <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
30005ac4: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30005ac8: e59f1020 ldr r1, [pc, #32] ; 30005af0 <Stack_check_Dump_threads_usage+0x108><== NOT EXECUTED 30005acc: e1a02006 mov r2, r6 <== NOT EXECUTED 30005ad0: e1a0e00f mov lr, pc <== NOT EXECUTED 30005ad4: e594f000 ldr pc, [r4] <== NOT EXECUTED
}
}
30005ad8: e8bd8fff pop {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}<== NOT EXECUTED
30005b98 <Stack_check_report_blown_task>:
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
30005b98: e92d40ff push {r0, r1, r2, r3, r4, r5, r6, r7, lr} <== NOT EXECUTED
30005b9c: e1a06000 mov r6, r0 <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack);
30005ba0: e59040b8 ldr r4, [r0, #184] ; 0xb8 <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
30005ba4: e59f0078 ldr r0, [pc, #120] ; 30005c24 <Stack_check_report_blown_task+0x8c><== NOT EXECUTED
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
30005ba8: e20150ff and r5, r1, #255 ; 0xff <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
char name[32];
printk("BLOWN STACK!!!\n");
30005bac: eb000609 bl 300073d8 <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
30005bb0: e59f0070 ldr r0, [pc, #112] ; 30005c28 <Stack_check_report_blown_task+0x90><== NOT EXECUTED 30005bb4: e1a01006 mov r1, r6 <== NOT EXECUTED 30005bb8: eb000606 bl 300073d8 <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
30005bbc: e59f0068 ldr r0, [pc, #104] ; 30005c2c <Stack_check_report_blown_task+0x94><== NOT EXECUTED 30005bc0: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 30005bc4: eb000603 bl 300073d8 <printk> <== NOT EXECUTED
printk(
30005bc8: e59f0060 ldr r0, [pc, #96] ; 30005c30 <Stack_check_report_blown_task+0x98><== NOT EXECUTED 30005bcc: e596100c ldr r1, [r6, #12] <== NOT EXECUTED 30005bd0: eb000600 bl 300073d8 <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
30005bd4: e1a0200d mov r2, sp <== NOT EXECUTED 30005bd8: e3a01020 mov r1, #32 <== NOT EXECUTED 30005bdc: e5960008 ldr r0, [r6, #8] <== NOT EXECUTED 30005be0: eb000e8e bl 30009620 <rtems_object_get_name> <== NOT EXECUTED 30005be4: e1a01000 mov r1, r0 <== NOT EXECUTED 30005be8: e59f0044 ldr r0, [pc, #68] ; 30005c34 <Stack_check_report_blown_task+0x9c><== NOT EXECUTED 30005bec: eb0005f9 bl 300073d8 <printk> <== NOT EXECUTED
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
30005bf0: e59620b8 ldr r2, [r6, #184] ; 0xb8 <== NOT EXECUTED 30005bf4: e59610b4 ldr r1, [r6, #180] ; 0xb4 <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
30005bf8: e59f0038 ldr r0, [pc, #56] ; 30005c38 <Stack_check_report_blown_task+0xa0><== NOT EXECUTED 30005bfc: e0823001 add r3, r2, r1 <== NOT EXECUTED 30005c00: eb0005f4 bl 300073d8 <printk> <== NOT EXECUTED
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
30005c04: e3550000 cmp r5, #0 <== NOT EXECUTED
printk(
30005c08: 059f002c ldreq r0, [pc, #44] ; 30005c3c <Stack_check_report_blown_task+0xa4><== NOT EXECUTED 30005c0c: 03a01010 moveq r1, #16 <== NOT EXECUTED 30005c10: 02842008 addeq r2, r4, #8 <== NOT EXECUTED 30005c14: 02843018 addeq r3, r4, #24 <== NOT EXECUTED 30005c18: 0b0005ee bleq 300073d8 <printk> <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
30005c1c: e3a00081 mov r0, #129 ; 0x81 <== NOT EXECUTED 30005c20: eb001093 bl 30009e74 <rtems_fatal_error_occurred> <== NOT EXECUTED
3000f2c8 <TOD_MICROSECONDS_TO_TICKS>:
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
return (microseconds / rtems_configuration_get_microseconds_per_tick());
3000f2c8: e59f300c ldr r3, [pc, #12] ; 3000f2dc <TOD_MICROSECONDS_TO_TICKS+0x14><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
3000f2cc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (microseconds / rtems_configuration_get_microseconds_per_tick());
3000f2d0: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3000f2d4: eb004c64 bl 3002246c <__aeabi_uidiv> <== NOT EXECUTED
}
3000f2d8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000af1c <TOD_MILLISECONDS_TO_TICKS>:
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000af1c: e59f3020 ldr r3, [pc, #32] ; 3000af44 <TOD_MILLISECONDS_TO_TICKS+0x28><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000af20: e92d4010 push {r4, lr} <== NOT EXECUTED
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000af24: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000af28: e1a04000 mov r4, r0 <== NOT EXECUTED
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000af2c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000af30: eb003e86 bl 3001a950 <__aeabi_uidiv> <== NOT EXECUTED 3000af34: e1a01000 mov r1, r0 <== NOT EXECUTED 3000af38: e1a00004 mov r0, r4 <== NOT EXECUTED 3000af3c: eb003e83 bl 3001a950 <__aeabi_uidiv> <== NOT EXECUTED
}
3000af40: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30020d4c <TOD_TICKS_PER_SECOND_method>:
#include <rtems/config.h>
#include <rtems/score/tod.h>
uint32_t TOD_TICKS_PER_SECOND_method(void)
{
return (TOD_MICROSECONDS_PER_SECOND /
30020d4c: e59f3010 ldr r3, [pc, #16] ; 30020d64 <TOD_TICKS_PER_SECOND_method+0x18><== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/config.h>
#include <rtems/score/tod.h>
uint32_t TOD_TICKS_PER_SECOND_method(void)
{
30020d50: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (TOD_MICROSECONDS_PER_SECOND /
30020d54: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 30020d58: e59f0008 ldr r0, [pc, #8] ; 30020d68 <TOD_TICKS_PER_SECOND_method+0x1c><== NOT EXECUTED 30020d5c: ebfff5d4 bl 3001e4b4 <__aeabi_uidiv> <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
}
30020d60: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30011230 <_CORE_barrier_Wait>:
)
{
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
30011230: e59fc078 ldr ip, [pc, #120] ; 300112b0 <_CORE_barrier_Wait+0x80>
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
30011234: e92d4070 push {r4, r5, r6, lr}
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
30011238: e59cc004 ldr ip, [ip, #4]
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
3001123c: e3a04000 mov r4, #0 30011240: e58c4034 str r4, [ip, #52] ; 0x34
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
30011244: e59d2010 ldr r2, [sp, #16]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30011248: e10f4000 mrs r4, CPSR 3001124c: e3845080 orr r5, r4, #128 ; 0x80 30011250: e129f005 msr CPSR_fc, r5
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
30011254: e5905048 ldr r5, [r0, #72] ; 0x48
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
30011258: e5906040 ldr r6, [r0, #64] ; 0x40
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
3001125c: e2855001 add r5, r5, #1
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
30011260: e3560000 cmp r6, #0
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
30011264: e5805048 str r5, [r0, #72] ; 0x48
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
30011268: 1a000007 bne 3001128c <_CORE_barrier_Wait+0x5c>
if ( the_barrier->number_of_waiting_threads ==
3001126c: e5906044 ldr r6, [r0, #68] ; 0x44 <== NOT EXECUTED 30011270: e1550006 cmp r5, r6 <== NOT EXECUTED 30011274: 1a000004 bne 3001128c <_CORE_barrier_Wait+0x5c> <== NOT EXECUTED
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
30011278: e3a03001 mov r3, #1 <== NOT EXECUTED 3001127c: e58c3034 str r3, [ip, #52] ; 0x34 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30011280: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
30011284: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
_ISR_Enable( level );
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
30011288: eaffffdc b 30011200 <_CORE_barrier_Release> <== NOT EXECUTED
3001128c: e3a02001 mov r2, #1 30011290: e5802030 str r2, [r0, #48] ; 0x30
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
30011294: e58c0044 str r0, [ip, #68] ; 0x44
executing->Wait.id = id;
30011298: e58c1020 str r1, [ip, #32] 3001129c: e129f004 msr CPSR_fc, r4
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
300112a0: e59f200c ldr r2, [pc, #12] ; 300112b4 <_CORE_barrier_Wait+0x84> 300112a4: e1a01003 mov r1, r3
}
300112a8: e8bd4070 pop {r4, r5, r6, lr}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
300112ac: eafff1e9 b 3000da58 <_Thread_queue_Enqueue_with_handler>
300191ec <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
300191ec: e590304c ldr r3, [r0, #76] ; 0x4c
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
300191f0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
300191f4: e1520003 cmp r2, r3
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
300191f8: e1a06000 mov r6, r0 300191fc: e1a0a001 mov sl, r1 30019200: e1a07002 mov r7, r2 30019204: e59d8020 ldr r8, [sp, #32]
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
30019208: 8a000013 bhi 3001925c <_CORE_message_queue_Broadcast+0x70>
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
3001920c: e5905048 ldr r5, [r0, #72] ; 0x48 30019210: e3550000 cmp r5, #0
*count = 0;
30019214: 13a00000 movne r0, #0 30019218: 15880000 strne r0, [r8]
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
3001921c: 0a000007 beq 30019240 <_CORE_message_queue_Broadcast+0x54>
30019220: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30019224: e594002c ldr r0, [r4, #44] ; 0x2c 30019228: e1a0100a mov r1, sl 3001922c: e1a02007 mov r2, r7 30019230: eb001df8 bl 30020a18 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30019234: e5943028 ldr r3, [r4, #40] ; 0x28
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
30019238: e2855001 add r5, r5, #1
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
3001923c: e5837000 str r7, [r3]
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
30019240: e1a00006 mov r0, r6 30019244: eb000a87 bl 3001bc68 <_Thread_queue_Dequeue> 30019248: e2504000 subs r4, r0, #0
3001924c: 1afffff4 bne 30019224 <_CORE_message_queue_Broadcast+0x38>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
30019250: e5885000 str r5, [r8]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30019254: e1a00004 mov r0, r4
30019258: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
3001925c: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
30019260: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
300121e8 <_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
)
{
300121e8: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
300121ec: 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
)
{
300121f0: e1a04000 mov r4, r0
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
300121f4: 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
)
{
300121f8: e1a06002 mov r6, r2
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
300121fc: e5842044 str r2, [r4, #68] ; 0x44
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
)
{
30012200: e1a05001 mov r5, r1
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
30012204: e5840048 str r0, [r4, #72] ; 0x48
the_message_queue->maximum_message_size = maximum_message_size;
30012208: e584304c str r3, [r4, #76] ; 0x4c
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
3001220c: 01a02003 moveq r2, r3
30012210: 0a000003 beq 30012224 <_CORE_message_queue_Initialize+0x3c>
allocated_message_size += sizeof(uint32_t);
30012214: e2832004 add r2, r3, #4 <== NOT EXECUTED
allocated_message_size &= ~(sizeof(uint32_t) - 1);
30012218: e3c22003 bic r2, r2, #3 <== NOT EXECUTED
}
if (allocated_message_size < maximum_message_size)
3001221c: e1520003 cmp r2, r3 <== NOT EXECUTED
30012220: 38bd80f0 popcc {r4, r5, r6, r7, pc} <== NOT EXECUTED
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
30012224: e2827010 add r7, r2, #16
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
30012228: e0000796 mul r0, r6, r7
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
3001222c: e1500002 cmp r0, r2
return false;
30012230: 33a00000 movcc r0, #0
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
30012234: 38bd80f0 popcc {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 );
30012238: eb000b17 bl 30014e9c <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
3001223c: e3500000 cmp r0, #0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
30012240: e1a01000 mov r1, r0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
30012244: e584005c str r0, [r4, #92] ; 0x5c
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
30012248: 0a000013 beq 3001229c <_CORE_message_queue_Initialize+0xb4>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
3001224c: e2840060 add r0, r4, #96 ; 0x60 30012250: e1a02006 mov r2, r6 30012254: e1a03007 mov r3, r7 30012258: eb001252 bl 30016ba8 <_Chain_Initialize>
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 );
3001225c: e2843054 add r3, r4, #84 ; 0x54
head->next = tail;
30012260: e5843050 str r3, [r4, #80] ; 0x50
head->previous = NULL;
30012264: e3a03000 mov r3, #0 30012268: e5843054 str r3, [r4, #84] ; 0x54
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3001226c: e2843050 add r3, r4, #80 ; 0x50
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
30012270: e5843058 str r3, [r4, #88] ; 0x58
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
30012274: e5951000 ldr r1, [r5] 30012278: e1a00004 mov r0, r4 3001227c: e3510001 cmp r1, #1 30012280: 13a01000 movne r1, #0 30012284: 03a01001 moveq r1, #1 30012288: e3a02080 mov r2, #128 ; 0x80 3001228c: e3a03006 mov r3, #6 30012290: eb0008b3 bl 30014564 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
30012294: e3a00001 mov r0, #1
30012298: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
3001229c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3001238c <_CORE_message_queue_Submit>:
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
3001238c: e590304c ldr r3, [r0, #76] ; 0x4c
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30012390: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30012394: e1520003 cmp r2, r3
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30012398: e1a04000 mov r4, r0 3001239c: e1a0a001 mov sl, r1 300123a0: e1a05002 mov r5, r2 300123a4: e59d7020 ldr r7, [sp, #32]
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
300123a8: 83a00001 movhi r0, #1
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
300123ac: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
300123b0: e5948048 ldr r8, [r4, #72] ; 0x48 300123b4: e3580000 cmp r8, #0
300123b8: 1a00000b bne 300123ec <_CORE_message_queue_Submit+0x60>
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
300123bc: eb000769 bl 30014168 <_Thread_queue_Dequeue>
if ( the_thread ) {
300123c0: e2506000 subs r6, r0, #0
300123c4: 0a000008 beq 300123ec <_CORE_message_queue_Submit+0x60>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
300123c8: e596002c ldr r0, [r6, #44] ; 0x2c 300123cc: e1a0100a mov r1, sl 300123d0: e1a02005 mov r2, r5 300123d4: eb001b84 bl 300191ec <memcpy>
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
300123d8: e5963028 ldr r3, [r6, #40] ; 0x28
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
300123dc: e1a00008 mov r0, r8
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
300123e0: e5835000 str r5, [r3]
the_thread->Wait.count = (uint32_t) submit_type;
300123e4: e5867024 str r7, [r6, #36] ; 0x24
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
300123e8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* No one waiting on the message queue at this time, so attempt to
* queue the message up for a future receive.
*/
if ( the_message_queue->number_of_pending_messages <
300123ec: e5942048 ldr r2, [r4, #72] ; 0x48 300123f0: e5943044 ldr r3, [r4, #68] ; 0x44 300123f4: e1520003 cmp r2, r3
300123f8: 2a00000d bcs 30012434 <_CORE_message_queue_Submit+0xa8>
_CORE_message_queue_Allocate_message_buffer (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
_Chain_Get( &the_message_queue->Inactive_messages );
300123fc: e2840060 add r0, r4, #96 ; 0x60 30012400: ebffff61 bl 3001218c <_Chain_Get>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30012404: e1a0100a mov r1, sl
_CORE_message_queue_Allocate_message_buffer (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
_Chain_Get( &the_message_queue->Inactive_messages );
30012408: e1a06000 mov r6, r0
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
3001240c: e1a02005 mov r2, r5 30012410: e280000c add r0, r0, #12 30012414: eb001b74 bl 300191ec <memcpy>
size
);
the_message->Contents.size = size;
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
30012418: e1a00004 mov r0, r4
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
3001241c: e5865008 str r5, [r6, #8]
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
30012420: e1a01006 mov r1, r6 30012424: e1a02007 mov r2, r7 30012428: eb0011ee bl 30016be8 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
3001242c: e3a00000 mov r0, #0
30012430: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
}
#if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND)
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
30012434: e3a00002 mov r0, #2 <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
30012438: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30009f58 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
30009f58: e92d40f0 push {r4, r5, r6, r7, lr}
30009f5c: e1a07003 mov r7, r3
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
30009f60: e59f30ac ldr r3, [pc, #172] ; 3000a014 <_CORE_mutex_Seize+0xbc>
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
30009f64: e1a04000 mov r4, r0
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
30009f68: e5933000 ldr r3, [r3]
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
30009f6c: e1a05001 mov r5, r1
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
30009f70: e3530000 cmp r3, #0
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
30009f74: e20260ff and r6, r2, #255 ; 0xff
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 30009f78: 0a000008 beq 30009fa0 <_CORE_mutex_Seize+0x48>
30009f7c: e3560000 cmp r6, #0
30009f80: 0a000006 beq 30009fa0 <_CORE_mutex_Seize+0x48>
30009f84: e59f308c ldr r3, [pc, #140] ; 3000a018 <_CORE_mutex_Seize+0xc0>
30009f88: e5933000 ldr r3, [r3]
30009f8c: e3530001 cmp r3, #1
30009f90: 83a00000 movhi r0, #0
30009f94: 81a01000 movhi r1, r0
30009f98: 83a02012 movhi r2, #18
30009f9c: 8b0001bf blhi 3000a6a0 <_Internal_error_Occurred>
30009fa0: e1a00004 mov r0, r4
30009fa4: e28d1014 add r1, sp, #20
30009fa8: eb001164 bl 3000e540 <_CORE_mutex_Seize_interrupt_trylock>
30009fac: e3500000 cmp r0, #0
30009fb0: 08bd80f0 popeq {r4, r5, r6, r7, pc}
30009fb4: e3560000 cmp r6, #0
30009fb8: e59f305c ldr r3, [pc, #92] ; 3000a01c <_CORE_mutex_Seize+0xc4>
30009fbc: 1a000005 bne 30009fd8 <_CORE_mutex_Seize+0x80>
30009fc0: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
30009fc4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
30009fc8: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
30009fcc: e3a02001 mov r2, #1 <== NOT EXECUTED
30009fd0: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
30009fd4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30009fd8: e5933004 ldr r3, [r3, #4]
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30009fdc: e3a02001 mov r2, #1
30009fe0: e5842030 str r2, [r4, #48] ; 0x30
30009fe4: e5834044 str r4, [r3, #68] ; 0x44
30009fe8: e5835020 str r5, [r3, #32]
30009fec: e59f3020 ldr r3, [pc, #32] ; 3000a014 <_CORE_mutex_Seize+0xbc>
30009ff0: e5932000 ldr r2, [r3]
30009ff4: e2822001 add r2, r2, #1
30009ff8: e5832000 str r2, [r3]
30009ffc: e59d3014 ldr r3, [sp, #20]
3000a000: e129f003 msr CPSR_fc, r3
3000a004: e1a00004 mov r0, r4
3000a008: e1a01007 mov r1, r7
3000a00c: ebffffb8 bl 30009ef4 <_CORE_mutex_Seize_interrupt_blocking>
3000a010: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000e540 <_CORE_mutex_Seize_interrupt_trylock>:
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
3000e540: e1a03000 mov r3, r0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000e544: e59f210c ldr r2, [pc, #268] ; 3000e658 <_CORE_mutex_Seize_interrupt_trylock+0x118>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000e548: e593c050 ldr ip, [r3, #80] ; 0x50
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000e54c: e3a00000 mov r0, #0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000e550: e5922004 ldr r2, [r2, #4]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000e554: e15c0000 cmp ip, r0
3000e558: e92d4010 push {r4, lr}
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000e55c: e5820034 str r0, [r2, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000e560: 0a00002c beq 3000e618 <_CORE_mutex_Seize_interrupt_trylock+0xd8>
the_mutex->lock = CORE_MUTEX_LOCKED;
3000e564: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
3000e568: e5920008 ldr r0, [r2, #8]
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
3000e56c: e583205c str r2, [r3, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
3000e570: e5830060 str r0, [r3, #96] ; 0x60
the_mutex->nest_count = 1;
3000e574: e3a00001 mov r0, #1 3000e578: e5830054 str r0, [r3, #84] ; 0x54
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
3000e57c: e5930048 ldr r0, [r3, #72] ; 0x48
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000e580: e3500002 cmp r0, #2
3000e584: 0a000001 beq 3000e590 <_CORE_mutex_Seize_interrupt_trylock+0x50>
3000e588: e3500003 cmp r0, #3
3000e58c: 1a000004 bne 3000e5a4 <_CORE_mutex_Seize_interrupt_trylock+0x64>
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000e590: e592c01c ldr ip, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
3000e594: e3500003 cmp r0, #3
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000e598: e28c4001 add r4, ip, #1 3000e59c: e582401c str r4, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
3000e5a0: 0a000000 beq 3000e5a8 <_CORE_mutex_Seize_interrupt_trylock+0x68>
_ISR_Enable( *level_p );
3000e5a4: ea000025 b 3000e640 <_CORE_mutex_Seize_interrupt_trylock+0x100>
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
3000e5a8: e593004c ldr r0, [r3, #76] ; 0x4c
current = executing->current_priority;
3000e5ac: e5924014 ldr r4, [r2, #20]
if ( current == ceiling ) {
3000e5b0: e1540000 cmp r4, r0
3000e5b4: 1a000000 bne 3000e5bc <_CORE_mutex_Seize_interrupt_trylock+0x7c>
_ISR_Enable( *level_p );
3000e5b8: ea000020 b 3000e640 <_CORE_mutex_Seize_interrupt_trylock+0x100><== NOT EXECUTED
return 0;
}
if ( current > ceiling ) {
3000e5bc: 9a00000b bls 3000e5f0 <_CORE_mutex_Seize_interrupt_trylock+0xb0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000e5c0: e59f2094 ldr r2, [pc, #148] ; 3000e65c <_CORE_mutex_Seize_interrupt_trylock+0x11c><== NOT EXECUTED 3000e5c4: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000e5c8: e2800001 add r0, r0, #1 <== NOT EXECUTED 3000e5cc: e5820000 str r0, [r2] <== NOT EXECUTED 3000e5d0: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000e5d4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
3000e5d8: e3a02000 mov r2, #0 <== NOT EXECUTED 3000e5dc: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED 3000e5e0: e593104c ldr r1, [r3, #76] ; 0x4c <== NOT EXECUTED 3000e5e4: ebfff376 bl 3000b3c4 <_Thread_Change_priority> <== NOT EXECUTED
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
3000e5e8: ebfff479 bl 3000b7d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000e5ec: ea000015 b 3000e648 <_CORE_mutex_Seize_interrupt_trylock+0x108><== NOT EXECUTED
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
3000e5f0: e3a00005 mov r0, #5 3000e5f4: e5820034 str r0, [r2, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000e5f8: e3a00001 mov r0, #1 3000e5fc: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
3000e600: e3a00000 mov r0, #0 3000e604: e5830054 str r0, [r3, #84] ; 0x54
executing->resource_count--; /* undo locking above */
3000e608: e582c01c str ip, [r2, #28]
3000e60c: e5913000 ldr r3, [r1]
3000e610: e129f003 msr CPSR_fc, r3
3000e614: e8bd8010 pop {r4, pc}
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
3000e618: e593005c ldr r0, [r3, #92] ; 0x5c 3000e61c: e1500002 cmp r0, r2
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000e620: 13a00001 movne r0, #1
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
3000e624: 18bd8010 popne {r4, pc}
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
3000e628: e5932040 ldr r2, [r3, #64] ; 0x40 3000e62c: e3520000 cmp r2, #0
3000e630: 1a000006 bne 3000e650 <_CORE_mutex_Seize_interrupt_trylock+0x110>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
3000e634: e5932054 ldr r2, [r3, #84] ; 0x54 3000e638: e2822001 add r2, r2, #1 3000e63c: e5832054 str r2, [r3, #84] ; 0x54 3000e640: e5913000 ldr r3, [r1] 3000e644: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
3000e648: e3a00000 mov r0, #0
3000e64c: e8bd8010 pop {r4, pc}
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000e650: e3a00001 mov r0, #1
3000e654: e8bd8010 pop {r4, pc}
3000a020 <_CORE_mutex_Surrender>:
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
3000a020: e92d4030 push {r4, r5, lr}
3000a024: e1a04000 mov r4, r0
* allowed when the mutex in quetion is FIFO or simple Priority
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
3000a028: e5d43044 ldrb r3, [r4, #68] ; 0x44
)
{
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
3000a02c: e590005c ldr r0, [r0, #92] ; 0x5c
* allowed when the mutex in quetion is FIFO or simple Priority
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
3000a030: e3530000 cmp r3, #0
3000a034: 0a000004 beq 3000a04c <_CORE_mutex_Surrender+0x2c>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000a038: e59f30ec ldr r3, [pc, #236] ; 3000a12c <_CORE_mutex_Surrender+0x10c>
if ( !_Thread_Is_executing( holder ) )
3000a03c: e5933004 ldr r3, [r3, #4] 3000a040: e1500003 cmp r0, r3
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
3000a044: 13a05002 movne r5, #2
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
if ( !_Thread_Is_executing( holder ) )
3000a048: 1a000035 bne 3000a124 <_CORE_mutex_Surrender+0x104>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
3000a04c: e5945054 ldr r5, [r4, #84] ; 0x54 3000a050: e3550000 cmp r5, #0
3000a054: 0a000032 beq 3000a124 <_CORE_mutex_Surrender+0x104>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000a058: e2455001 sub r5, r5, #1
if ( the_mutex->nest_count != 0 ) {
3000a05c: e3550000 cmp r5, #0
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000a060: e5845054 str r5, [r4, #84] ; 0x54
/* Currently no API exercises this behavior. */
break;
}
#else
/* must be CORE_MUTEX_NESTING_ACQUIRES or we wouldn't be here */
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a064: 13a05000 movne r5, #0
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
3000a068: 1a00002d bne 3000a124 <_CORE_mutex_Surrender+0x104>
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
3000a06c: e5943048 ldr r3, [r4, #72] ; 0x48
/*
* Formally release the mutex before possibly transferring it to a
* blocked thread.
*/
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000a070: e3530002 cmp r3, #2
3000a074: 0a000001 beq 3000a080 <_CORE_mutex_Surrender+0x60>
3000a078: e3530003 cmp r3, #3
3000a07c: 1a000009 bne 3000a0a8 <_CORE_mutex_Surrender+0x88>
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000a080: e590301c ldr r3, [r0, #28] 3000a084: e2433001 sub r3, r3, #1
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
3000a088: e3530000 cmp r3, #0
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000a08c: e580301c str r3, [r0, #28]
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
3000a090: 1a000004 bne 3000a0a8 <_CORE_mutex_Surrender+0x88>
holder->real_priority != holder->current_priority ) {
3000a094: e5901018 ldr r1, [r0, #24]
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
3000a098: e5903014 ldr r3, [r0, #20] 3000a09c: e1510003 cmp r1, r3
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
3000a0a0: 13a02001 movne r2, #1 3000a0a4: 1b0004c6 blne 3000b3c4 <_Thread_Change_priority>
}
}
the_mutex->holder = NULL;
3000a0a8: e3a05000 mov r5, #0 3000a0ac: e584505c str r5, [r4, #92] ; 0x5c
the_mutex->holder_id = 0;
3000a0b0: e5845060 str r5, [r4, #96] ; 0x60
/*
* Now we check if another thread was waiting for this mutex. If so,
* transfer the mutex to that thread.
*/
if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
3000a0b4: e1a00004 mov r0, r4 3000a0b8: eb000683 bl 3000bacc <_Thread_queue_Dequeue> 3000a0bc: e2503000 subs r3, r0, #0
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000a0c0: 03a02001 moveq r2, #1 3000a0c4: 05842050 streq r2, [r4, #80] ; 0x50
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a0c8: 01a05003 moveq r5, r3
/*
* Now we check if another thread was waiting for this mutex. If so,
* transfer the mutex to that thread.
*/
if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
3000a0cc: 0a000014 beq 3000a124 <_CORE_mutex_Surrender+0x104>
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000a0d0: e5932008 ldr r2, [r3, #8]
} else
#endif
{
the_mutex->holder = the_thread;
3000a0d4: e584305c str r3, [r4, #92] ; 0x5c
the_mutex->holder_id = the_thread->Object.id;
3000a0d8: e5842060 str r2, [r4, #96] ; 0x60
the_mutex->nest_count = 1;
3000a0dc: e3a02001 mov r2, #1 3000a0e0: e5842054 str r2, [r4, #84] ; 0x54
switch ( the_mutex->Attributes.discipline ) {
3000a0e4: e5942048 ldr r2, [r4, #72] ; 0x48 3000a0e8: e3520002 cmp r2, #2
case CORE_MUTEX_DISCIPLINES_FIFO:
case CORE_MUTEX_DISCIPLINES_PRIORITY:
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000a0ec: 0593201c ldreq r2, [r3, #28] 3000a0f0: 02822001 addeq r2, r2, #1 3000a0f4: 0583201c streq r2, [r3, #28]
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000a0f8: 0a000009 beq 3000a124 <_CORE_mutex_Surrender+0x104>
3000a0fc: e3520003 cmp r2, #3 <== NOT EXECUTED 3000a100: 1a000007 bne 3000a124 <_CORE_mutex_Surrender+0x104> <== NOT EXECUTED
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000a104: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000a108: e594104c ldr r1, [r4, #76] ; 0x4c <== NOT EXECUTED
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000a10c: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000a110: e583201c str r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000a114: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED 3000a118: e1510003 cmp r1, r3 <== NOT EXECUTED
the_thread->current_priority){
_Thread_Change_priority(
3000a11c: 31a02005 movcc r2, r5 <== NOT EXECUTED 3000a120: 3b0004a7 blcc 3000b3c4 <_Thread_Change_priority> <== NOT EXECUTED
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
3000a124: e1a00005 mov r0, r5
3000a128: e8bd8030 pop {r4, r5, pc}
3000a730 <_Chain_Append_with_empty_check>:
bool _Chain_Append_with_empty_check(
Chain_Control *chain,
Chain_Node *node
)
{
3000a730: e92d4010 push {r4, lr} <== NOT EXECUTED
3000a734: e1a03000 mov r3, r0 <== NOT EXECUTED
3000a738: e10f4000 mrs r4, CPSR <== NOT EXECUTED
3000a73c: e3842080 orr r2, r4, #128 ; 0x80 <== NOT EXECUTED
3000a740: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3000a744: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000a748: e280c004 add ip, r0, #4 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000a74c: e5900000 ldr r0, [r0] <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3000a750: e5831008 str r1, [r3, #8] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3000a754: e581c000 str ip, [r1] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
3000a758: e5812004 str r2, [r1, #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;
3000a75c: e5821000 str r1, [r2] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000a760: e150000c cmp r0, ip <== NOT EXECUTED 3000a764: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a768: 03a00001 moveq r0, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a76c: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Disable( level );
was_empty = _Chain_Append_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return was_empty;
}
3000a770: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a7c0 <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
3000a7c0: e92d4010 push {r4, lr} <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a7c4: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000a7c8: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000a7cc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
)
{
bool is_empty_now = true;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_first = head->next;
3000a7d0: e5902000 ldr r2, [r0] <== NOT EXECUTED
Chain_Node **the_node
)
{
bool is_empty_now = true;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000a7d4: e280c004 add ip, r0, #4 <== NOT EXECUTED
Chain_Node *old_first = head->next;
if ( old_first != tail ) {
3000a7d8: e152000c cmp r2, ip <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
} else
*the_node = NULL;
3000a7dc: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000a7e0: 05813000 streq r3, [r1] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Get_with_empty_check_unprotected(
Chain_Control *the_chain,
Chain_Node **the_node
)
{
bool is_empty_now = true;
3000a7e4: 03a00001 moveq r0, #1 <== NOT EXECUTED
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_first = head->next;
if ( old_first != tail ) {
3000a7e8: 0a000006 beq 3000a808 <_Chain_Get_with_empty_check+0x48> <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
3000a7ec: e5923000 ldr r3, [r2] <== NOT EXECUTED
head->next = new_first;
3000a7f0: e5803000 str r3, [r0] <== NOT EXECUTED
new_first->previous = head;
3000a7f4: e5830004 str r0, [r3, #4] <== NOT EXECUTED
*the_node = old_first;
3000a7f8: e5812000 str r2, [r1] <== NOT EXECUTED
is_empty_now = new_first == tail;
3000a7fc: e153000c cmp r3, ip <== NOT EXECUTED 3000a800: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a804: 03a00001 moveq r0, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a808: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Disable( level );
is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return is_empty_now;
}
3000a80c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a86c <_Chain_Prepend_with_empty_check>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a86c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000a870: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000a874: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Disable( level );
was_empty = _Chain_Prepend_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return was_empty;
}
3000a878: e5903000 ldr r3, [r0] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000a87c: e5810004 str r0, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000a880: e4801004 str r1, [r0], #4 <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000a884: e5831004 str r1, [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;
3000a888: e5813000 str r3, [r1] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a88c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3000a890: e1530000 cmp r3, r0 <== NOT EXECUTED 3000a894: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a898: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000a89c: e12fff1e bx lr <== NOT EXECUTED
30008f48 <_Event_Seize>:
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
30008f48: e59fc0f8 ldr ip, [pc, #248] ; 30009048 <_Event_Seize+0x100>
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
30008f4c: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
30008f50: e59c4004 ldr r4, [ip, #4]
executing->Wait.return_code = RTEMS_SUCCESSFUL;
30008f54: e3a0c000 mov ip, #0 30008f58: e584c034 str ip, [r4, #52] ; 0x34
api = executing->API_Extensions[ THREAD_API_RTEMS ];
30008f5c: e59470f4 ldr r7, [r4, #244] ; 0xf4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008f60: e10f5000 mrs r5, CPSR 30008f64: e385c080 orr ip, r5, #128 ; 0x80 30008f68: e129f00c msr CPSR_fc, ip
_ISR_Disable( level );
pending_events = api->pending_events;
30008f6c: e5976000 ldr r6, [r7]
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
30008f70: e010c006 ands ip, r0, r6
30008f74: 0a000007 beq 30008f98 <_Event_Seize+0x50>
30008f78: e15c0000 cmp ip, r0
30008f7c: 0a000001 beq 30008f88 <_Event_Seize+0x40>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
30008f80: e3110002 tst r1, #2 <== NOT EXECUTED 30008f84: 0a000003 beq 30008f98 <_Event_Seize+0x50> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
30008f88: e1c6600c bic r6, r6, ip
api->pending_events =
30008f8c: e5876000 str r6, [r7]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30008f90: e129f005 msr CPSR_fc, r5 30008f94: ea000004 b 30008fac <_Event_Seize+0x64>
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
30008f98: e3110001 tst r1, #1
30008f9c: 0a000004 beq 30008fb4 <_Event_Seize+0x6c>
30008fa0: e129f005 msr CPSR_fc, r5
_ISR_Enable( level );
executing->Wait.return_code = RTEMS_UNSATISFIED;
30008fa4: e3a0200d mov r2, #13 30008fa8: e5842034 str r2, [r4, #52] ; 0x34
*event_out = seized_events;
30008fac: e583c000 str ip, [r3]
return;
30008fb0: e8bd80f0 pop {r4, r5, r6, r7, pc}
* NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set; executing->Wait.count = (uint32_t) event_in; executing->Wait.return_argument = event_out;
30008fb4: e5843028 str r3, [r4, #40] ; 0x28
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30008fb8: e59f308c ldr r3, [pc, #140] ; 3000904c <_Event_Seize+0x104>
* set properly when we are marked as in the event critical section. * * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set;
30008fbc: e5841030 str r1, [r4, #48] ; 0x30
executing->Wait.count = (uint32_t) event_in;
executing->Wait.return_argument = event_out;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30008fc0: e3a01001 mov r1, #1
* * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set; executing->Wait.count = (uint32_t) event_in;
30008fc4: e5840024 str r0, [r4, #36] ; 0x24
executing->Wait.return_argument = event_out;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30008fc8: e5831000 str r1, [r3] 30008fcc: e129f005 msr CPSR_fc, r5
_ISR_Enable( level );
if ( ticks ) {
30008fd0: e3520000 cmp r2, #0
30008fd4: 0a00000a beq 30009004 <_Event_Seize+0xbc>
_Watchdog_Initialize(
30008fd8: e5941008 ldr r1, [r4, #8]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30008fdc: e59f006c ldr r0, [pc, #108] ; 30009050 <_Event_Seize+0x108>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30008fe0: e3a03000 mov r3, #0
the_watchdog->routine = routine;
30008fe4: e5840064 str r0, [r4, #100] ; 0x64
the_watchdog->id = id;
30008fe8: e5841068 str r1, [r4, #104] ; 0x68
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30008fec: e5843050 str r3, [r4, #80] ; 0x50
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
30008ff0: e584306c str r3, [r4, #108] ; 0x6c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30008ff4: e5842054 str r2, [r4, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30008ff8: e59f0054 ldr r0, [pc, #84] ; 30009054 <_Event_Seize+0x10c> 30008ffc: e2841048 add r1, r4, #72 ; 0x48 30009000: eb000d43 bl 3000c514 <_Watchdog_Insert>
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
30009004: e1a00004 mov r0, r4 30009008: e3a01c01 mov r1, #256 ; 0x100 3000900c: eb000bf3 bl 3000bfe0 <_Thread_Set_state>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30009010: e10f2000 mrs r2, CPSR 30009014: e3823080 orr r3, r2, #128 ; 0x80 30009018: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
sync_state = _Event_Sync_state;
3000901c: e59f3028 ldr r3, [pc, #40] ; 3000904c <_Event_Seize+0x104>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
30009020: e3a01000 mov r1, #0
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
_ISR_Disable( level );
sync_state = _Event_Sync_state;
30009024: e5930000 ldr r0, [r3]
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
30009028: e5831000 str r1, [r3]
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
3000902c: e3500001 cmp r0, #1
30009030: 1a000001 bne 3000903c <_Event_Seize+0xf4>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009034: e129f002 msr CPSR_fc, r2
30009038: e8bd80f0 pop {r4, r5, r6, r7, pc}
* An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level );
3000903c: e1a01004 mov r1, r4 <== NOT EXECUTED
}
30009040: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
* An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level );
30009044: ea0008cb b 3000b378 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED
300090a8 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
300090a8: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
300090ac: e590c0f4 ldr ip, [r0, #244] ; 0xf4
option_set = (rtems_option) the_thread->Wait.option;
300090b0: e5905030 ldr r5, [r0, #48] ; 0x30
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
300090b4: e1a04000 mov r4, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300090b8: e10f3000 mrs r3, CPSR 300090bc: e3832080 orr r2, r3, #128 ; 0x80 300090c0: e129f002 msr CPSR_fc, r2
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
pending_events = api->pending_events;
300090c4: e59c1000 ldr r1, [ip]
event_condition = (rtems_event_set) the_thread->Wait.count;
300090c8: e5900024 ldr r0, [r0, #36] ; 0x24
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
300090cc: e0102001 ands r2, r0, r1
300090d0: 1a000000 bne 300090d8 <_Event_Surrender+0x30>
_ISR_Enable( level );
300090d4: ea000039 b 300091c0 <_Event_Surrender+0x118>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
300090d8: e59f60e8 ldr r6, [pc, #232] ; 300091c8 <_Event_Surrender+0x120> 300090dc: e5967000 ldr r7, [r6] 300090e0: e3570000 cmp r7, #0
300090e4: 0a000017 beq 30009148 <_Event_Surrender+0xa0>
300090e8: e5966004 ldr r6, [r6, #4] <== NOT EXECUTED 300090ec: e1540006 cmp r4, r6 <== NOT EXECUTED 300090f0: 1a000014 bne 30009148 <_Event_Surrender+0xa0> <== NOT EXECUTED
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
300090f4: e59f60d0 ldr r6, [pc, #208] ; 300091cc <_Event_Surrender+0x124><== NOT EXECUTED 300090f8: e5967000 ldr r7, [r6] <== NOT EXECUTED
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
300090fc: e3570002 cmp r7, #2 <== NOT EXECUTED 30009100: 0a000002 beq 30009110 <_Event_Surrender+0x68> <== NOT EXECUTED
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
30009104: e5966000 ldr r6, [r6] <== NOT EXECUTED
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
30009108: e3560001 cmp r6, #1 <== NOT EXECUTED 3000910c: 1a00000d bne 30009148 <_Event_Surrender+0xa0> <== NOT EXECUTED
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
30009110: e1520000 cmp r2, r0 <== NOT EXECUTED 30009114: 0a000001 beq 30009120 <_Event_Surrender+0x78> <== NOT EXECUTED 30009118: e3150002 tst r5, #2 <== NOT EXECUTED 3000911c: 0a000008 beq 30009144 <_Event_Surrender+0x9c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
30009120: e1c11002 bic r1, r1, r2 <== NOT EXECUTED
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
30009124: e58c1000 str r1, [ip] <== NOT EXECUTED
the_thread->Wait.count = 0;
30009128: e3a01000 mov r1, #0 <== NOT EXECUTED 3000912c: e5841024 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
30009130: e5941028 ldr r1, [r4, #40] ; 0x28 <== NOT EXECUTED 30009134: e5812000 str r2, [r1] <== NOT EXECUTED
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
30009138: e59f208c ldr r2, [pc, #140] ; 300091cc <_Event_Surrender+0x124><== NOT EXECUTED 3000913c: e3a01003 mov r1, #3 <== NOT EXECUTED 30009140: e5821000 str r1, [r2] <== NOT EXECUTED
}
_ISR_Enable( level );
30009144: ea00001d b 300091c0 <_Event_Surrender+0x118> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
30009148: e5946010 ldr r6, [r4, #16]
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
3000914c: e3160c01 tst r6, #256 ; 0x100
30009150: 0a00001a beq 300091c0 <_Event_Surrender+0x118>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
30009154: e1520000 cmp r2, r0
30009158: 0a000001 beq 30009164 <_Event_Surrender+0xbc>
3000915c: e3150002 tst r5, #2 <== NOT EXECUTED 30009160: 0a000016 beq 300091c0 <_Event_Surrender+0x118> <== NOT EXECUTED
30009164: e1c11002 bic r1, r1, r2
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
30009168: e58c1000 str r1, [ip]
the_thread->Wait.count = 0;
3000916c: e3a01000 mov r1, #0 30009170: e5841024 str r1, [r4, #36] ; 0x24
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
30009174: e5941028 ldr r1, [r4, #40] ; 0x28 30009178: e5812000 str r2, [r1]
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000917c: e10f2000 mrs r2, CPSR 30009180: e129f003 msr CPSR_fc, r3 30009184: e129f002 msr CPSR_fc, r2
_ISR_Flash( level );
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30009188: e5942050 ldr r2, [r4, #80] ; 0x50 3000918c: e3520002 cmp r2, #2
30009190: 0a000001 beq 3000919c <_Event_Surrender+0xf4>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009194: e129f003 msr CPSR_fc, r3 30009198: ea000004 b 300091b0 <_Event_Surrender+0x108>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000919c: e3a02003 mov r2, #3 <== NOT EXECUTED 300091a0: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 300091a4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
300091a8: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 300091ac: eb000d30 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
300091b0: e59f1018 ldr r1, [pc, #24] ; 300091d0 <_Event_Surrender+0x128> 300091b4: e1a00004 mov r0, r4
}
return;
}
}
_ISR_Enable( level );
}
300091b8: e8bd40f0 pop {r4, r5, r6, r7, lr}
300091bc: ea0008bf b 3000b4c0 <_Thread_Clear_state>
300091c0: e129f003 msr CPSR_fc, r3
300091c4: e8bd80f0 pop {r4, r5, r6, r7, pc}
300091d4 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
300091d4: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
300091d8: e1a0100d mov r1, sp <== NOT EXECUTED 300091dc: eb000985 bl 3000b7f8 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
300091e0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300091e4: e3530000 cmp r3, #0 <== NOT EXECUTED 300091e8: 1a000015 bne 30009244 <_Event_Timeout+0x70> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300091ec: e10f2000 mrs r2, CPSR <== NOT EXECUTED 300091f0: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 300091f4: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
300091f8: e5803024 str r3, [r0, #36] ; 0x24 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
300091fc: e59f3044 ldr r3, [pc, #68] ; 30009248 <_Event_Timeout+0x74><== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) ) {
30009200: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30009204: e1500003 cmp r0, r3 <== NOT EXECUTED 30009208: 1a000004 bne 30009220 <_Event_Timeout+0x4c> <== NOT EXECUTED
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
3000920c: e59f3038 ldr r3, [pc, #56] ; 3000924c <_Event_Timeout+0x78><== NOT EXECUTED 30009210: e5931000 ldr r1, [r3] <== NOT EXECUTED 30009214: e3510001 cmp r1, #1 <== NOT EXECUTED
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
30009218: 02811001 addeq r1, r1, #1 <== NOT EXECUTED 3000921c: 05831000 streq r1, [r3] <== NOT EXECUTED
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
30009220: e3a03006 mov r3, #6 <== NOT EXECUTED 30009224: e5803034 str r3, [r0, #52] ; 0x34 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009228: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000922c: e59f101c ldr r1, [pc, #28] ; 30009250 <_Event_Timeout+0x7c><== NOT EXECUTED 30009230: eb0008a2 bl 3000b4c0 <_Thread_Clear_state> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
30009234: e59f3018 ldr r3, [pc, #24] ; 30009254 <_Event_Timeout+0x80><== NOT EXECUTED 30009238: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000923c: e2422001 sub r2, r2, #1 <== NOT EXECUTED 30009240: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
30009244: e8bd8008 pop {r3, pc} <== NOT EXECUTED
3000e6bc <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000e6bc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000e6c0: 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;
3000e6c4: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000e6c8: e24dd01c sub sp, sp, #28 3000e6cc: e1a0b003 mov fp, r3
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3000e6d0: e2913004 adds r3, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000e6d4: e1a05000 mov r5, r0 3000e6d8: e1a06001 mov r6, r1
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;
3000e6dc: e58d2000 str r2, [sp]
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3000e6e0: e58d300c str r3, [sp, #12]
3000e6e4: 2a00006a bcs 3000e894 <_Heap_Allocate_aligned_with_boundary+0x1d8>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
3000e6e8: e35b0000 cmp fp, #0
3000e6ec: 0a000003 beq 3000e700 <_Heap_Allocate_aligned_with_boundary+0x44>
if ( boundary < alloc_size ) {
3000e6f0: e15b0001 cmp fp, r1 <== NOT EXECUTED 3000e6f4: 3a000066 bcc 3000e894 <_Heap_Allocate_aligned_with_boundary+0x1d8><== NOT EXECUTED
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
3000e6f8: e3580000 cmp r8, #0 <== NOT EXECUTED 3000e6fc: 01a08002 moveq r8, r2 <== NOT EXECUTED
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
3000e700: e59d2000 ldr r2, [sp]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000e704: e2663004 rsb r3, 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
3000e708: e2822007 add r2, r2, #7
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000e70c: e595a008 ldr sl, [r5, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000e710: e3a07000 mov r7, #0
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
3000e714: e58d2014 str r2, [sp, #20]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000e718: e58d3018 str r3, [sp, #24]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000e71c: ea000048 b 3000e844 <_Heap_Allocate_aligned_with_boundary+0x188>
/*
* 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 ) {
3000e720: e59a4004 ldr r4, [sl, #4] 3000e724: e59d200c ldr r2, [sp, #12] 3000e728: e1540002 cmp r4, r2
3000e72c: 9a00003f bls 3000e830 <_Heap_Allocate_aligned_with_boundary+0x174>
3000e730: e28a3008 add r3, sl, #8
if ( alignment == 0 ) {
3000e734: e3580000 cmp r8, #0 3000e738: e58d3008 str r3, [sp, #8]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000e73c: 01a04003 moveq r4, r3
3000e740: 0a00003b beq 3000e834 <_Heap_Allocate_aligned_with_boundary+0x178>
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000e744: e5952014 ldr r2, [r5, #20]
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
3000e748: e59d3014 ldr r3, [sp, #20]
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000e74c: e58d2004 str r2, [sp, #4]
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
3000e750: e0629003 rsb r9, r2, 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;
3000e754: e3c44001 bic r4, r4, #1
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000e758: e59d2018 ldr r2, [sp, #24]
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
3000e75c: e08a4004 add r4, sl, r4
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
3000e760: e0899004 add r9, r9, r4
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000e764: e0824004 add r4, r2, r4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000e768: e1a00004 mov r0, r4 3000e76c: e1a01008 mov r1, r8 3000e770: eb00150c bl 30013ba8 <__umodsi3> 3000e774: e0604004 rsb r4, r0, r4
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 ) {
3000e778: e1540009 cmp r4, r9
3000e77c: 9a000003 bls 3000e790 <_Heap_Allocate_aligned_with_boundary+0xd4>
3000e780: e1a00009 mov r0, r9 <== NOT EXECUTED 3000e784: e1a01008 mov r1, r8 <== NOT EXECUTED 3000e788: eb001506 bl 30013ba8 <__umodsi3> <== NOT EXECUTED 3000e78c: e0604009 rsb r4, r0, r9 <== NOT EXECUTED
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
3000e790: e35b0000 cmp fp, #0
3000e794: 0a000014 beq 3000e7ec <_Heap_Allocate_aligned_with_boundary+0x130>
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000e798: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
/* 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;
3000e79c: e0849006 add r9, r4, r6 <== NOT EXECUTED
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000e7a0: e0833006 add r3, r3, r6 <== NOT EXECUTED 3000e7a4: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 3000e7a8: ea000008 b 3000e7d0 <_Heap_Allocate_aligned_with_boundary+0x114><== NOT EXECUTED
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
3000e7ac: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000e7b0: e1500002 cmp r0, r2 <== NOT EXECUTED 3000e7b4: 3a00001d bcc 3000e830 <_Heap_Allocate_aligned_with_boundary+0x174><== NOT EXECUTED
return 0;
}
alloc_begin = boundary_line - alloc_size;
3000e7b8: e0664000 rsb r4, r6, r0 <== NOT EXECUTED 3000e7bc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000e7c0: e1a01008 mov r1, r8 <== NOT EXECUTED 3000e7c4: eb0014f7 bl 30013ba8 <__umodsi3> <== NOT EXECUTED 3000e7c8: e0604004 rsb r4, r0, r4 <== NOT EXECUTED
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
3000e7cc: e0849006 add r9, r4, r6 <== NOT EXECUTED 3000e7d0: e1a00009 mov r0, r9 <== NOT EXECUTED 3000e7d4: e1a0100b mov r1, fp <== NOT EXECUTED 3000e7d8: eb0014f2 bl 30013ba8 <__umodsi3> <== NOT EXECUTED 3000e7dc: e0600009 rsb r0, r0, r9 <== NOT EXECUTED
/* 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 ) {
3000e7e0: e1500009 cmp r0, r9 <== NOT EXECUTED 3000e7e4: 31540000 cmpcc r4, r0 <== NOT EXECUTED 3000e7e8: 3affffef bcc 3000e7ac <_Heap_Allocate_aligned_with_boundary+0xf0><== NOT EXECUTED
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 ) {
3000e7ec: e59d3008 ldr r3, [sp, #8] 3000e7f0: e1540003 cmp r4, r3
3000e7f4: 3a00000d bcc 3000e830 <_Heap_Allocate_aligned_with_boundary+0x174>
3000e7f8: e1a00004 mov r0, r4 3000e7fc: e59d1000 ldr r1, [sp] 3000e800: eb0014e8 bl 30013ba8 <__umodsi3> 3000e804: e3e09007 mvn r9, #7 3000e808: 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);
3000e80c: e0899004 add r9, r9, r4
if ( free_size >= min_block_size || free_size == 0 ) {
return alloc_begin;
}
}
return 0;
3000e810: 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 ) {
3000e814: e0603009 rsb r3, r0, r9
return alloc_begin;
}
}
return 0;
3000e818: e1590000 cmp r9, r0 3000e81c: 11530002 cmpne r3, r2 3000e820: 33a09000 movcc r9, #0 3000e824: 23a09001 movcs r9, #1 3000e828: 31a04009 movcc r4, r9 3000e82c: ea000000 b 3000e834 <_Heap_Allocate_aligned_with_boundary+0x178> 3000e830: e3a04000 mov r4, #0
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
3000e834: e3540000 cmp r4, #0
);
}
}
/* Statistics */
++search_count;
3000e838: e2877001 add r7, r7, #1
if ( alloc_begin != 0 ) {
3000e83c: 1a000004 bne 3000e854 <_Heap_Allocate_aligned_with_boundary+0x198>
break;
}
block = block->next;
3000e840: 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 ) {
3000e844: e15a0005 cmp sl, r5
3000e848: 1affffb4 bne 3000e720 <_Heap_Allocate_aligned_with_boundary+0x64>
3000e84c: e3a04000 mov r4, #0 3000e850: ea00000a b 3000e880 <_Heap_Allocate_aligned_with_boundary+0x1c4>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000e854: e5953048 ldr r3, [r5, #72] ; 0x48
stats->searches += search_count;
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000e858: e1a00005 mov r0, r5
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000e85c: e2833001 add r3, r3, #1 3000e860: e5853048 str r3, [r5, #72] ; 0x48
stats->searches += search_count;
3000e864: e595304c ldr r3, [r5, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000e868: e1a0100a mov r1, sl
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
stats->searches += search_count;
3000e86c: e0833007 add r3, r3, r7 3000e870: e585304c str r3, [r5, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000e874: e1a02004 mov r2, r4 3000e878: e1a03006 mov r3, r6 3000e87c: ebffef3c bl 3000a574 <_Heap_Block_allocate>
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000e880: e5953044 ldr r3, [r5, #68] ; 0x44
stats->max_search = search_count;
}
return (void *) alloc_begin;
3000e884: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000e888: e1530007 cmp r3, r7
stats->max_search = search_count;
3000e88c: 35857044 strcc r7, [r5, #68] ; 0x44
}
return (void *) alloc_begin;
3000e890: ea000000 b 3000e898 <_Heap_Allocate_aligned_with_boundary+0x1dc>
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
3000e894: e3a00000 mov r0, #0
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000e898: e28dd01c add sp, sp, #28
3000e89c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000a574 <_Heap_Block_allocate>:
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000a574: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000a578: e591a004 ldr sl, [r1, #4]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000a57c: e2426008 sub r6, r2, #8
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000a580: e1a04001 mov r4, r1 3000a584: e1a07003 mov r7, r3
Heap_Statistics *const stats = &heap->stats;
uintptr_t const alloc_area_begin = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_area_offset = alloc_begin - alloc_area_begin;
3000a588: e0613006 rsb r3, r1, r6
- 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;
3000a58c: e3ca1001 bic r1, sl, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000a590: e0849001 add r9, r4, r1
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000a594: e1a05000 mov r5, r0
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;
3000a598: e5990004 ldr r0, [r9, #4]
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000a59c: e3100001 tst r0, #1
/* Statistics */
--stats->free_blocks;
++stats->used_blocks;
stats->free_size -= _Heap_Block_size( block );
} else {
free_list_anchor = _Heap_Free_list_head( heap );
3000a5a0: 11a08005 movne r8, r5
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000a5a4: 1a00000c bne 3000a5dc <_Heap_Block_allocate+0x68>
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
3000a5a8: e5940008 ldr r0, [r4, #8]
free_list_anchor = block->prev;
3000a5ac: e594800c ldr r8, [r4, #12]
Heap_Block *prev = block->prev;
prev->next = next;
3000a5b0: e5880008 str r0, [r8, #8]
next->prev = prev;
3000a5b4: e580800c str r8, [r0, #12]
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000a5b8: e5950038 ldr r0, [r5, #56] ; 0x38 3000a5bc: e2400001 sub r0, r0, #1 3000a5c0: e5850038 str r0, [r5, #56] ; 0x38
++stats->used_blocks;
3000a5c4: e5950040 ldr r0, [r5, #64] ; 0x40 3000a5c8: e2800001 add r0, r0, #1 3000a5cc: e5850040 str r0, [r5, #64] ; 0x40
stats->free_size -= _Heap_Block_size( block );
3000a5d0: e5950030 ldr r0, [r5, #48] ; 0x30 3000a5d4: e0611000 rsb r1, r1, r0 3000a5d8: e5851030 str r1, [r5, #48] ; 0x30
} else {
free_list_anchor = _Heap_Free_list_head( heap );
}
if ( alloc_area_offset < heap->page_size ) {
3000a5dc: e5951010 ldr r1, [r5, #16] 3000a5e0: e1530001 cmp r3, r1
3000a5e4: 2a000005 bcs 3000a600 <_Heap_Block_allocate+0x8c>
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
_Heap_Block_split( heap, block, free_list_anchor, alloc_size );
3000a5e8: e1a00005 mov r0, r5 3000a5ec: e1a01004 mov r1, r4 3000a5f0: e1a02008 mov r2, r8 3000a5f4: e0833007 add r3, r3, r7 3000a5f8: ebffff31 bl 3000a2c4 <_Heap_Block_split> 3000a5fc: ea000021 b 3000a688 <_Heap_Block_allocate+0x114>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000a600: e1a00002 mov r0, r2 3000a604: eb002567 bl 30013ba8 <__umodsi3>
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000a608: e5952030 ldr r2, [r5, #48] ; 0x30
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000a60c: e0606006 rsb r6, r0, r6
_Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
uintptr_t const new_block_begin = (uintptr_t) new_block;
uintptr_t const new_block_size = block_end - new_block_begin;
block_end = new_block_begin;
block_size = block_end - block_begin;
3000a610: e0643006 rsb r3, r4, r6
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000a614: e0822003 add r2, r2, r3
if ( _Heap_Is_prev_used( block ) ) {
3000a618: e31a0001 tst sl, #1
uintptr_t block_end = block_begin + block_size;
Heap_Block *const new_block =
_Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
uintptr_t const new_block_begin = (uintptr_t) new_block;
uintptr_t const new_block_size = block_end - new_block_begin;
3000a61c: e0669009 rsb r9, r6, r9
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000a620: e5852030 str r2, [r5, #48] ; 0x30
if ( _Heap_Is_prev_used( block ) ) {
3000a624: 0a000009 beq 3000a650 <_Heap_Block_allocate+0xdc>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000a628: e5982008 ldr r2, [r8, #8]
new_block->next = next;
new_block->prev = block_before;
3000a62c: e584800c str r8, [r4, #12]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
3000a630: e5842008 str r2, [r4, #8]
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
3000a634: e582400c str r4, [r2, #12]
_Heap_Free_list_insert_after( free_list_anchor, block );
free_list_anchor = block;
/* Statistics */
++stats->free_blocks;
3000a638: e5952038 ldr r2, [r5, #56] ; 0x38
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
3000a63c: e5884008 str r4, [r8, #8] 3000a640: e2822001 add r2, r2, #1 3000a644: e5852038 str r2, [r5, #56] ; 0x38 3000a648: e1a02004 mov r2, r4 3000a64c: ea000005 b 3000a668 <_Heap_Block_allocate+0xf4>
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Prev_block(
const Heap_Block *block
)
{
return (Heap_Block *) ((uintptr_t) block - block->prev_size);
3000a650: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000a654: e0624004 rsb r4, r2, r4 <== NOT EXECUTED
- 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;
3000a658: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000a65c: e3c22001 bic r2, r2, #1 <== NOT EXECUTED
} else {
Heap_Block *const prev_block = _Heap_Prev_block( block );
uintptr_t const prev_block_size = _Heap_Block_size( prev_block );
block = prev_block;
block_size += prev_block_size;
3000a660: e0833002 add r3, r3, r2 <== NOT EXECUTED 3000a664: e1a02008 mov r2, r8 <== NOT EXECUTED
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
3000a668: e3831001 orr r1, r3, #1 3000a66c: e5841004 str r1, [r4, #4]
new_block->prev_size = block_size;
3000a670: e8860208 stm r6, {r3, r9}
new_block->size_and_flag = new_block_size;
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
3000a674: e1a00005 mov r0, r5 3000a678: e1a01006 mov r1, r6 3000a67c: e1a03007 mov r3, r7 3000a680: ebffff0f bl 3000a2c4 <_Heap_Block_split> 3000a684: e1a04006 mov r4, r6
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000a688: e5953030 ldr r3, [r5, #48] ; 0x30 3000a68c: e5952034 ldr r2, [r5, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000a690: e1a00004 mov r0, r4
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000a694: e1520003 cmp r2, r3
stats->min_free_size = stats->free_size;
3000a698: 85853034 strhi r3, [r5, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000a69c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
3000a2c4 <_Heap_Block_split>:
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000a2c4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Heap_Statistics *const stats = &heap->stats;
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000a2c8: e5908014 ldr r8, [r0, #20]
uintptr_t alloc_size
)
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const page_size = heap->page_size;
3000a2cc: e590a010 ldr sl, [r0, #16]
uintptr_t const min_block_size = heap->min_block_size; uintptr_t const min_alloc_size = min_block_size - HEAP_BLOCK_HEADER_SIZE;
3000a2d0: e248b008 sub fp, r8, #8
return heap->stats.size;
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Max( uintptr_t a, uintptr_t b )
{
return a > b ? a : b;
3000a2d4: e153000b cmp r3, fp 3000a2d8: 21a0b003 movcs fp, r3
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const used_size =
3000a2dc: e28bb008 add fp, fp, #8
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000a2e0: e1a05001 mov r5, r1
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000a2e4: e5919004 ldr r9, [r1, #4]
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000a2e8: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000a2ec: e1a0100a mov r1, sl 3000a2f0: e1a0000b mov r0, fp 3000a2f4: e1a06002 mov r6, r2 3000a2f8: eb00262a bl 30013ba8 <__umodsi3>
- 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;
3000a2fc: e3c97001 bic r7, r9, #1
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
3000a300: e3500000 cmp r0, #0
uintptr_t const used_size =
_Heap_Max( alloc_size, min_alloc_size ) + HEAP_BLOCK_HEADER_SIZE;
uintptr_t const used_block_size = _Heap_Align_up( used_size, page_size );
uintptr_t const free_size = block_size + HEAP_ALLOC_BONUS - used_size;
3000a304: e2872004 add r2, r7, #4
return value - remainder + alignment;
3000a308: 108ba00a addne sl, fp, sl
} else {
return value;
3000a30c: 01a0a00b moveq sl, fp
uintptr_t const free_size_limit = min_block_size + HEAP_ALLOC_BONUS;
3000a310: e2888004 add r8, r8, #4
uintptr_t const used_size =
_Heap_Max( alloc_size, min_alloc_size ) + HEAP_BLOCK_HEADER_SIZE;
uintptr_t const used_block_size = _Heap_Align_up( used_size, page_size );
uintptr_t const free_size = block_size + HEAP_ALLOC_BONUS - used_size;
3000a314: e06bb002 rsb fp, fp, r2
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
3000a318: 1060a00a rsbne sl, r0, sl
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000a31c: e0853007 add r3, r5, r7
Heap_Block *next_block = _Heap_Block_at( block, block_size );
_HAssert( used_size <= block_size + HEAP_ALLOC_BONUS );
_HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS );
if ( free_size >= free_size_limit ) {
3000a320: e15b0008 cmp fp, r8
next_block->prev_size = free_block_size;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, free_block );
} else {
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000a324: 35932004 ldrcc r2, [r3, #4] 3000a328: 33822001 orrcc r2, r2, #1
Heap_Block *next_block = _Heap_Block_at( block, block_size );
_HAssert( used_size <= block_size + HEAP_ALLOC_BONUS );
_HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS );
if ( free_size >= free_size_limit ) {
3000a32c: 3a000023 bcc 3000a3c0 <_Heap_Block_split+0xfc>
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000a330: e5941030 ldr r1, [r4, #48] ; 0x30
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000a334: e2099001 and r9, r9, #1
_HAssert( used_size <= block_size + HEAP_ALLOC_BONUS );
_HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS );
if ( free_size >= free_size_limit ) {
Heap_Block *const free_block = _Heap_Block_at( block, used_block_size );
uintptr_t free_block_size = block_size - used_block_size;
3000a338: e06a7007 rsb r7, sl, r7
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000a33c: e08a2005 add r2, sl, r5
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
block->size_and_flag = size | flag;
3000a340: e18aa009 orr sl, sl, r9 3000a344: e585a004 str sl, [r5, #4]
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000a348: e0811007 add r1, r1, r7 3000a34c: e5841030 str r1, [r4, #48] ; 0x30
- 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;
3000a350: e5931004 ldr r1, [r3, #4] 3000a354: e3c11001 bic r1, r1, #1
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000a358: e0830001 add r0, r3, 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;
3000a35c: e5900004 ldr r0, [r0, #4]
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
if ( _Heap_Is_used( next_block ) ) {
3000a360: e3100001 tst r0, #1
3000a364: 0a000008 beq 3000a38c <_Heap_Block_split+0xc8>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000a368: e5961008 ldr r1, [r6, #8]
new_block->next = next;
new_block->prev = block_before;
3000a36c: e582600c str r6, [r2, #12]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
3000a370: e5821008 str r1, [r2, #8]
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
3000a374: e581200c str r2, [r1, #12]
_Heap_Free_list_insert_after( free_list_anchor, free_block );
/* Statistics */
++stats->free_blocks;
3000a378: e5941038 ldr r1, [r4, #56] ; 0x38
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
3000a37c: e5862008 str r2, [r6, #8] 3000a380: e2811001 add r1, r1, #1 3000a384: e5841038 str r1, [r4, #56] ; 0x38 3000a388: ea000007 b 3000a3ac <_Heap_Block_split+0xe8>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
3000a38c: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
Heap_Block *prev = old_block->prev;
3000a390: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
} else {
uintptr_t const next_block_size = _Heap_Block_size( next_block );
_Heap_Free_list_replace( next_block, free_block );
free_block_size += next_block_size;
3000a394: e0877001 add r7, r7, r1 <== NOT EXECUTED
new_block->next = next;
new_block->prev = prev;
3000a398: e582300c str r3, [r2, #12] <== NOT EXECUTED
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
3000a39c: e5820008 str r0, [r2, #8] <== NOT EXECUTED
new_block->prev = prev;
next->prev = new_block;
3000a3a0: e580200c str r2, [r0, #12] <== NOT EXECUTED
prev->next = new_block;
3000a3a4: e5832008 str r2, [r3, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000a3a8: e0873002 add r3, r7, r2 <== NOT EXECUTED
next_block = _Heap_Block_at( free_block, free_block_size );
}
free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED;
3000a3ac: e3871001 orr r1, r7, #1 3000a3b0: e5821004 str r1, [r2, #4]
next_block->prev_size = free_block_size;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000a3b4: e5932004 ldr r2, [r3, #4]
next_block = _Heap_Block_at( free_block, free_block_size );
}
free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED;
next_block->prev_size = free_block_size;
3000a3b8: e5837000 str r7, [r3]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000a3bc: e3c22001 bic r2, r2, #1
_Heap_Protection_block_initialize( heap, free_block );
} else {
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000a3c0: e5832004 str r2, [r3, #4]
3000a3c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000ebd8 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
3000ebd8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3000ebdc: e1a05001 mov r5, r1 <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
3000ebe0: e5901020 ldr r1, [r0, #32] <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
3000ebe4: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 3000ebe8: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
3000ebec: e58d1010 str r1, [sp, #16] <== NOT EXECUTED
Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size;
3000ebf0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size;
3000ebf4: e5901030 ldr r1, [r0, #48] ; 0x30 <== NOT EXECUTED
Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL;
3000ebf8: e3a08000 mov r8, #0 <== NOT EXECUTED
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
3000ebfc: e0956002 adds r6, r5, r2 <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
3000ec00: e1a04000 mov r4, r0 <== NOT EXECUTED
Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size;
3000ec04: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL;
3000ec08: e58d8024 str r8, [sp, #36] ; 0x24 <== NOT EXECUTED
Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size;
3000ec0c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED
Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL;
3000ec10: e58d8020 str r8, [sp, #32] <== NOT EXECUTED
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size;
3000ec14: e58d101c str r1, [sp, #28] <== NOT EXECUTED
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
return false;
3000ec18: 21a00008 movcs r0, r8 <== NOT EXECUTED
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
3000ec1c: 2a00009d bcs 3000ee98 <_Heap_Extend+0x2c0> <== NOT EXECUTED
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
3000ec20: e28d1024 add r1, sp, #36 ; 0x24 <== NOT EXECUTED 3000ec24: e58d1000 str r1, [sp] <== NOT EXECUTED 3000ec28: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000ec2c: e58d1004 str r1, [sp, #4] <== NOT EXECUTED 3000ec30: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ec34: e1a01002 mov r1, r2 <== NOT EXECUTED 3000ec38: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 3000ec3c: ebffeeb7 bl 3000a720 <_Heap_Get_first_and_last_block> <== NOT EXECUTED
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
3000ec40: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ec44: 0a000093 beq 3000ee98 <_Heap_Extend+0x2c0> <== NOT EXECUTED 3000ec48: e59da010 ldr sl, [sp, #16] <== NOT EXECUTED 3000ec4c: e1a07008 mov r7, r8 <== NOT EXECUTED 3000ec50: e1a09008 mov r9, r8 <== NOT EXECUTED
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
3000ec54: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED 3000ec58: e1a03008 mov r3, r8 <== NOT EXECUTED 3000ec5c: e1a0c004 mov ip, r4 <== NOT EXECUTED 3000ec60: ea000000 b 3000ec68 <_Heap_Extend+0x90> <== NOT EXECUTED 3000ec64: e1a0100a mov r1, sl <== NOT EXECUTED
uintptr_t const sub_area_end = start_block->prev_size;
3000ec68: e59a4000 ldr r4, [sl] <== NOT EXECUTED
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
3000ec6c: e1560001 cmp r6, r1 <== NOT EXECUTED 3000ec70: 93a00000 movls r0, #0 <== NOT EXECUTED 3000ec74: 83a00001 movhi r0, #1 <== NOT EXECUTED 3000ec78: e1550004 cmp r5, r4 <== NOT EXECUTED 3000ec7c: 23a00000 movcs r0, #0 <== NOT EXECUTED 3000ec80: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ec84: 1a000082 bne 3000ee94 <_Heap_Extend+0x2bc> <== NOT EXECUTED
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
3000ec88: e1560001 cmp r6, r1 <== NOT EXECUTED 3000ec8c: 01a0300a moveq r3, sl <== NOT EXECUTED 3000ec90: 0a000001 beq 3000ec9c <_Heap_Extend+0xc4> <== NOT EXECUTED
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
3000ec94: e1560004 cmp r6, r4 <== NOT EXECUTED 3000ec98: 31a0900a movcc r9, sl <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000ec9c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000eca0: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 3000eca4: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000eca8: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 3000ecac: eb001512 bl 300140fc <__umodsi3> <== NOT EXECUTED 3000ecb0: e244b008 sub fp, r4, #8 <== NOT EXECUTED
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
3000ecb4: e1540005 cmp r4, r5 <== NOT EXECUTED
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000ecb8: e060000b rsb r0, r0, fp <== NOT EXECUTED 3000ecbc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3000ecc0: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
3000ecc4: 01a07000 moveq r7, r0 <== NOT EXECUTED
start_block->prev_size = extend_area_end;
3000ecc8: 058a6000 streq r6, [sl] <== NOT EXECUTED
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
3000eccc: 0a000000 beq 3000ecd4 <_Heap_Extend+0xfc> <== NOT EXECUTED 3000ecd0: 31a08000 movcc r8, r0 <== NOT EXECUTED
- 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;
3000ecd4: e590a004 ldr sl, [r0, #4] <== NOT EXECUTED
} else if ( sub_area_end < extend_area_begin ) {
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
3000ecd8: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000ecdc: e3caa001 bic sl, sl, #1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000ece0: e080a00a add sl, r0, sl <== NOT EXECUTED 3000ece4: e15a0002 cmp sl, r2 <== NOT EXECUTED 3000ece8: 1affffdd bne 3000ec64 <_Heap_Extend+0x8c> <== NOT EXECUTED 3000ecec: e1a02009 mov r2, r9 <== NOT EXECUTED 3000ecf0: e1a09003 mov r9, r3 <== NOT EXECUTED
if ( extend_area_begin < heap->area_begin ) {
3000ecf4: e59c3018 ldr r3, [ip, #24] <== NOT EXECUTED 3000ecf8: e1a0400c mov r4, ip <== NOT EXECUTED 3000ecfc: e1550003 cmp r5, r3 <== NOT EXECUTED
heap->area_begin = extend_area_begin;
3000ed00: 358c5018 strcc r5, [ip, #24] <== NOT EXECUTED
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
if ( extend_area_begin < heap->area_begin ) {
3000ed04: 3a000002 bcc 3000ed14 <_Heap_Extend+0x13c> <== NOT EXECUTED
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
3000ed08: e59c301c ldr r3, [ip, #28] <== NOT EXECUTED 3000ed0c: e1530006 cmp r3, r6 <== NOT EXECUTED
heap->area_end = extend_area_end;
3000ed10: 358c601c strcc r6, [ip, #28] <== NOT EXECUTED
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
3000ed14: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000ed18: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
extend_first_block->prev_size = extend_area_end;
3000ed1c: e5816000 str r6, [r1] <== NOT EXECUTED
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
3000ed20: e0610003 rsb r0, r1, r3 <== NOT EXECUTED
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
3000ed24: e380c001 orr ip, r0, #1 <== NOT EXECUTED
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
3000ed28: e5830000 str r0, [r3] <== NOT EXECUTED
extend_last_block->size_and_flag = 0;
3000ed2c: e3a00000 mov r0, #0 <== NOT EXECUTED
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
3000ed30: e581c004 str ip, [r1, #4] <== NOT EXECUTED
extend_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
3000ed34: e5830004 str r0, [r3, #4] <== NOT EXECUTED
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
3000ed38: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED 3000ed3c: e1500001 cmp r0, r1 <== NOT EXECUTED
heap->first_block = extend_first_block;
3000ed40: 85841020 strhi r1, [r4, #32] <== NOT EXECUTED
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
3000ed44: 8a000002 bhi 3000ed54 <_Heap_Extend+0x17c> <== NOT EXECUTED
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
3000ed48: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000ed4c: e1510003 cmp r1, r3 <== NOT EXECUTED
heap->last_block = extend_last_block;
3000ed50: 35843024 strcc r3, [r4, #36] ; 0x24 <== NOT EXECUTED
}
if ( merge_below_block != NULL ) {
3000ed54: e3590000 cmp r9, #0 <== NOT EXECUTED 3000ed58: 0a000010 beq 3000eda0 <_Heap_Extend+0x1c8> <== NOT EXECUTED
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
3000ed5c: e594a010 ldr sl, [r4, #16] <== NOT EXECUTED
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
3000ed60: e2855008 add r5, r5, #8 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000ed64: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ed68: e1a0100a mov r1, sl <== NOT EXECUTED 3000ed6c: eb0014e2 bl 300140fc <__umodsi3> <== NOT EXECUTED
if ( remainder != 0 ) {
3000ed70: e3500000 cmp r0, #0 <== NOT EXECUTED
return value - remainder + alignment;
3000ed74: 1085500a addne r5, r5, sl <== NOT EXECUTED 3000ed78: 10605005 rsbne r5, r0, r5 <== NOT EXECUTED
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
3000ed7c: e5993000 ldr r3, [r9] <== NOT EXECUTED
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
3000ed80: e2451008 sub r1, r5, #8 <== NOT EXECUTED
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
3000ed84: e5053008 str r3, [r5, #-8] <== NOT EXECUTED
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
3000ed88: e0613009 rsb r3, r1, r9 <== NOT EXECUTED
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
3000ed8c: e3833001 orr r3, r3, #1 <== NOT EXECUTED 3000ed90: e5053004 str r3, [r5, #-4] <== NOT EXECUTED
_Heap_Free_block( heap, new_first_block );
3000ed94: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ed98: ebffff86 bl 3000ebb8 <_Heap_Free_block> <== NOT EXECUTED 3000ed9c: ea000004 b 3000edb4 <_Heap_Extend+0x1dc> <== NOT EXECUTED
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
3000eda0: e3520000 cmp r2, #0 <== NOT EXECUTED
_Heap_Link_below(
3000eda4: 159d3020 ldrne r3, [sp, #32] <== NOT EXECUTED
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
3000eda8: 10632002 rsbne r2, r3, r2 <== NOT EXECUTED 3000edac: 13822001 orrne r2, r2, #1 <== NOT EXECUTED
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
3000edb0: 15832004 strne r2, [r3, #4] <== NOT EXECUTED
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
3000edb4: e3570000 cmp r7, #0 <== NOT EXECUTED 3000edb8: 0a000012 beq 3000ee08 <_Heap_Extend+0x230> <== NOT EXECUTED
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
3000edbc: e2466008 sub r6, r6, #8 <== NOT EXECUTED
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
3000edc0: e0676006 rsb r6, r7, r6 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000edc4: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED 3000edc8: e1a00006 mov r0, r6 <== NOT EXECUTED 3000edcc: eb0014ca bl 300140fc <__umodsi3> <== NOT EXECUTED
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
3000edd0: e5972004 ldr r2, [r7, #4] <== NOT EXECUTED 3000edd4: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3000edd8: e0662002 rsb r2, r6, r2 <== NOT EXECUTED
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
3000eddc: e0863007 add r3, r6, r7 <== NOT EXECUTED
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
3000ede0: e3822001 orr r2, r2, #1 <== NOT EXECUTED
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
3000ede4: e5832004 str r2, [r3, #4] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000ede8: e5973004 ldr r3, [r7, #4] <== NOT EXECUTED
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
3000edec: e1a00004 mov r0, r4 <== NOT EXECUTED 3000edf0: e2033001 and r3, r3, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3000edf4: e1866003 orr r6, r6, r3 <== NOT EXECUTED 3000edf8: e5876004 str r6, [r7, #4] <== NOT EXECUTED 3000edfc: e1a01007 mov r1, r7 <== NOT EXECUTED 3000ee00: ebffff6c bl 3000ebb8 <_Heap_Free_block> <== NOT EXECUTED 3000ee04: ea00000b b 3000ee38 <_Heap_Extend+0x260> <== NOT EXECUTED
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
3000ee08: e3580000 cmp r8, #0 <== NOT EXECUTED 3000ee0c: 0a000009 beq 3000ee38 <_Heap_Extend+0x260> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000ee10: e5982004 ldr r2, [r8, #4] <== NOT EXECUTED
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
3000ee14: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000ee18: e2022001 and r2, r2, #1 <== NOT EXECUTED 3000ee1c: e0681001 rsb r1, r8, r1 <== NOT EXECUTED
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
3000ee20: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
block->size_and_flag = size | flag;
3000ee24: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000ee28: e5882004 str r2, [r8, #4] <== NOT EXECUTED
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000ee2c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000ee30: e3822001 orr r2, r2, #1 <== NOT EXECUTED 3000ee34: e5832004 str r2, [r3, #4] <== NOT EXECUTED
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
3000ee38: e3570000 cmp r7, #0 <== NOT EXECUTED 3000ee3c: 03590000 cmpeq r9, #0 <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
3000ee40: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000ee44: 059d1024 ldreq r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000ee48: 0bffff5a bleq 3000ebb8 <_Heap_Free_block> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
3000ee4c: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
3000ee50: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000ee54: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
3000ee58: e0631001 rsb r1, r3, r1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000ee5c: e2022001 and r2, r2, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3000ee60: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000ee64: e5832004 str r2, [r3, #4] <== NOT EXECUTED
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
3000ee68: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3000ee6c: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
3000ee70: e594202c ldr r2, [r4, #44] ; 0x2c <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
3000ee74: e0613003 rsb r3, r1, r3 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
3000ee78: e0822003 add r2, r2, r3 <== NOT EXECUTED 3000ee7c: e584202c str r2, [r4, #44] ; 0x2c <== NOT EXECUTED
if ( extended_size_ptr != NULL )
3000ee80: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
*extended_size_ptr = extended_size;
return true;
3000ee84: e3a00001 mov r0, #1 <== NOT EXECUTED
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
3000ee88: e3520000 cmp r2, #0 <== NOT EXECUTED
*extended_size_ptr = extended_size;
3000ee8c: 15823000 strne r3, [r2] <== NOT EXECUTED 3000ee90: ea000000 b 3000ee98 <_Heap_Extend+0x2c0> <== NOT EXECUTED
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
3000ee94: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
3000ee98: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
3000ee9c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000ebb8 <_Heap_Free_block>:
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block )
{
Heap_Statistics *const stats = &heap->stats;
/* Statistics */
++stats->used_blocks;
3000ebb8: e5902040 ldr r2, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ));
3000ebbc: e2811008 add r1, r1, #8 <== NOT EXECUTED
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block )
{
Heap_Statistics *const stats = &heap->stats;
/* Statistics */
++stats->used_blocks;
3000ebc0: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000ebc4: e5802040 str r2, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
3000ebc8: e5902050 ldr r2, [r0, #80] ; 0x50 <== NOT EXECUTED 3000ebcc: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000ebd0: e5802050 str r2, [r0, #80] ; 0x50 <== NOT EXECUTED
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ));
3000ebd4: ea0000b1 b 3000eea0 <_Heap_Free> <== NOT EXECUTED
3000a454 <_Heap_Initialize>:
Heap_Control *heap,
void *heap_area_begin_ptr,
uintptr_t heap_area_size,
uintptr_t page_size
)
{
3000a454: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr}
3000a458: e1a08002 mov r8, r2
uintptr_t min_block_size = 0;
bool area_ok = false;
Heap_Block *first_block = NULL;
Heap_Block *last_block = NULL;
if ( page_size == 0 ) {
3000a45c: e2535000 subs r5, r3, #0
uintptr_t first_block_begin = 0; uintptr_t first_block_size = 0; uintptr_t last_block_begin = 0; uintptr_t min_block_size = 0; bool area_ok = false; Heap_Block *first_block = NULL;
3000a460: e3a02000 mov r2, #0
Heap_Control *heap,
void *heap_area_begin_ptr,
uintptr_t heap_area_size,
uintptr_t page_size
)
{
3000a464: e1a04000 mov r4, r0 3000a468: e1a06001 mov r6, r1
uintptr_t first_block_begin = 0; uintptr_t first_block_size = 0; uintptr_t last_block_begin = 0; uintptr_t min_block_size = 0; bool area_ok = false; Heap_Block *first_block = NULL;
3000a46c: e58d200c str r2, [sp, #12]
Heap_Block *last_block = NULL;
3000a470: e58d2008 str r2, [sp, #8]
if ( page_size == 0 ) {
page_size = CPU_ALIGNMENT;
3000a474: 03a05008 moveq r5, #8
uintptr_t min_block_size = 0;
bool area_ok = false;
Heap_Block *first_block = NULL;
Heap_Block *last_block = NULL;
if ( page_size == 0 ) {
3000a478: 0a000004 beq 3000a490 <_Heap_Initialize+0x3c>
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
3000a47c: e2153007 ands r3, r5, #7
return value - remainder + alignment;
3000a480: 12855008 addne r5, r5, #8 3000a484: 10635005 rsbne r5, r3, r5
page_size = CPU_ALIGNMENT;
} else {
page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT );
if ( page_size < CPU_ALIGNMENT ) {
3000a488: e3550007 cmp r5, #7
3000a48c: 9a000034 bls 3000a564 <_Heap_Initialize+0x110>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000a490: e1a01005 mov r1, r5 3000a494: e3a00010 mov r0, #16 3000a498: eb0025c2 bl 30013ba8 <__umodsi3>
if ( remainder != 0 ) {
3000a49c: e3500000 cmp r0, #0
return value - remainder + alignment;
3000a4a0: 12857010 addne r7, r5, #16
return 0;
}
}
min_block_size = _Heap_Align_up( sizeof( Heap_Block ), page_size );
area_ok = _Heap_Get_first_and_last_block(
3000a4a4: e28d300c add r3, sp, #12 3000a4a8: 10607007 rsbne r7, r0, r7
} else {
return value;
3000a4ac: 03a07010 moveq r7, #16 3000a4b0: e58d3000 str r3, [sp] 3000a4b4: e28d3008 add r3, sp, #8 3000a4b8: e58d3004 str r3, [sp, #4] 3000a4bc: e1a00006 mov r0, r6 3000a4c0: e1a01008 mov r1, r8 3000a4c4: e1a02005 mov r2, r5 3000a4c8: e1a03007 mov r3, r7 3000a4cc: ebffffbd bl 3000a3c8 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&first_block,
&last_block
);
if ( !area_ok ) {
3000a4d0: e3500000 cmp r0, #0
3000a4d4: 0a000023 beq 3000a568 <_Heap_Initialize+0x114>
return 0;
}
memset(heap, 0, sizeof(*heap));
3000a4d8: e3a01000 mov r1, #0 3000a4dc: e3a02058 mov r2, #88 ; 0x58 3000a4e0: e1a00004 mov r0, r4 3000a4e4: eb0019b9 bl 30010bd0 <memset>
heap->Protection.block_initialize = _Heap_Protection_block_initialize_default;
heap->Protection.block_check = _Heap_Protection_block_check_default;
heap->Protection.block_error = _Heap_Protection_block_error_default;
#endif
first_block_begin = (uintptr_t) first_block;
3000a4e8: e59d300c ldr r3, [sp, #12]
last_block_begin = (uintptr_t) last_block;
3000a4ec: e59d2008 ldr r2, [sp, #8]
uintptr_t page_size
)
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr;
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
3000a4f0: e0888006 add r8, r8, r6
heap->Protection.block_error = _Heap_Protection_block_error_default;
#endif
first_block_begin = (uintptr_t) first_block;
last_block_begin = (uintptr_t) last_block;
first_block_size = last_block_begin - first_block_begin;
3000a4f4: e0630002 rsb r0, r3, r2
/* First block */
first_block->prev_size = heap_area_end;
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
3000a4f8: e3801001 orr r1, r0, #1
first_block_begin = (uintptr_t) first_block;
last_block_begin = (uintptr_t) last_block;
first_block_size = last_block_begin - first_block_begin;
/* First block */
first_block->prev_size = heap_area_end;
3000a4fc: e5838000 str r8, [r3]
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
3000a500: e9830012 stmib r3, {r1, r4}
first_block->next = _Heap_Free_list_tail( heap ); first_block->prev = _Heap_Free_list_head( heap );
3000a504: e583400c str r4, [r3, #12]
heap->min_block_size = min_block_size; heap->area_begin = heap_area_begin; heap->area_end = heap_area_end; heap->first_block = first_block; heap->last_block = last_block; _Heap_Free_list_head( heap )->next = first_block;
3000a508: e5843008 str r3, [r4, #8]
/* Heap control */ heap->page_size = page_size; heap->min_block_size = min_block_size; heap->area_begin = heap_area_begin; heap->area_end = heap_area_end; heap->first_block = first_block;
3000a50c: e5843020 str r3, [r4, #32]
heap->last_block = last_block; _Heap_Free_list_head( heap )->next = first_block; _Heap_Free_list_tail( heap )->prev = first_block;
3000a510: e584300c str r3, [r4, #12]
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
3000a514: e0623003 rsb r3, r2, r3
heap->page_size = page_size; heap->min_block_size = min_block_size; heap->area_begin = heap_area_begin; heap->area_end = heap_area_end; heap->first_block = first_block; heap->last_block = last_block;
3000a518: e5842024 str r2, [r4, #36] ; 0x24
first_block->next = _Heap_Free_list_tail( heap );
first_block->prev = _Heap_Free_list_head( heap );
_Heap_Protection_block_initialize( heap, first_block );
/* Heap control */
heap->page_size = page_size;
3000a51c: e5845010 str r5, [r4, #16]
heap->min_block_size = min_block_size;
3000a520: e5847014 str r7, [r4, #20]
heap->area_begin = heap_area_begin;
3000a524: e5846018 str r6, [r4, #24]
heap->area_end = heap_area_end;
3000a528: e584801c str r8, [r4, #28]
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
block->size_and_flag = size | flag;
3000a52c: e5823004 str r3, [r2, #4]
/* Statistics */
stats->size = first_block_size;
stats->free_size = first_block_size;
stats->min_free_size = first_block_size;
stats->free_blocks = 1;
3000a530: e3a03001 mov r3, #1
heap->last_block = last_block;
_Heap_Free_list_head( heap )->next = first_block;
_Heap_Free_list_tail( heap )->prev = first_block;
/* Last block */
last_block->prev_size = first_block_size;
3000a534: e5820000 str r0, [r2]
/* Statistics */
stats->size = first_block_size;
stats->free_size = first_block_size;
stats->min_free_size = first_block_size;
stats->free_blocks = 1;
3000a538: e5843038 str r3, [r4, #56] ; 0x38
stats->max_free_blocks = 1;
3000a53c: e584303c str r3, [r4, #60] ; 0x3c
stats->instance = instance++;
3000a540: e59f3028 ldr r3, [pc, #40] ; 3000a570 <_Heap_Initialize+0x11c>
last_block->size_and_flag = 0;
_Heap_Set_last_block_size( heap );
_Heap_Protection_block_initialize( heap, last_block );
/* Statistics */
stats->size = first_block_size;
3000a544: e584002c str r0, [r4, #44] ; 0x2c
stats->free_size = first_block_size; stats->min_free_size = first_block_size; stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++;
3000a548: e5932000 ldr r2, [r3]
_Heap_Set_last_block_size( heap );
_Heap_Protection_block_initialize( heap, last_block );
/* Statistics */
stats->size = first_block_size;
stats->free_size = first_block_size;
3000a54c: e5840030 str r0, [r4, #48] ; 0x30
stats->min_free_size = first_block_size; stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++;
3000a550: e5842028 str r2, [r4, #40] ; 0x28 3000a554: e2822001 add r2, r2, #1
_Heap_Protection_block_initialize( heap, last_block );
/* Statistics */
stats->size = first_block_size;
stats->free_size = first_block_size;
stats->min_free_size = first_block_size;
3000a558: e5840034 str r0, [r4, #52] ; 0x34
stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++;
3000a55c: e5832000 str r2, [r3]
);
_HAssert(
_Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size )
);
return first_block_size;
3000a560: ea000000 b 3000a568 <_Heap_Initialize+0x114>
} else {
page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT );
if ( page_size < CPU_ALIGNMENT ) {
/* Integer overflow */
return 0;
3000a564: e3a00000 mov r0, #0 <== NOT EXECUTED
_HAssert(
_Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size )
);
return first_block_size;
}
3000a568: e28dd010 add sp, sp, #16
3000a56c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
30015f04 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
30015f04: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30015f08: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30015f0c: e241a008 sub sl, r1, #8 30015f10: e1a00001 mov r0, r1 30015f14: e1a05001 mov r5, r1 30015f18: e5941010 ldr r1, [r4, #16] 30015f1c: e1a08003 mov r8, r3 30015f20: e1a07002 mov r7, r2 30015f24: ebfff71f bl 30013ba8 <__umodsi3> 30015f28: e59d601c ldr r6, [sp, #28]
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
*old_size = 0;
30015f2c: e3a03000 mov r3, #0 30015f30: e5883000 str r3, [r8]
*new_size = 0;
30015f34: e5863000 str r3, [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;
30015f38: 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);
30015f3c: e060100a rsb r1, r0, sl
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;
30015f40: e1530001 cmp r3, r1
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
30015f44: 83a00002 movhi r0, #2
30015f48: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
30015f4c: e5943024 ldr r3, [r4, #36] ; 0x24
30015f50: e1530001 cmp r3, r1
30015f54: 3a000035 bcc 30016030 <_Heap_Resize_block+0x12c>
- 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;
30015f58: e5913004 ldr r3, [r1, #4]
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t block_size = _Heap_Block_size( block );
uintptr_t block_end = block_begin + block_size;
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
30015f5c: e265c004 rsb ip, r5, #4 30015f60: e3c33001 bic r3, r3, #1
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t block_size = _Heap_Block_size( block );
uintptr_t block_end = block_begin + block_size;
30015f64: e0812003 add r2, r1, r3 30015f68: e5920004 ldr r0, [r2, #4]
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
30015f6c: e08cc002 add ip, ip, r2 30015f70: e3c00001 bic r0, r0, #1
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
30015f74: e082a000 add sl, r2, r0
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;
30015f78: e59aa004 ldr sl, [sl, #4]
bool next_block_is_free = _Heap_Is_free( next_block );;
_HAssert( _Heap_Is_block_in_heap( heap, next_block ) );
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
30015f7c: e588c000 str ip, [r8]
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
30015f80: e31a0001 tst sl, #1 30015f84: 13a0a000 movne sl, #0 30015f88: 03a0a001 moveq sl, #1
if ( next_block_is_free ) {
30015f8c: e35a0000 cmp sl, #0
block_size += next_block_size;
alloc_size += next_block_size;
30015f90: 108cc000 addne ip, ip, r0
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
if ( next_block_is_free ) {
block_size += next_block_size;
30015f94: 10833000 addne r3, r3, r0
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
30015f98: e157000c cmp r7, ip
return HEAP_RESIZE_UNSATISFIED;
30015f9c: 83a00001 movhi r0, #1
if ( next_block_is_free ) {
block_size += next_block_size;
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
30015fa0: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
30015fa4: e35a0000 cmp sl, #0
30015fa8: 0a000011 beq 30015ff4 <_Heap_Resize_block+0xf0>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
30015fac: e591c004 ldr ip, [r1, #4] <== NOT EXECUTED 30015fb0: e20cc001 and ip, ip, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
30015fb4: e183c00c orr ip, r3, ip <== NOT EXECUTED 30015fb8: e581c004 str ip, [r1, #4] <== NOT EXECUTED
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
30015fbc: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
Heap_Block *prev = block->prev;
30015fc0: e592200c ldr r2, [r2, #12] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30015fc4: e0833001 add r3, r3, r1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
30015fc8: e582c008 str ip, [r2, #8] <== NOT EXECUTED
next->prev = prev;
30015fcc: e58c200c str r2, [ip, #12] <== NOT EXECUTED
_Heap_Block_set_size( block, block_size );
_Heap_Free_list_remove( next_block );
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
30015fd0: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 30015fd4: e3822001 orr r2, r2, #1 <== NOT EXECUTED 30015fd8: e5832004 str r2, [r3, #4] <== NOT EXECUTED
/* Statistics */
--stats->free_blocks;
30015fdc: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 30015fe0: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30015fe4: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
stats->free_size -= next_block_size;
30015fe8: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED 30015fec: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 30015ff0: e5840030 str r0, [r4, #48] ; 0x30 <== NOT EXECUTED
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
30015ff4: e1a02005 mov r2, r5 30015ff8: e1a03007 mov r3, r7 30015ffc: e1a00004 mov r0, r4 30016000: ebffd15b bl 3000a574 <_Heap_Block_allocate>
- 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;
30016004: e5903004 ldr r3, [r0, #4] 30016008: e3c33001 bic r3, r3, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3001600c: e2833004 add r3, r3, #4
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
30016010: e0655003 rsb r5, r5, r3 30016014: e0800005 add r0, r0, r5 30016018: e5860000 str r0, [r6]
/* Statistics */
++stats->resizes;
3001601c: e5943054 ldr r3, [r4, #84] ; 0x54
return HEAP_RESIZE_SUCCESSFUL;
30016020: e3a00000 mov r0, #0
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
/* Statistics */
++stats->resizes;
30016024: e2833001 add r3, r3, #1
30016028: e5843054 str r3, [r4, #84] ; 0x54
3001602c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
30016030: e3a00002 mov r0, #2 <== NOT EXECUTED
}
30016034: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000b2bc <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000b2bc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size;
3000b2c0: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000b2c4: e24dd030 sub sp, sp, #48 ; 0x30 <== NOT EXECUTED
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size;
3000b2c8: e58d3024 str r3, [sp, #36] ; 0x24 <== NOT EXECUTED
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
3000b2cc: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
3000b2d0: e59f4500 ldr r4, [pc, #1280] ; 3000b7d8 <_Heap_Walk+0x51c> <== NOT EXECUTED
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
3000b2d4: e58d3028 str r3, [sp, #40] ; 0x28 <== NOT EXECUTED
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
3000b2d8: e59f34fc ldr r3, [pc, #1276] ; 3000b7dc <_Heap_Walk+0x520> <== NOT EXECUTED 3000b2dc: e31200ff tst r2, #255 ; 0xff <== NOT EXECUTED 3000b2e0: 11a04003 movne r4, r3 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000b2e4: e59f34f4 ldr r3, [pc, #1268] ; 3000b7e0 <_Heap_Walk+0x524> <== NOT EXECUTED
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
3000b2e8: e590c020 ldr ip, [r0, #32] <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000b2ec: e5933000 ldr r3, [r3] <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000b2f0: e1a06000 mov r6, r0 <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000b2f4: e3530003 cmp r3, #3 <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000b2f8: e1a05001 mov r5, r1 <== NOT EXECUTED
uintptr_t const page_size = heap->page_size;
3000b2fc: e5909010 ldr r9, [r0, #16] <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block;
3000b300: e58dc020 str ip, [sp, #32] <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000b304: 1a000127 bne 3000b7a8 <_Heap_Walk+0x4ec> <== NOT EXECUTED
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
3000b308: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b30c: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000b310: e58dc000 str ip, [sp] <== NOT EXECUTED 3000b314: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED 3000b318: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000b31c: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 3000b320: e58d200c str r2, [sp, #12] <== NOT EXECUTED 3000b324: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000b328: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000b32c: e59f24b0 ldr r2, [pc, #1200] ; 3000b7e4 <_Heap_Walk+0x528> <== NOT EXECUTED 3000b330: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 3000b334: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED 3000b338: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 3000b33c: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000b340: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b344: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000b348: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b34c: e1a03009 mov r3, r9 <== NOT EXECUTED 3000b350: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b354: e12fff14 bx r4 <== NOT EXECUTED
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
3000b358: e3590000 cmp r9, #0 <== NOT EXECUTED 3000b35c: 1a000006 bne 3000b37c <_Heap_Walk+0xc0> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
3000b360: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b364: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b368: e59f2478 ldr r2, [pc, #1144] ; 3000b7e8 <_Heap_Walk+0x52c> <== NOT EXECUTED 3000b36c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b370: e12fff14 bx r4 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000b374: e1a08009 mov r8, r9 <== NOT EXECUTED 3000b378: ea00010b b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
3000b37c: e2198007 ands r8, r9, #7 <== NOT EXECUTED
(*printer)(
3000b380: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b384: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b388: 159f245c ldrne r2, [pc, #1116] ; 3000b7ec <_Heap_Walk+0x530><== NOT EXECUTED 3000b38c: 11a03009 movne r3, r9 <== NOT EXECUTED 3000b390: 1a00010c bne 3000b7c8 <_Heap_Walk+0x50c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000b394: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b398: e1a01009 mov r1, r9 <== NOT EXECUTED 3000b39c: ebffe749 bl 300050c8 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
3000b3a0: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3000b3a4: 0a000006 beq 3000b3c4 <_Heap_Walk+0x108> <== NOT EXECUTED
(*printer)(
3000b3a8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b3ac: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b3b0: e59f2438 ldr r2, [pc, #1080] ; 3000b7f0 <_Heap_Walk+0x534> <== NOT EXECUTED 3000b3b4: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b3b8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b3bc: e12fff14 bx r4 <== NOT EXECUTED 3000b3c0: ea0000f9 b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED 3000b3c4: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000b3c8: e1a01009 mov r1, r9 <== NOT EXECUTED 3000b3cc: e28c0008 add r0, ip, #8 <== NOT EXECUTED 3000b3d0: ebffe73c bl 300050c8 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000b3d4: e250a000 subs sl, r0, #0 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
3000b3d8: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b3dc: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b3e0: 159f240c ldrne r2, [pc, #1036] ; 3000b7f4 <_Heap_Walk+0x538><== NOT EXECUTED 3000b3e4: 159d3020 ldrne r3, [sp, #32] <== NOT EXECUTED 3000b3e8: 1a0000cc bne 3000b720 <_Heap_Walk+0x464> <== NOT EXECUTED
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;
3000b3ec: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000b3f0: e5928004 ldr r8, [r2, #4] <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
3000b3f4: e2188001 ands r8, r8, #1 <== NOT EXECUTED
(*printer)(
3000b3f8: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000b3fc: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000b400: 059f23f0 ldreq r2, [pc, #1008] ; 3000b7f8 <_Heap_Walk+0x53c><== NOT EXECUTED 3000b404: 0a000009 beq 3000b430 <_Heap_Walk+0x174> <== NOT EXECUTED
- 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;
3000b408: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000b40c: e5937004 ldr r7, [r3, #4] <== NOT EXECUTED 3000b410: e3c77001 bic r7, r7, #1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000b414: e0837007 add r7, r3, r7 <== NOT EXECUTED
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;
3000b418: e5978004 ldr r8, [r7, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
3000b41c: e2188001 ands r8, r8, #1 <== NOT EXECUTED 3000b420: 1a000005 bne 3000b43c <_Heap_Walk+0x180> <== NOT EXECUTED
(*printer)(
3000b424: e59f23d0 ldr r2, [pc, #976] ; 3000b7fc <_Heap_Walk+0x540> <== NOT EXECUTED 3000b428: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b42c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b430: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b434: e12fff14 bx r4 <== NOT EXECUTED 3000b438: ea0000db b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED
);
return false;
}
if (
3000b43c: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000b440: e157000c cmp r7, ip <== NOT EXECUTED 3000b444: 0a000006 beq 3000b464 <_Heap_Walk+0x1a8> <== NOT EXECUTED
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
3000b448: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b44c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b450: e59f23a8 ldr r2, [pc, #936] ; 3000b800 <_Heap_Walk+0x544> <== NOT EXECUTED 3000b454: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b458: e12fff14 bx r4 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000b45c: e1a0800a mov r8, sl <== NOT EXECUTED 3000b460: ea0000d1 b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
3000b464: e596b010 ldr fp, [r6, #16] <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000b468: e5968008 ldr r8, [r6, #8] <== NOT EXECUTED
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
3000b46c: e1a0a006 mov sl, r6 <== NOT EXECUTED 3000b470: ea000034 b 3000b548 <_Heap_Walk+0x28c> <== NOT EXECUTED
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;
3000b474: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED 3000b478: e1530008 cmp r3, r8 <== NOT EXECUTED 3000b47c: 83a0c000 movhi ip, #0 <== NOT EXECUTED 3000b480: 8a000003 bhi 3000b494 <_Heap_Walk+0x1d8> <== NOT EXECUTED 3000b484: e596c024 ldr ip, [r6, #36] ; 0x24 <== NOT EXECUTED 3000b488: e15c0008 cmp ip, r8 <== NOT EXECUTED 3000b48c: 33a0c000 movcc ip, #0 <== NOT EXECUTED 3000b490: 23a0c001 movcs ip, #1 <== NOT EXECUTED
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
3000b494: e21cc0ff ands ip, ip, #255 ; 0xff <== NOT EXECUTED
(*printer)(
3000b498: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000b49c: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000b4a0: 059f235c ldreq r2, [pc, #860] ; 3000b804 <_Heap_Walk+0x548><== NOT EXECUTED 3000b4a4: 0a000012 beq 3000b4f4 <_Heap_Walk+0x238> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000b4a8: e2880008 add r0, r8, #8 <== NOT EXECUTED 3000b4ac: e1a0100b mov r1, fp <== NOT EXECUTED 3000b4b0: ebffe704 bl 300050c8 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000b4b4: e250c000 subs ip, r0, #0 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
3000b4b8: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b4bc: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b4c0: 159f2340 ldrne r2, [pc, #832] ; 3000b808 <_Heap_Walk+0x54c><== NOT EXECUTED 3000b4c4: 11a03008 movne r3, r8 <== NOT EXECUTED 3000b4c8: 1a0000be bne 3000b7c8 <_Heap_Walk+0x50c> <== NOT EXECUTED
- 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;
3000b4cc: e5983004 ldr r3, [r8, #4] <== NOT EXECUTED 3000b4d0: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000b4d4: e0883003 add r3, r8, r3 <== NOT EXECUTED
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;
3000b4d8: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000b4dc: e2133001 ands r3, r3, #1 <== NOT EXECUTED 3000b4e0: e58d302c str r3, [sp, #44] ; 0x2c <== NOT EXECUTED 3000b4e4: 0a000009 beq 3000b510 <_Heap_Walk+0x254> <== NOT EXECUTED
(*printer)(
3000b4e8: e59f231c ldr r2, [pc, #796] ; 3000b80c <_Heap_Walk+0x550> <== NOT EXECUTED 3000b4ec: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b4f0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b4f4: e1a03008 mov r3, r8 <== NOT EXECUTED 3000b4f8: e58dc01c str ip, [sp, #28] <== NOT EXECUTED 3000b4fc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b500: e12fff14 bx r4 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000b504: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 3000b508: e1a0800c mov r8, ip <== NOT EXECUTED 3000b50c: ea0000a6 b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED
);
return false;
}
if ( free_block->prev != prev_block ) {
3000b510: e598300c ldr r3, [r8, #12] <== NOT EXECUTED 3000b514: e153000a cmp r3, sl <== NOT EXECUTED 3000b518: 0a000008 beq 3000b540 <_Heap_Walk+0x284> <== NOT EXECUTED
(*printer)(
3000b51c: e58d3000 str r3, [sp] <== NOT EXECUTED 3000b520: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b524: e1a03008 mov r3, r8 <== NOT EXECUTED 3000b528: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b52c: e59f22dc ldr r2, [pc, #732] ; 3000b810 <_Heap_Walk+0x554> <== NOT EXECUTED 3000b530: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b534: e12fff14 bx r4 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000b538: e59d802c ldr r8, [sp, #44] ; 0x2c <== NOT EXECUTED 3000b53c: ea00009a b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED
return false;
}
prev_block = free_block;
free_block = free_block->next;
3000b540: e1a0a008 mov sl, r8 <== NOT EXECUTED 3000b544: e5988008 ldr r8, [r8, #8] <== NOT EXECUTED
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
3000b548: e1580006 cmp r8, r6 <== NOT EXECUTED 3000b54c: 1affffc8 bne 3000b474 <_Heap_Walk+0x1b8> <== NOT EXECUTED 3000b550: ea000000 b 3000b558 <_Heap_Walk+0x29c> <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000b554: e1a07008 mov r7, r8 <== NOT EXECUTED
return true;
}
3000b558: e5973004 ldr r3, [r7, #4] <== NOT EXECUTED
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;
3000b55c: e5962020 ldr r2, [r6, #32] <== NOT EXECUTED
- 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;
3000b560: e3c3a001 bic sl, r3, #1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000b564: e087800a add r8, r7, sl <== NOT EXECUTED
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;
3000b568: e1520008 cmp r2, r8 <== NOT EXECUTED 3000b56c: 83a0b000 movhi fp, #0 <== NOT EXECUTED 3000b570: 8a000003 bhi 3000b584 <_Heap_Walk+0x2c8> <== NOT EXECUTED 3000b574: e596b024 ldr fp, [r6, #36] ; 0x24 <== NOT EXECUTED 3000b578: e15b0008 cmp fp, r8 <== NOT EXECUTED 3000b57c: 33a0b000 movcc fp, #0 <== NOT EXECUTED 3000b580: 23a0b001 movcs fp, #1 <== NOT EXECUTED
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
3000b584: e21bb0ff ands fp, fp, #255 ; 0xff <== NOT EXECUTED 3000b588: 1a000007 bne 3000b5ac <_Heap_Walk+0x2f0> <== NOT EXECUTED
(*printer)(
3000b58c: e58d8000 str r8, [sp] <== NOT EXECUTED 3000b590: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b594: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b598: e59f2274 ldr r2, [pc, #628] ; 3000b814 <_Heap_Walk+0x558> <== NOT EXECUTED 3000b59c: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b5a0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b5a4: e12fff14 bx r4 <== NOT EXECUTED 3000b5a8: ea00005e b 3000b728 <_Heap_Walk+0x46c> <== NOT EXECUTED
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
3000b5ac: e59d2028 ldr r2, [sp, #40] ; 0x28 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000b5b0: e1a0000a mov r0, sl <== NOT EXECUTED 3000b5b4: e1a01009 mov r1, r9 <== NOT EXECUTED 3000b5b8: e057b002 subs fp, r7, r2 <== NOT EXECUTED 3000b5bc: 13a0b001 movne fp, #1 <== NOT EXECUTED 3000b5c0: e58d301c str r3, [sp, #28] <== NOT EXECUTED 3000b5c4: ebffe6bf bl 300050c8 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
3000b5c8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b5cc: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 3000b5d0: 0a000005 beq 3000b5ec <_Heap_Walk+0x330> <== NOT EXECUTED 3000b5d4: e35b0000 cmp fp, #0 <== NOT EXECUTED
(*printer)(
3000b5d8: 158da000 strne sl, [sp] <== NOT EXECUTED 3000b5dc: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b5e0: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b5e4: 159f222c ldrne r2, [pc, #556] ; 3000b818 <_Heap_Walk+0x55c><== NOT EXECUTED 3000b5e8: 1a000014 bne 3000b640 <_Heap_Walk+0x384> <== NOT EXECUTED
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
3000b5ec: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b5f0: e15a000c cmp sl, ip <== NOT EXECUTED 3000b5f4: 2a000009 bcs 3000b620 <_Heap_Walk+0x364> <== NOT EXECUTED 3000b5f8: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b5fc: 0a000007 beq 3000b620 <_Heap_Walk+0x364> <== NOT EXECUTED
(*printer)(
3000b600: e88d1400 stm sp, {sl, ip} <== NOT EXECUTED
3000b604: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b608: e3a01001 mov r1, #1 <== NOT EXECUTED
3000b60c: e59f2208 ldr r2, [pc, #520] ; 3000b81c <_Heap_Walk+0x560> <== NOT EXECUTED
3000b610: e1a03007 mov r3, r7 <== NOT EXECUTED
3000b614: e1a0e00f mov lr, pc <== NOT EXECUTED
3000b618: e12fff14 bx r4 <== NOT EXECUTED
3000b61c: ea00006b b 3000b7d0 <_Heap_Walk+0x514> <== NOT EXECUTED
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
3000b620: e1580007 cmp r8, r7 <== NOT EXECUTED 3000b624: 8a000009 bhi 3000b650 <_Heap_Walk+0x394> <== NOT EXECUTED 3000b628: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b62c: 0a000007 beq 3000b650 <_Heap_Walk+0x394> <== NOT EXECUTED
(*printer)(
3000b630: e59f21e8 ldr r2, [pc, #488] ; 3000b820 <_Heap_Walk+0x564> <== NOT EXECUTED 3000b634: e58d8000 str r8, [sp] <== NOT EXECUTED 3000b638: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b63c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b640: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b644: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b648: e12fff14 bx r4 <== NOT EXECUTED 3000b64c: ea00005f b 3000b7d0 <_Heap_Walk+0x514> <== NOT EXECUTED
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;
3000b650: e203b001 and fp, r3, #1 <== NOT EXECUTED 3000b654: e5983004 ldr r3, [r8, #4] <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
3000b658: e3130001 tst r3, #1 <== NOT EXECUTED 3000b65c: 1a00003b bne 3000b750 <_Heap_Walk+0x494> <== NOT EXECUTED
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
3000b660: e597200c ldr r2, [r7, #12] <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000b664: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000b668: e596100c ldr r1, [r6, #12] <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000b66c: e1520003 cmp r2, r3 <== NOT EXECUTED 3000b670: 059f01ac ldreq r0, [pc, #428] ; 3000b824 <_Heap_Walk+0x568><== NOT EXECUTED 3000b674: 0a000003 beq 3000b688 <_Heap_Walk+0x3cc> <== NOT EXECUTED
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
3000b678: e59f31a8 ldr r3, [pc, #424] ; 3000b828 <_Heap_Walk+0x56c> <== NOT EXECUTED 3000b67c: e1520006 cmp r2, r6 <== NOT EXECUTED 3000b680: e59f01a4 ldr r0, [pc, #420] ; 3000b82c <_Heap_Walk+0x570> <== NOT EXECUTED 3000b684: 01a00003 moveq r0, r3 <== NOT EXECUTED
block->next,
block->next == last_free_block ?
3000b688: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000b68c: e1530001 cmp r3, r1 <== NOT EXECUTED 3000b690: 059f1198 ldreq r1, [pc, #408] ; 3000b830 <_Heap_Walk+0x574><== NOT EXECUTED 3000b694: 0a000003 beq 3000b6a8 <_Heap_Walk+0x3ec> <== NOT EXECUTED
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
3000b698: e59fc194 ldr ip, [pc, #404] ; 3000b834 <_Heap_Walk+0x578> <== NOT EXECUTED 3000b69c: e1530006 cmp r3, r6 <== NOT EXECUTED 3000b6a0: e59f1184 ldr r1, [pc, #388] ; 3000b82c <_Heap_Walk+0x570> <== NOT EXECUTED 3000b6a4: 01a0100c moveq r1, ip <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000b6a8: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000b6ac: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000b6b0: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000b6b4: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000b6b8: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b6bc: e58da000 str sl, [sp] <== NOT EXECUTED 3000b6c0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b6c4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b6c8: e59f2168 ldr r2, [pc, #360] ; 3000b838 <_Heap_Walk+0x57c> <== NOT EXECUTED 3000b6cc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b6d0: e12fff14 bx r4 <== NOT EXECUTED
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
3000b6d4: e5983000 ldr r3, [r8] <== NOT EXECUTED 3000b6d8: e15a0003 cmp sl, r3 <== NOT EXECUTED 3000b6dc: 0a000009 beq 3000b708 <_Heap_Walk+0x44c> <== NOT EXECUTED
(*printer)(
3000b6e0: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000b6e4: e58da000 str sl, [sp] <== NOT EXECUTED 3000b6e8: e58d8008 str r8, [sp, #8] <== NOT EXECUTED 3000b6ec: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b6f0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b6f4: e59f2140 ldr r2, [pc, #320] ; 3000b83c <_Heap_Walk+0x580> <== NOT EXECUTED 3000b6f8: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b6fc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b700: e12fff14 bx r4 <== NOT EXECUTED 3000b704: ea000031 b 3000b7d0 <_Heap_Walk+0x514> <== NOT EXECUTED
);
return false;
}
if ( !prev_used ) {
3000b708: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b70c: 1a000007 bne 3000b730 <_Heap_Walk+0x474> <== NOT EXECUTED
(*printer)(
3000b710: e59f2128 ldr r2, [pc, #296] ; 3000b840 <_Heap_Walk+0x584> <== NOT EXECUTED 3000b714: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b718: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b71c: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b720: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b724: e12fff14 bx r4 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000b728: e1a0800b mov r8, fp <== NOT EXECUTED 3000b72c: ea00001e b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000b730: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED 3000b734: ea000002 b 3000b744 <_Heap_Walk+0x488> <== NOT EXECUTED
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
3000b738: e1530007 cmp r3, r7 <== NOT EXECUTED 3000b73c: 0a000016 beq 3000b79c <_Heap_Walk+0x4e0> <== NOT EXECUTED
return true;
}
free_block = free_block->next;
3000b740: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
3000b744: e1530006 cmp r3, r6 <== NOT EXECUTED 3000b748: 1afffffa bne 3000b738 <_Heap_Walk+0x47c> <== NOT EXECUTED 3000b74c: ea000019 b 3000b7b8 <_Heap_Walk+0x4fc> <== NOT EXECUTED
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
3000b750: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b754: 0a000007 beq 3000b778 <_Heap_Walk+0x4bc> <== NOT EXECUTED
(*printer)(
3000b758: e58da000 str sl, [sp] <== NOT EXECUTED 3000b75c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b760: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b764: e59f20d8 ldr r2, [pc, #216] ; 3000b844 <_Heap_Walk+0x588> <== NOT EXECUTED 3000b768: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b76c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b770: e12fff14 bx r4 <== NOT EXECUTED 3000b774: ea000008 b 3000b79c <_Heap_Walk+0x4e0> <== NOT EXECUTED
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
3000b778: e58da000 str sl, [sp] <== NOT EXECUTED 3000b77c: e5973000 ldr r3, [r7] <== NOT EXECUTED 3000b780: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b784: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000b788: e1a0100b mov r1, fp <== NOT EXECUTED 3000b78c: e59f20b4 ldr r2, [pc, #180] ; 3000b848 <_Heap_Walk+0x58c> <== NOT EXECUTED 3000b790: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b794: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b798: e12fff14 bx r4 <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000b79c: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000b7a0: e1580002 cmp r8, r2 <== NOT EXECUTED 3000b7a4: 1affff6a bne 3000b554 <_Heap_Walk+0x298> <== NOT EXECUTED
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
3000b7a8: e3a08001 mov r8, #1 <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000b7ac: e1a00008 mov r0, r8 <== NOT EXECUTED
3000b7b0: e28dd030 add sp, sp, #48 ; 0x30 <== NOT EXECUTED
3000b7b4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
3000b7b8: e59f208c ldr r2, [pc, #140] ; 3000b84c <_Heap_Walk+0x590> <== NOT EXECUTED 3000b7bc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b7c0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b7c4: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b7c8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b7cc: e12fff14 bx r4 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000b7d0: e3a08000 mov r8, #0 <== NOT EXECUTED 3000b7d4: eafffff4 b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED
3000b278 <_Heap_Walk_print>:
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
3000b278: e92d000c push {r2, r3} <== NOT EXECUTED
3000b27c: e92d4001 push {r0, lr} <== NOT EXECUTED
3000b280: e1a03000 mov r3, r0 <== NOT EXECUTED
va_list ap;
if ( error ) {
3000b284: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
3000b288: 159f0024 ldrne r0, [pc, #36] ; 3000b2b4 <_Heap_Walk_print+0x3c><== NOT EXECUTED
} else {
printk( "PASS[%d]: ", source );
3000b28c: 059f0024 ldreq r0, [pc, #36] ; 3000b2b8 <_Heap_Walk_print+0x40><== NOT EXECUTED 3000b290: e1a01003 mov r1, r3 <== NOT EXECUTED 3000b294: ebfff17d bl 30007890 <printk> <== NOT EXECUTED
}
va_start( ap, fmt );
3000b298: e28d100c add r1, sp, #12 <== NOT EXECUTED
vprintk( fmt, ap );
3000b29c: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
3000b2a0: e58d1000 str r1, [sp] <== NOT EXECUTED
vprintk( fmt, ap );
3000b2a4: ebfff847 bl 300093c8 <vprintk> <== NOT EXECUTED
va_end( ap ); }
3000b2a8: e8bd4008 pop {r3, lr} <== NOT EXECUTED
3000b2ac: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000b2b0: e12fff1e bx lr <== NOT EXECUTED
3000b26c <_Heap_Walk_print_nothing>:
int source,
bool error,
const char *fmt,
...
)
{
3000b26c: e92d000c push {r2, r3} <== NOT EXECUTED
/* Do nothing */ }
3000b270: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000b274: e12fff1e bx lr <== NOT EXECUTED
3000a6a0 <_Internal_error_Occurred>:
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
3000a6a0: e59f3038 ldr r3, [pc, #56] ; 3000a6e0 <_Internal_error_Occurred+0x40>
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000a6a4: e20110ff and r1, r1, #255 ; 0xff
3000a6a8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
_Internal_errors_What_happened.the_source = the_source;
3000a6ac: e5830000 str r0, [r3]
_Internal_errors_What_happened.is_internal = is_internal;
3000a6b0: e5c31004 strb r1, [r3, #4]
_Internal_errors_What_happened.the_error = the_error;
3000a6b4: e5832008 str r2, [r3, #8]
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000a6b8: e1a04002 mov r4, r2
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
3000a6bc: eb000738 bl 3000c3a4 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
3000a6c0: e59f301c ldr r3, [pc, #28] ; 3000a6e4 <_Internal_error_Occurred+0x44><== NOT EXECUTED 3000a6c4: e3a02005 mov r2, #5 <== NOT EXECUTED 3000a6c8: e5832000 str r2, [r3] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a6cc: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000a6d0: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000a6d4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
3000a6d8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a6dc: eafffffe b 3000a6dc <_Internal_error_Occurred+0x3c> <== NOT EXECUTED
3000ab6c <_Objects_Get>:
* always NULL.
*
* If the Id is valid but the object has not been created yet, then
* the local_table entry will be NULL.
*/
index = id - information->minimum_id + 1;
3000ab6c: e5903008 ldr r3, [r0, #8]
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000ab70: e92d4030 push {r4, r5, lr}
* always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1;
3000ab74: e2633001 rsb r3, r3, #1
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000ab78: e1a04002 mov r4, r2
/*
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
3000ab7c: e1d021b0 ldrh r2, [r0, #16]
* always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1;
3000ab80: e0833001 add r3, r3, r1
/*
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
3000ab84: e1530002 cmp r3, r2
/* * Object Id is not within this API and Class on this node. So * it may be global in a multiprocessing system. But it is clearly * invalid on a single processor system. */ *location = OBJECTS_ERROR;
3000ab88: 83a03001 movhi r3, #1 3000ab8c: 85843000 strhi r3, [r4]
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
3000ab90: 83a05000 movhi r5, #0
/*
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
3000ab94: 8a00000b bhi 3000abc8 <_Objects_Get+0x5c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000ab98: e59f2030 ldr r2, [pc, #48] ; 3000abd0 <_Objects_Get+0x64> 3000ab9c: e5921000 ldr r1, [r2] 3000aba0: e2811001 add r1, r1, #1 3000aba4: e5821000 str r1, [r2]
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000aba8: e590201c ldr r2, [r0, #28] 3000abac: e7925103 ldr r5, [r2, r3, lsl #2] 3000abb0: e3550000 cmp r5, #0
*location = OBJECTS_LOCAL;
3000abb4: 13a03000 movne r3, #0
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000abb8: 1a000001 bne 3000abc4 <_Objects_Get+0x58>
/*
* Valid Id for this API, Class and Node but the object has not
* been allocated yet.
*/
_Thread_Enable_dispatch();
3000abbc: eb000304 bl 3000b7d4 <_Thread_Enable_dispatch> <== NOT EXECUTED
*location = OBJECTS_ERROR;
3000abc0: e3a03001 mov r3, #1 <== NOT EXECUTED
3000abc4: e5843000 str r3, [r4]
_Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif }
3000abc8: e1a00005 mov r0, r5
3000abcc: e8bd8030 pop {r4, r5, pc}
3000aaa0 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000aaa0: e1a01801 lsl r1, r1, #16
3000aaa4: e92d4030 push {r4, r5, lr}
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000aaa8: e1b05821 lsrs r5, r1, #16
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000aaac: e1a04000 mov r4, r0
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
3000aab0: 01a00005 moveq r0, r5
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000aab4: 08bd8030 popeq {r4, r5, pc}
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
3000aab8: eb000ff4 bl 3000ea90 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
3000aabc: e3500000 cmp r0, #0
3000aac0: 08bd8030 popeq {r4, r5, pc}
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
3000aac4: e1550000 cmp r5, r0
3000aac8: 8a00000a bhi 3000aaf8 <_Objects_Get_information+0x58>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
3000aacc: e59f302c ldr r3, [pc, #44] ; 3000ab00 <_Objects_Get_information+0x60>
3000aad0: e7930104 ldr r0, [r3, r4, lsl #2]
3000aad4: e3500000 cmp r0, #0
3000aad8: 08bd8030 popeq {r4, r5, pc}
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
3000aadc: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !info )
3000aae0: e3500000 cmp r0, #0
3000aae4: 08bd8030 popeq {r4, r5, pc}
* In a multprocessing configuration, we may access remote objects.
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
3000aae8: e1d031b0 ldrh r3, [r0, #16]
return NULL;
3000aaec: e3530000 cmp r3, #0
3000aaf0: 03a00000 moveq r0, #0
3000aaf4: e8bd8030 pop {r4, r5, pc}
the_class_api_maximum = _Objects_API_maximum_class( the_api );
if ( the_class_api_maximum == 0 )
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
3000aaf8: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
3000aafc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000ab04 <_Objects_Get_isr_disable>:
{
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000ab04: e590c008 ldr ip, [r0, #8]
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
3000ab08: e92d4010 push {r4, lr}
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000ab0c: e26cc001 rsb ip, ip, #1 3000ab10: e08c1001 add r1, ip, r1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ab14: e10f4000 mrs r4, CPSR 3000ab18: e384c080 orr ip, r4, #128 ; 0x80 3000ab1c: e129f00c msr CPSR_fc, ip
_ISR_Disable( level );
if ( information->maximum >= index ) {
3000ab20: e1d0c1b0 ldrh ip, [r0, #16] 3000ab24: e15c0001 cmp ip, r1
3000ab28: 3a00000a bcc 3000ab58 <_Objects_Get_isr_disable+0x54>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000ab2c: e590001c ldr r0, [r0, #28] 3000ab30: e7900101 ldr r0, [r0, r1, lsl #2] 3000ab34: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3000ab38: 13a01000 movne r1, #0 3000ab3c: 15821000 strne r1, [r2]
*level_p = level;
3000ab40: 15834000 strne r4, [r3]
index = id - information->minimum_id + 1;
_ISR_Disable( level );
if ( information->maximum >= index ) {
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000ab44: 18bd8010 popne {r4, pc}
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ab48: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
3000ab4c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ab50: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3000ab54: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ab58: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
} _ISR_Enable( level ); *location = OBJECTS_ERROR;
3000ab5c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ab60: e5823000 str r3, [r2] <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
3000ab64: e3a00000 mov r0, #0 <== NOT EXECUTED
#endif }
3000ab68: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c5c8 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
3000c5c8: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
3000c5cc: e2515000 subs r5, r1, #0 <== NOT EXECUTED
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
3000c5d0: e1a04002 mov r4, r2 <== NOT EXECUTED
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
return NULL;
3000c5d4: 01a04005 moveq r4, r5 <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
3000c5d8: 0a00002e beq 3000c698 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED
return NULL;
if ( name == NULL )
3000c5dc: e3540000 cmp r4, #0 <== NOT EXECUTED 3000c5e0: 0a00002c beq 3000c698 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000c5e4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c5e8: 059f30b0 ldreq r3, [pc, #176] ; 3000c6a0 <_Objects_Get_name_as_string+0xd8><== NOT EXECUTED 3000c5ec: 11a06000 movne r6, r0 <== NOT EXECUTED 3000c5f0: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000c5f4: 05936008 ldreq r6, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3000c5f8: e1a00006 mov r0, r6 <== NOT EXECUTED 3000c5fc: ebffffb9 bl 3000c4e8 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
3000c600: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return NULL;
3000c604: 01a04003 moveq r4, r3 <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
information = _Objects_Get_information_id( tmpId );
if ( !information )
3000c608: 0a000022 beq 3000c698 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
3000c60c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000c610: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000c614: eb000023 bl 3000c6a8 <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3000c618: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3000c61c: e3530000 cmp r3, #0 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
3000c620: 13a04000 movne r4, #0 <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
if ( !information )
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
3000c624: 1a00001b bne 3000c698 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED
if ( information->is_string ) {
s = the_object->name.name_p;
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
3000c628: e590200c ldr r2, [r0, #12] <== NOT EXECUTED
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
3000c62c: e5cd3004 strb r3, [sp, #4] <== NOT EXECUTED
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
3000c630: e1a01c22 lsr r1, r2, #24 <== NOT EXECUTED 3000c634: e5cd1000 strb r1, [sp] <== NOT EXECUTED
lname[ 1 ] = (u32_name >> 16) & 0xff;
3000c638: e1a01822 lsr r1, r2, #16 <== NOT EXECUTED 3000c63c: e5cd1001 strb r1, [sp, #1] <== NOT EXECUTED
lname[ 2 ] = (u32_name >> 8) & 0xff;
3000c640: e1a01422 lsr r1, r2, #8 <== NOT EXECUTED
lname[ 3 ] = (u32_name >> 0) & 0xff;
3000c644: e5cd2003 strb r2, [sp, #3] <== NOT EXECUTED
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
3000c648: e5cd1002 strb r1, [sp, #2] <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000c64c: e1a02004 mov r2, r4 <== NOT EXECUTED 3000c650: e2455001 sub r5, r5, #1 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
3000c654: e59f0048 ldr r0, [pc, #72] ; 3000c6a4 <_Objects_Get_name_as_string+0xdc><== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000c658: ea000006 b 3000c678 <_Objects_Get_name_as_string+0xb0> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
3000c65c: e590c000 ldr ip, [r0] <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000c660: e2833001 add r3, r3, #1 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
3000c664: e08cc001 add ip, ip, r1 <== NOT EXECUTED 3000c668: e5dcc001 ldrb ip, [ip, #1] <== NOT EXECUTED 3000c66c: e31c0097 tst ip, #151 ; 0x97 <== NOT EXECUTED 3000c670: 03a0102a moveq r1, #42 ; 0x2a <== NOT EXECUTED 3000c674: e4c21001 strb r1, [r2], #1 <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000c678: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c67c: 2a000002 bcs 3000c68c <_Objects_Get_name_as_string+0xc4> <== NOT EXECUTED 3000c680: e7dd1003 ldrb r1, [sp, r3] <== NOT EXECUTED 3000c684: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c688: 1afffff3 bne 3000c65c <_Objects_Get_name_as_string+0x94> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
3000c68c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000c690: e5c23000 strb r3, [r2] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c694: eb0002fb bl 3000d288 <_Thread_Enable_dispatch> <== NOT EXECUTED
return name;
}
return NULL; /* unreachable path */
}
3000c698: e1a00004 mov r0, r4 <== NOT EXECUTED
3000c69c: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
3000ad20 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
3000ad20: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
3000ad24: e2507000 subs r7, r0, #0 <== NOT EXECUTED
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
3000ad28: e1a04002 mov r4, r2 <== NOT EXECUTED 3000ad2c: e1a06003 mov r6, r3 <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
3000ad30: 01a00007 moveq r0, r7 <== NOT EXECUTED
)
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
3000ad34: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return NULL;
if ( !location_p )
3000ad38: e3520000 cmp r2, #0 <== NOT EXECUTED
return NULL;
3000ad3c: 01a00002 moveq r0, r2 <== NOT EXECUTED
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
3000ad40: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return NULL;
if ( !next_id_p )
3000ad44: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ad48: 0a000016 beq 3000ada8 <_Objects_Get_next+0x88> <== NOT EXECUTED
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
3000ad4c: e1b03801 lsls r3, r1, #16 <== NOT EXECUTED
next_id = information->minimum_id;
3000ad50: 05975008 ldreq r5, [r7, #8] <== NOT EXECUTED
else
next_id = id;
3000ad54: 11a05001 movne r5, r1 <== NOT EXECUTED
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
3000ad58: e1d731b0 ldrh r3, [r7, #16] <== NOT EXECUTED 3000ad5c: e1a02805 lsl r2, r5, #16 <== NOT EXECUTED 3000ad60: e1530822 cmp r3, r2, lsr #16 <== NOT EXECUTED 3000ad64: 2a000005 bcs 3000ad80 <_Objects_Get_next+0x60> <== NOT EXECUTED
{
*location_p = OBJECTS_ERROR;
3000ad68: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ad6c: e5843000 str r3, [r4] <== NOT EXECUTED
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
3000ad70: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000ad74: e5863000 str r3, [r6] <== NOT EXECUTED
return 0;
3000ad78: e3a00000 mov r0, #0 <== NOT EXECUTED
3000ad7c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
3000ad80: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ad84: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ad88: e1a02004 mov r2, r4 <== NOT EXECUTED 3000ad8c: eb000007 bl 3000adb0 <_Objects_Get> <== NOT EXECUTED
next_id++;
} while (*location_p != OBJECTS_LOCAL);
3000ad90: e5943000 ldr r3, [r4] <== NOT EXECUTED
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
next_id++;
3000ad94: e2855001 add r5, r5, #1 <== NOT EXECUTED
} while (*location_p != OBJECTS_LOCAL);
3000ad98: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ad9c: 1affffed bne 3000ad58 <_Objects_Get_next+0x38> <== NOT EXECUTED
*next_id_p = next_id;
3000ada0: e5865000 str r5, [r6] <== NOT EXECUTED
return object;
3000ada4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
3000ada8: e1a00003 mov r0, r3 <== NOT EXECUTED
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
3000adac: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3001acc8 <_Objects_Get_no_protection>:
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
3001acc8: e5903008 ldr r3, [r0, #8] 3001accc: e2633001 rsb r3, r3, #1 3001acd0: e0833001 add r3, r3, r1
if ( information->maximum >= index ) {
3001acd4: e1d011b0 ldrh r1, [r0, #16] 3001acd8: e1510003 cmp r1, r3
3001acdc: 3a000005 bcc 3001acf8 <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3001ace0: e590101c ldr r1, [r0, #28] 3001ace4: e7910103 ldr r0, [r1, r3, lsl #2] 3001ace8: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3001acec: 13a03000 movne r3, #0 3001acf0: 15823000 strne r3, [r2]
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
if ( information->maximum >= index ) {
if ( (the_object = information->local_table[ index ]) != NULL ) {
3001acf4: 112fff1e bxne lr
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
3001acf8: e3a03001 mov r3, #1 <== NOT EXECUTED 3001acfc: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3001ad00: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3001ad04: e12fff1e bx lr <== NOT EXECUTED
3000c0cc <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
3000c0cc: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3000c0d0: e1a04001 mov r4, r1 <== NOT EXECUTED
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000c0d4: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000c0d8: 059f306c ldreq r3, [pc, #108] ; 3000c14c <_Objects_Id_to_name+0x80><== NOT EXECUTED 3000c0dc: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000c0e0: 05931008 ldreq r1, [r3, #8] <== NOT EXECUTED 3000c0e4: e1a03c21 lsr r3, r1, #24 <== NOT EXECUTED 3000c0e8: e2033007 and r3, r3, #7 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000c0ec: e2432001 sub r2, r3, #1 <== NOT EXECUTED 3000c0f0: e3520002 cmp r2, #2 <== NOT EXECUTED 3000c0f4: 8a00000d bhi 3000c130 <_Objects_Id_to_name+0x64> <== NOT EXECUTED 3000c0f8: ea00000e b 3000c138 <_Objects_Id_to_name+0x6c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000c0fc: e1a02da1 lsr r2, r1, #27 <== NOT EXECUTED
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
3000c100: e7930102 ldr r0, [r3, r2, lsl #2] <== NOT EXECUTED
if ( !information )
3000c104: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c108: 0a000008 beq 3000c130 <_Objects_Id_to_name+0x64> <== NOT EXECUTED
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
3000c10c: e1a0200d mov r2, sp <== NOT EXECUTED 3000c110: ebffffd3 bl 3000c064 <_Objects_Get> <== NOT EXECUTED
if ( !the_object )
3000c114: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c118: 0a000004 beq 3000c130 <_Objects_Id_to_name+0x64> <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
3000c11c: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000c120: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c124: eb00030a bl 3000cd54 <_Thread_Enable_dispatch> <== NOT EXECUTED
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000c128: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c12c: ea000000 b 3000c134 <_Objects_Id_to_name+0x68> <== NOT EXECUTED
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
3000c130: e3a00003 mov r0, #3 <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
3000c134: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
3000c138: e59f2010 ldr r2, [pc, #16] ; 3000c150 <_Objects_Id_to_name+0x84><== NOT EXECUTED 3000c13c: e7923103 ldr r3, [r2, r3, lsl #2] <== NOT EXECUTED 3000c140: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c144: 1affffec bne 3000c0fc <_Objects_Id_to_name+0x30> <== NOT EXECUTED 3000c148: eafffff8 b 3000c130 <_Objects_Id_to_name+0x64> <== NOT EXECUTED
3000aca0 <_Objects_Name_to_id_u32>:
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000aca0: e3530000 cmp r3, #0
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
3000aca4: e92d4030 push {r4, r5, lr}
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
3000aca8: 03a00002 moveq r0, #2
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000acac: 08bd8030 popeq {r4, r5, pc}
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
3000acb0: e3510000 cmp r1, #0
3000acb4: 0a000017 beq 3000ad18 <_Objects_Name_to_id_u32+0x78>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
3000acb8: e1d041b0 ldrh r4, [r0, #16] 3000acbc: e3540000 cmp r4, #0
3000acc0: 0a000016 beq 3000ad20 <_Objects_Name_to_id_u32+0x80>
3000acc4: e3720106 cmn r2, #-2147483647 ; 0x80000001 3000acc8: 13520000 cmpne r2, #0 3000accc: 03a02001 moveq r2, #1
3000acd0: 0a00000e beq 3000ad10 <_Objects_Name_to_id_u32+0x70>
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
3000acd4: e3520001 cmp r2, #1 <== NOT EXECUTED 3000acd8: 1a00000e bne 3000ad18 <_Objects_Name_to_id_u32+0x78> <== NOT EXECUTED 3000acdc: ea00000b b 3000ad10 <_Objects_Name_to_id_u32+0x70> <== NOT EXECUTED
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
the_object = information->local_table[ index ];
3000ace0: e590c01c ldr ip, [r0, #28] 3000ace4: e79cc102 ldr ip, [ip, r2, lsl #2]
if ( !the_object )
3000ace8: e35c0000 cmp ip, #0
3000acec: 0a000006 beq 3000ad0c <_Objects_Name_to_id_u32+0x6c>
continue;
if ( name == the_object->name.name_u32 ) {
3000acf0: e59c500c ldr r5, [ip, #12] 3000acf4: e1510005 cmp r1, r5
3000acf8: 1a000003 bne 3000ad0c <_Objects_Name_to_id_u32+0x6c>
*id = the_object->id;
3000acfc: e59c2008 ldr r2, [ip, #8]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000ad00: e3a00000 mov r0, #0
the_object = information->local_table[ index ];
if ( !the_object )
continue;
if ( name == the_object->name.name_u32 ) {
*id = the_object->id;
3000ad04: e5832000 str r2, [r3]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000ad08: e8bd8030 pop {r4, r5, pc}
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000ad0c: e2822001 add r2, r2, #1 3000ad10: e1520004 cmp r2, r4
3000ad14: 9afffff1 bls 3000ace0 <_Objects_Name_to_id_u32+0x40>
if ( !id )
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
return OBJECTS_INVALID_NAME;
3000ad18: e3a00001 mov r0, #1 <== NOT EXECUTED
3000ad1c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
return OBJECTS_INVALID_NAME;
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
3000ad20: e3a00001 mov r0, #1
#endif }
3000ad24: e8bd8030 pop {r4, r5, pc}
3000d080 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000d080: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000d084: e1a04001 mov r4, r1 <== NOT EXECUTED
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000d088: e1d013b8 ldrh r1, [r0, #56] ; 0x38 <== NOT EXECUTED 3000d08c: e1a00002 mov r0, r2 <== NOT EXECUTED
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000d090: e1a05002 mov r5, r2 <== NOT EXECUTED
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000d094: eb001b8f bl 30013ed8 <strnlen> <== NOT EXECUTED
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
3000d098: e3500001 cmp r0, #1 <== NOT EXECUTED 3000d09c: 85d53001 ldrbhi r3, [r5, #1] <== NOT EXECUTED 3000d0a0: e5d52000 ldrb r2, [r5] <== NOT EXECUTED 3000d0a4: 81a03803 lslhi r3, r3, #16 <== NOT EXECUTED 3000d0a8: 93a03602 movls r3, #2097152 ; 0x200000 <== NOT EXECUTED 3000d0ac: e1a02c02 lsl r2, r2, #24 <== NOT EXECUTED 3000d0b0: e3500002 cmp r0, #2 <== NOT EXECUTED 3000d0b4: e1832002 orr r2, r3, r2 <== NOT EXECUTED 3000d0b8: 85d53002 ldrbhi r3, [r5, #2] <== NOT EXECUTED 3000d0bc: 93a03a02 movls r3, #8192 ; 0x2000 <== NOT EXECUTED 3000d0c0: 81a03403 lslhi r3, r3, #8 <== NOT EXECUTED 3000d0c4: e3500003 cmp r0, #3 <== NOT EXECUTED 3000d0c8: e1822003 orr r2, r2, r3 <== NOT EXECUTED 3000d0cc: 85d53003 ldrbhi r3, [r5, #3] <== NOT EXECUTED 3000d0d0: 93a03020 movls r3, #32 <== NOT EXECUTED 3000d0d4: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000d0d8: e584300c str r3, [r4, #12] <== NOT EXECUTED
);
}
return true;
}
3000d0dc: e3a00001 mov r0, #1 <== NOT EXECUTED
3000d0e0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b0f8 <_Protected_heap_Extend>:
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000b0f8: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
bool extend_ok;
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000b0fc: e59f4038 ldr r4, [pc, #56] ; 3000b13c <_Protected_heap_Extend+0x44><== NOT EXECUTED
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000b100: e1a05000 mov r5, r0 <== NOT EXECUTED 3000b104: e1a07001 mov r7, r1 <== NOT EXECUTED 3000b108: e1a06002 mov r6, r2 <== NOT EXECUTED
bool extend_ok;
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000b10c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000b110: ebfffbd8 bl 3000a078 <_API_Mutex_Lock> <== NOT EXECUTED
extend_ok = _Heap_Extend(the_heap, starting_address, size, &amount_extended);
3000b114: e1a01007 mov r1, r7 <== NOT EXECUTED 3000b118: e1a02006 mov r2, r6 <== NOT EXECUTED 3000b11c: e1a0300d mov r3, sp <== NOT EXECUTED 3000b120: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b124: eb000eab bl 3000ebd8 <_Heap_Extend> <== NOT EXECUTED 3000b128: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
3000b12c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000b130: ebfffbe9 bl 3000a0dc <_API_Mutex_Unlock> <== NOT EXECUTED
return extend_ok; }
3000b134: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b138: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000b4e8 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
3000b4e8: e92d4070 push {r4, r5, r6, lr}
if ( !the_heap )
3000b4ec: e2506000 subs r6, r0, #0
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
3000b4f0: e1a05001 mov r5, r1
if ( !the_heap )
return false;
3000b4f4: 01a00006 moveq r0, r6
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
if ( !the_heap )
3000b4f8: 08bd8070 popeq {r4, r5, r6, pc}
return false;
if ( !the_info )
3000b4fc: e3510000 cmp r1, #0
3000b500: 0a000009 beq 3000b52c <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
3000b504: e59f4028 ldr r4, [pc, #40] ; 3000b534 <_Protected_heap_Get_information+0x4c> 3000b508: e5940000 ldr r0, [r4] 3000b50c: ebfffbc6 bl 3000a42c <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
3000b510: e1a00006 mov r0, r6 3000b514: e1a01005 mov r1, r5 3000b518: eb000fcc bl 3000f450 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
3000b51c: e5940000 ldr r0, [r4] 3000b520: ebfffbda bl 3000a490 <_API_Mutex_Unlock>
return true;
3000b524: e3a00001 mov r0, #1
3000b528: e8bd8070 pop {r4, r5, r6, pc}
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
3000b52c: e1a00001 mov r0, r1 <== NOT EXECUTED
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
3000b530: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000ffcc <_Protected_heap_Walk>:
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
3000ffcc: e59f3054 ldr r3, [pc, #84] ; 30010028 <_Protected_heap_Walk+0x5c><== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
3000ffd0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
3000ffd4: e5933000 ldr r3, [r3] <== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
3000ffd8: e1a06000 mov r6, r0 <== NOT EXECUTED
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
3000ffdc: e3530000 cmp r3, #0 <== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
3000ffe0: e1a05001 mov r5, r1 <== NOT EXECUTED 3000ffe4: e20270ff and r7, r2, #255 ; 0xff <== NOT EXECUTED
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
3000ffe8: 1a00000b bne 3001001c <_Protected_heap_Walk+0x50> <== NOT EXECUTED
_RTEMS_Lock_allocator();
3000ffec: e59f4038 ldr r4, [pc, #56] ; 3001002c <_Protected_heap_Walk+0x60><== NOT EXECUTED 3000fff0: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000fff4: ebfff86d bl 3000e1b0 <_API_Mutex_Lock> <== NOT EXECUTED
status = _Heap_Walk( the_heap, source, do_dump );
3000fff8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000fffc: e1a02007 mov r2, r7 <== NOT EXECUTED 30010000: e1a00006 mov r0, r6 <== NOT EXECUTED 30010004: ebfffc3e bl 3000f104 <_Heap_Walk> <== NOT EXECUTED 30010008: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
3001000c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010010: ebfff87f bl 3000e214 <_API_Mutex_Unlock> <== NOT EXECUTED
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
30010014: e1a00005 mov r0, r5 <== NOT EXECUTED
30010018: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
3001001c: e1a02007 mov r2, r7 <== NOT EXECUTED
} return status; }
30010020: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
30010024: eafffc36 b 3000f104 <_Heap_Walk> <== NOT EXECUTED
3000e410 <_RTEMS_Tasks_Invoke_task_variable_dtor>:
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000e410: e59f203c ldr r2, [pc, #60] ; 3000e454 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x44><== NOT EXECUTED
)
{
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
3000e414: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
if (_Thread_Is_executing(the_thread)) {
3000e418: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED
void _RTEMS_Tasks_Invoke_task_variable_dtor(
Thread_Control *the_thread,
rtems_task_variable_t *tvp
)
{
3000e41c: e92d4010 push {r4, lr} <== NOT EXECUTED
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
3000e420: e1520000 cmp r2, r0 <== NOT EXECUTED
value = *tvp->ptr;
3000e424: 05912004 ldreq r2, [r1, #4] <== NOT EXECUTED
void _RTEMS_Tasks_Invoke_task_variable_dtor(
Thread_Control *the_thread,
rtems_task_variable_t *tvp
)
{
3000e428: e1a04001 mov r4, r1 <== NOT EXECUTED
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
value = *tvp->ptr;
*tvp->ptr = tvp->gval;
3000e42c: 05911008 ldreq r1, [r1, #8] <== NOT EXECUTED
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
value = *tvp->ptr;
3000e430: 05920000 ldreq r0, [r2] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
} else {
value = tvp->tval;
3000e434: 1594000c ldrne r0, [r4, #12] <== NOT EXECUTED
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
value = *tvp->ptr;
*tvp->ptr = tvp->gval;
3000e438: 05821000 streq r1, [r2] <== NOT EXECUTED
} else {
value = tvp->tval;
}
if ( dtor )
3000e43c: e3530000 cmp r3, #0 <== NOT EXECUTED
(*dtor)(value);
3000e440: 11a0e00f movne lr, pc <== NOT EXECUTED 3000e444: 112fff13 bxne r3 <== NOT EXECUTED
_Workspace_Free(tvp);
3000e448: e1a00004 mov r0, r4 <== NOT EXECUTED
}
3000e44c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
}
if ( dtor )
(*dtor)(value);
_Workspace_Free(tvp);
3000e450: eafff8f0 b 3000c818 <_Workspace_Free> <== NOT EXECUTED
3000e2e8 <_RTEMS_tasks_Delete_extension>:
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
3000e2e8: e3a03000 mov r3, #0
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
3000e2ec: e92d4070 push {r4, r5, r6, lr}
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
3000e2f0: e5916100 ldr r6, [r1, #256] ; 0x100
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
3000e2f4: e1a04001 mov r4, r1
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
3000e2f8: e5813100 str r3, [r1, #256] ; 0x100
while (tvp) {
3000e2fc: ea000004 b 3000e314 <_RTEMS_tasks_Delete_extension+0x2c>
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
3000e300: e1a01006 mov r1, r6 <== NOT EXECUTED 3000e304: e1a00004 mov r0, r4 <== NOT EXECUTED
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
3000e308: e5965000 ldr r5, [r6] <== NOT EXECUTED
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
3000e30c: eb00003f bl 3000e410 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
tvp = next;
3000e310: e1a06005 mov r6, r5 <== NOT EXECUTED
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
3000e314: e3560000 cmp r6, #0
3000e318: 1afffff8 bne 3000e300 <_RTEMS_tasks_Delete_extension+0x18>
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
3000e31c: e59400f4 ldr r0, [r4, #244] ; 0xf4 3000e320: ebfff93c bl 3000c818 <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
3000e324: e58460f4 str r6, [r4, #244] ; 0xf4
}
3000e328: e8bd8070 pop {r4, r5, r6, pc}
3000e1ec <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
3000e1ec: e5903100 ldr r3, [r0, #256] ; 0x100
while (tvp) {
3000e1f0: ea000005 b 3000e20c <_RTEMS_tasks_Switch_extension+0x20>
tvp->tval = *tvp->ptr;
3000e1f4: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000e1f8: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000e1fc: e583000c str r0, [r3, #12] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
3000e200: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
3000e204: e5933000 ldr r3, [r3] <== NOT EXECUTED
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
3000e208: e5820000 str r0, [r2] <== NOT EXECUTED
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
3000e20c: e3530000 cmp r3, #0
3000e210: 1afffff7 bne 3000e1f4 <_RTEMS_tasks_Switch_extension+0x8>
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
3000e214: e5913100 ldr r3, [r1, #256] ; 0x100
while (tvp) {
3000e218: ea000005 b 3000e234 <_RTEMS_tasks_Switch_extension+0x48>
tvp->gval = *tvp->ptr;
3000e21c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000e220: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000e224: e5831008 str r1, [r3, #8] <== NOT EXECUTED
*tvp->ptr = tvp->tval;
3000e228: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
3000e22c: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
3000e230: e5821000 str r1, [r2] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
3000e234: e3530000 cmp r3, #0
3000e238: 1afffff7 bne 3000e21c <_RTEMS_tasks_Switch_extension+0x30>
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
3000e23c: e12fff1e bx lr
3000a990 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
3000a990: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3000a994: e1a01000 mov r1, r0 <== NOT EXECUTED
3000a998: e1a0200d mov r2, sp <== NOT EXECUTED
3000a99c: e59f0088 ldr r0, [pc, #136] ; 3000aa2c <_Rate_monotonic_Timeout+0x9c><== NOT EXECUTED
3000a9a0: eb00071d bl 3000c61c <_Objects_Get> <== NOT EXECUTED
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000a9a4: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a9a8: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a9ac: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a9b0: 1a00001c bne 3000aa28 <_Rate_monotonic_Timeout+0x98> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_thread = the_period->owner;
3000a9b4: e5900040 ldr r0, [r0, #64] ; 0x40 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_PERIOD);
3000a9b8: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
3000a9bc: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 3000a9c0: 0a000006 beq 3000a9e0 <_Rate_monotonic_Timeout+0x50> <== NOT EXECUTED 3000a9c4: e5902020 ldr r2, [r0, #32] <== NOT EXECUTED 3000a9c8: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000a9cc: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a9d0: 1a000002 bne 3000a9e0 <_Rate_monotonic_Timeout+0x50> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000a9d4: e59f1054 ldr r1, [pc, #84] ; 3000aa30 <_Rate_monotonic_Timeout+0xa0><== NOT EXECUTED 3000a9d8: eb000964 bl 3000cf70 <_Thread_Clear_state> <== NOT EXECUTED 3000a9dc: ea000006 b 3000a9fc <_Rate_monotonic_Timeout+0x6c> <== NOT EXECUTED
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
3000a9e0: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 3000a9e4: e3530001 cmp r3, #1 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
3000a9e8: 13a03004 movne r3, #4 <== NOT EXECUTED 3000a9ec: 15843038 strne r3, [r4, #56] ; 0x38 <== NOT EXECUTED
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
3000a9f0: 1a000008 bne 3000aa18 <_Rate_monotonic_Timeout+0x88> <== NOT EXECUTED
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
3000a9f4: e2833002 add r3, r3, #2 <== NOT EXECUTED 3000a9f8: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
3000a9fc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aa00: ebfffe7a bl 3000a3f0 <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000aa04: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000aa08: e59f0024 ldr r0, [pc, #36] ; 3000aa34 <_Rate_monotonic_Timeout+0xa4><== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000aa0c: e584301c str r3, [r4, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000aa10: e2841010 add r1, r4, #16 <== NOT EXECUTED 3000aa14: eb000da5 bl 3000e0b0 <_Watchdog_Insert> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000aa18: e59f3018 ldr r3, [pc, #24] ; 3000aa38 <_Rate_monotonic_Timeout+0xa8><== NOT EXECUTED 3000aa1c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000aa20: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000aa24: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
3000aa28: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000b3fc <_Scheduler_simple_Block>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Block(
Thread_Control *the_thread
)
{
3000b3fc: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b400: e1a04000 mov r4, r0 <== NOT EXECUTED
_Scheduler_simple_Extract(the_thread);
3000b404: eb00000c bl 3000b43c <_Scheduler_simple_Extract> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
3000b408: e59f3020 ldr r3, [pc, #32] ; 3000b430 <_Scheduler_simple_Block+0x34><== NOT EXECUTED
if ( _Thread_Is_heir( the_thread ) )
3000b40c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000b410: e1540003 cmp r4, r3 <== NOT EXECUTED
_Scheduler_simple_Schedule();
3000b414: 0b000043 bleq 3000b528 <_Scheduler_simple_Schedule> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000b418: e59f3010 ldr r3, [pc, #16] ; 3000b430 <_Scheduler_simple_Block+0x34><== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) )
3000b41c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000b420: e1540002 cmp r4, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000b424: 03a02001 moveq r2, #1 <== NOT EXECUTED
3000b428: 05c32010 strbeq r2, [r3, #16] <== NOT EXECUTED
3000b42c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b438 <_Scheduler_simple_Enqueue>:
void _Scheduler_simple_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler_simple_Ready_queue_Enqueue( the_thread );
3000b438: ea000024 b 3000b4d0 <_Scheduler_simple_Ready_queue_Enqueue><== NOT EXECUTED
3000b434 <_Scheduler_simple_Enqueue_first>:
void _Scheduler_simple_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler_simple_Ready_queue_Enqueue_first( the_thread );
3000b434: ea000014 b 3000b48c <_Scheduler_simple_Ready_queue_Enqueue_first><== NOT EXECUTED
3000b43c <_Scheduler_simple_Extract>:
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
3000b43c: e890000c ldm r0, {r2, r3} <== NOT EXECUTED
previous = the_node->previous; next->previous = previous;
3000b440: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000b444: e5832000 str r2, [r3] <== NOT EXECUTED
void _Scheduler_simple_Extract(
Thread_Control *the_thread
)
{
_Chain_Extract_unprotected( &the_thread->Object.Node );
}
3000b448: e12fff1e bx lr <== NOT EXECUTED
3000b458 <_Scheduler_simple_Free>:
*/
void _Scheduler_simple_Free(
Thread_Control *the_thread
)
{
}
3000b458: e12fff1e bx lr <== NOT EXECUTED
3000b4d0 <_Scheduler_simple_Ready_queue_Enqueue>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Ready_queue_Enqueue(
Thread_Control *the_thread
)
{
3000b4d0: e92d4010 push {r4, lr}
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
3000b4d4: e59f3048 ldr r3, [pc, #72] ; 3000b524 <_Scheduler_simple_Ready_queue_Enqueue+0x54> 3000b4d8: e5933000 ldr r3, [r3]
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000b4dc: e5932000 ldr r2, [r3]
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
3000b4e0: e2831004 add r1, r3, #4
ready = (Chain_Control *)_Scheduler.information;
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
3000b4e4: ea000006 b 3000b504 <_Scheduler_simple_Ready_queue_Enqueue+0x34>
current = (Thread_Control *) the_node;
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
3000b4e8: e5904014 ldr r4, [r0, #20] 3000b4ec: e592c014 ldr ip, [r2, #20]
ready = (Chain_Control *)_Scheduler.information;
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
3000b4f0: e1a03002 mov r3, r2
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
3000b4f4: e154000c cmp r4, ip
current = (Thread_Control *)current->Object.Node.previous;
3000b4f8: 35923004 ldrcc r3, [r2, #4]
break;
3000b4fc: 3a000002 bcc 3000b50c <_Scheduler_simple_Ready_queue_Enqueue+0x3c>
ready = (Chain_Control *)_Scheduler.information;
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
3000b500: e5922000 ldr r2, [r2] <== NOT EXECUTED
3000b504: e1520001 cmp r2, r1
3000b508: 1afffff6 bne 3000b4e8 <_Scheduler_simple_Ready_queue_Enqueue+0x18>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b50c: e5932000 ldr r2, [r3]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b510: e5803004 str r3, [r0, #4]
before_node = after_node->next; after_node->next = the_node;
3000b514: e5830000 str r0, [r3]
the_node->next = before_node; before_node->previous = the_node;
3000b518: e5820004 str r0, [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;
3000b51c: e5802000 str r2, [r0]
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000b520: e8bd8010 pop {r4, pc}
3000b48c <_Scheduler_simple_Ready_queue_Enqueue_first>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
3000b48c: e59f3038 ldr r3, [pc, #56] ; 3000b4cc <_Scheduler_simple_Ready_queue_Enqueue_first+0x40><== NOT EXECUTED
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
3000b490: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000b494: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000b498: e5933000 ldr r3, [r3] <== NOT EXECUTED
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
3000b49c: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED 3000b4a0: e1520001 cmp r2, r1 <== NOT EXECUTED 3000b4a4: 8a000006 bhi 3000b4c4 <_Scheduler_simple_Ready_queue_Enqueue_first+0x38><== NOT EXECUTED
current = (Thread_Control *)current->Object.Node.previous;
3000b4a8: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b4ac: e5932000 ldr r2, [r3] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b4b0: e5803004 str r3, [r0, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b4b4: e5830000 str r0, [r3] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b4b8: e5820004 str r0, [r2, #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;
3000b4bc: e5802000 str r2, [r0] <== NOT EXECUTED
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000b4c0: e12fff1e bx lr <== NOT EXECUTED
* Do NOT need to check for end of chain because there is always
* at least one task on the ready chain -- the IDLE task. It can
* never block, should never attempt to obtain a semaphore or mutex,
* and thus will always be there.
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
3000b4c4: e5933000 ldr r3, [r3] <== NOT EXECUTED
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
current = (Thread_Control *)current->Object.Node.previous;
break;
}
}
3000b4c8: eafffff3 b 3000b49c <_Scheduler_simple_Ready_queue_Enqueue_first+0x10><== NOT EXECUTED
3000b528 <_Scheduler_simple_Schedule>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Schedule(void)
{
_Thread_Heir = (Thread_Control *) _Chain_First(
(Chain_Control *) _Scheduler.information
3000b528: e59f3010 ldr r3, [pc, #16] ; 3000b540 <_Scheduler_simple_Schedule+0x18><== NOT EXECUTED
); }
3000b52c: e5933000 ldr r3, [r3] <== NOT EXECUTED
#include <rtems/score/thread.h>
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Schedule(void)
{
_Thread_Heir = (Thread_Control *) _Chain_First(
3000b530: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b534: e59f3008 ldr r3, [pc, #8] ; 3000b544 <_Scheduler_simple_Schedule+0x1c><== NOT EXECUTED 3000b538: e5832008 str r2, [r3, #8] <== NOT EXECUTED
(Chain_Control *) _Scheduler.information
);
}
3000b53c: e12fff1e bx lr <== NOT EXECUTED
3000b548 <_Scheduler_simple_Unblock>:
#include <rtems/score/thread.h>
void _Scheduler_simple_Unblock(
Thread_Control *the_thread
)
{
3000b548: e92d4010 push {r4, lr}
3000b54c: e1a04000 mov r4, r0
_Scheduler_simple_Ready_queue_Enqueue(the_thread);
3000b550: ebffffde bl 3000b4d0 <_Scheduler_simple_Ready_queue_Enqueue>
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
3000b554: e59f303c ldr r3, [pc, #60] ; 3000b598 <_Scheduler_simple_Unblock+0x50>
3000b558: e5942014 ldr r2, [r4, #20]
3000b55c: e5931008 ldr r1, [r3, #8]
3000b560: e5911014 ldr r1, [r1, #20]
3000b564: e1520001 cmp r2, r1
3000b568: 28bd8010 popcs {r4, pc}
_Thread_Heir = the_thread;
3000b56c: e5834008 str r4, [r3, #8]
if ( _Thread_Executing->is_preemptible ||
3000b570: e5933004 ldr r3, [r3, #4] 3000b574: e5d33074 ldrb r3, [r3, #116] ; 0x74 3000b578: e3530000 cmp r3, #0
3000b57c: 1a000001 bne 3000b588 <_Scheduler_simple_Unblock+0x40>
3000b580: e3520000 cmp r2, #0 <== NOT EXECUTED
3000b584: 18bd8010 popne {r4, pc} <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000b588: e59f3008 ldr r3, [pc, #8] ; 3000b598 <_Scheduler_simple_Unblock+0x50>
3000b58c: e3a02001 mov r2, #1
3000b590: e5c32010 strb r2, [r3, #16]
3000b594: e8bd8010 pop {r4, pc}
3000b59c <_Scheduler_simple_Yield>:
#include <rtems/score/scheduler.h>
#include <rtems/score/thread.h>
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Yield( void )
{
3000b59c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing;
executing = _Thread_Executing;
3000b5a0: e59f5048 ldr r5, [pc, #72] ; 3000b5f0 <_Scheduler_simple_Yield+0x54><== NOT EXECUTED 3000b5a4: e5954004 ldr r4, [r5, #4] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b5a8: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000b5ac: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000b5b0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
3000b5b4: e894000c ldm r4, {r2, r3} <== NOT EXECUTED
{
/* extract */
_Chain_Extract_unprotected( &the_thread->Object.Node );
/* enqueue */
_Scheduler_simple_Ready_queue_Enqueue( the_thread );
3000b5b8: e1a00004 mov r0, r4 <== NOT EXECUTED
previous = the_node->previous; next->previous = previous;
3000b5bc: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000b5c0: e5832000 str r2, [r3] <== NOT EXECUTED 3000b5c4: ebffffc1 bl 3000b4d0 <_Scheduler_simple_Ready_queue_Enqueue><== NOT EXECUTED
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000b5c8: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000b5cc: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000b5d0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_Scheduler_simple_Ready_queue_Requeue(&_Scheduler, executing);
_ISR_Flash( level );
_Scheduler_simple_Schedule();
3000b5d4: ebffffd3 bl 3000b528 <_Scheduler_simple_Schedule> <== NOT EXECUTED
if ( !_Thread_Is_heir( executing ) )
3000b5d8: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000b5dc: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000b5e0: 13a03001 movne r3, #1 <== NOT EXECUTED 3000b5e4: 15c53010 strbne r3, [r5, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b5e8: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
}
3000b5ec: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000a5c4 <_TOD_Get_uptime_as_timespec>:
*/
void _TOD_Get_uptime_as_timespec(
struct timespec *uptime
)
{
3000a5c4: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED
3000a5c8: e1a04000 mov r4, r0 <== NOT EXECUTED
Timestamp_Control uptime_ts;
/* assume time checked for NULL by caller */
_TOD_Get_uptime( &uptime_ts );
3000a5cc: e1a0000d mov r0, sp <== NOT EXECUTED 3000a5d0: eb00113c bl 3000eac8 <_TOD_Get_uptime> <== NOT EXECUTED
_Timestamp_To_timespec( &uptime_ts, uptime );
3000a5d4: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
3000a5d8: e884000c stm r4, {r2, r3} <== NOT EXECUTED
}
3000a5dc: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED
3000a248 <_TOD_Tickle_ticks>:
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
3000a248: e92d4013 push {r0, r1, r4, lr}
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000a24c: e3a03000 mov r3, #0 3000a250: e58d3000 str r3, [sp] 3000a254: e59f3054 ldr r3, [pc, #84] ; 3000a2b0 <_TOD_Tickle_ticks+0x68> 3000a258: e3a02ffa mov r2, #1000 ; 0x3e8 3000a25c: e593300c ldr r3, [r3, #12]
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000a260: e1a0100d mov r1, sp
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000a264: e0030392 mul r3, r2, r3 3000a268: e58d3004 str r3, [sp, #4]
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000a26c: e59f3040 ldr r3, [pc, #64] ; 3000a2b4 <_TOD_Tickle_ticks+0x6c>
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000a270: e59f0040 ldr r0, [pc, #64] ; 3000a2b8 <_TOD_Tickle_ticks+0x70>
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000a274: e5932000 ldr r2, [r3] 3000a278: e2822001 add r2, r2, #1 3000a27c: e5832000 str r2, [r3]
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000a280: eb0007d6 bl 3000c1e0 <_Timespec_Add_to>
/* we do not care how much the uptime changed */
/* Update the timespec format TOD */
seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick );
3000a284: e59f0030 ldr r0, [pc, #48] ; 3000a2bc <_TOD_Tickle_ticks+0x74> 3000a288: e1a0100d mov r1, sp 3000a28c: eb0007d3 bl 3000c1e0 <_Timespec_Add_to> 3000a290: e1a04000 mov r4, r0
while ( seconds ) {
3000a294: ea000002 b 3000a2a4 <_TOD_Tickle_ticks+0x5c>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
3000a298: e59f0020 ldr r0, [pc, #32] ; 3000a2c0 <_TOD_Tickle_ticks+0x78><== NOT EXECUTED 3000a29c: eb00091d bl 3000c718 <_Watchdog_Tickle> <== NOT EXECUTED
_Watchdog_Tickle_seconds();
seconds--;
3000a2a0: e2444001 sub r4, r4, #1 <== NOT EXECUTED
_Timestamp_Add_to( &_TOD_Uptime, &tick );
/* we do not care how much the uptime changed */
/* Update the timespec format TOD */
seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick );
while ( seconds ) {
3000a2a4: e3540000 cmp r4, #0
3000a2a8: 1afffffa bne 3000a298 <_TOD_Tickle_ticks+0x50>
_Watchdog_Tickle_seconds();
seconds--;
}
}
3000a2ac: e8bd801c pop {r2, r3, r4, pc}
3000a4c0 <_TOD_Validate>:
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
3000a4c0: e59f30ac ldr r3, [pc, #172] ; 3000a574 <_TOD_Validate+0xb4>
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
3000a4c4: 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) ||
3000a4c8: e2504000 subs r4, r0, #0
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
3000a4cc: e593100c ldr r1, [r3, #12]
(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;
3000a4d0: 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) ||
3000a4d4: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
3000a4d8: e59f0098 ldr r0, [pc, #152] ; 3000a578 <_TOD_Validate+0xb8> 3000a4dc: eb00440c bl 3001b514 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
3000a4e0: e5943018 ldr r3, [r4, #24] 3000a4e4: e1530000 cmp r3, r0
3000a4e8: 2a00001d bcs 3000a564 <_TOD_Validate+0xa4>
(the_tod->ticks >= ticks_per_second) ||
3000a4ec: e5943014 ldr r3, [r4, #20] 3000a4f0: e353003b cmp r3, #59 ; 0x3b
3000a4f4: 8a00001a bhi 3000a564 <_TOD_Validate+0xa4>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
3000a4f8: e5943010 ldr r3, [r4, #16] 3000a4fc: e353003b cmp r3, #59 ; 0x3b
3000a500: 8a000017 bhi 3000a564 <_TOD_Validate+0xa4>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
3000a504: e594300c ldr r3, [r4, #12] 3000a508: e3530017 cmp r3, #23
3000a50c: 8a000014 bhi 3000a564 <_TOD_Validate+0xa4>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
3000a510: e5943004 ldr r3, [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) ||
3000a514: e3530000 cmp r3, #0
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
3000a518: 01a00003 moveq r0, r3
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) ||
3000a51c: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
3000a520: e353000c cmp r3, #12
3000a524: 8a00000e bhi 3000a564 <_TOD_Validate+0xa4>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000a528: e5942000 ldr r2, [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) ||
3000a52c: e59f1048 ldr r1, [pc, #72] ; 3000a57c <_TOD_Validate+0xbc> 3000a530: e1520001 cmp r2, r1
3000a534: 9a00000c bls 3000a56c <_TOD_Validate+0xac>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
3000a538: e5940008 ldr r0, [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) ||
3000a53c: e3500000 cmp r0, #0
3000a540: 08bd8010 popeq {r4, pc}
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
3000a544: e3120003 tst r2, #3 3000a548: e59f2030 ldr r2, [pc, #48] ; 3000a580 <_TOD_Validate+0xc0>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
3000a54c: 0283300d addeq r3, r3, #13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000a550: e7924103 ldr r4, [r2, r3, lsl #2]
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
3000a554: e1500004 cmp r0, r4
3000a558: 83a00000 movhi r0, #0
3000a55c: 93a00001 movls r0, #1
3000a560: 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;
3000a564: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a568: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a56c: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
3000a570: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b3c4 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
3000b3c4: e92d40f0 push {r4, r5, r6, r7, lr}
3000b3c8: e1a04000 mov r4, r0
3000b3cc: e1a05001 mov r5, r1
3000b3d0: e20260ff and r6, r2, #255 ; 0xff
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
3000b3d4: e5907010 ldr r7, [r0, #16]
/* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread );
3000b3d8: eb000311 bl 3000c024 <_Thread_Set_transient>
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
3000b3dc: e5943014 ldr r3, [r4, #20] 3000b3e0: e1530005 cmp r3, r5
_Thread_Set_priority( the_thread, new_priority );
3000b3e4: 11a00004 movne r0, r4 3000b3e8: 11a01005 movne r1, r5 3000b3ec: 1b0002f4 blne 3000bfc4 <_Thread_Set_priority>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b3f0: e10f5000 mrs r5, CPSR 3000b3f4: e3853080 orr r3, r5, #128 ; 0x80 3000b3f8: e129f003 msr CPSR_fc, r3
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
3000b3fc: e5942010 ldr r2, [r4, #16] 3000b400: e2077004 and r7, r7, #4
if ( state != STATES_TRANSIENT ) {
3000b404: e3520004 cmp r2, #4
3000b408: 0a00000b beq 3000b43c <_Thread_Change_priority+0x78>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
3000b40c: e3570000 cmp r7, #0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
3000b410: 03c23004 biceq r3, r2, #4 <== NOT EXECUTED
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
3000b414: 05843010 streq r3, [r4, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b418: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
3000b41c: e59f3090 ldr r3, [pc, #144] ; 3000b4b4 <_Thread_Change_priority+0xf0><== NOT EXECUTED 3000b420: e0023003 and r3, r2, r3 <== NOT EXECUTED
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
3000b424: e3530000 cmp r3, #0 <== NOT EXECUTED
3000b428: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
3000b42c: e5940044 ldr r0, [r4, #68] ; 0x44 <== NOT EXECUTED 3000b430: e1a01004 mov r1, r4 <== NOT EXECUTED
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
3000b434: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
3000b438: ea0002bc b 3000bf30 <_Thread_queue_Requeue> <== NOT EXECUTED
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
3000b43c: e3570000 cmp r7, #0
3000b440: 1a00000a bne 3000b470 <_Thread_Change_priority+0xac>
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
if ( prepend_it )
3000b444: e3560000 cmp r6, #0
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
3000b448: e5847010 str r7, [r4, #16] 3000b44c: e59f3064 ldr r3, [pc, #100] ; 3000b4b8 <_Thread_Change_priority+0xf4>
if ( prepend_it )
3000b450: 0a000003 beq 3000b464 <_Thread_Change_priority+0xa0>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
3000b454: e1a00004 mov r0, r4 3000b458: e1a0e00f mov lr, pc 3000b45c: e593f028 ldr pc, [r3, #40] ; 0x28 3000b460: ea000002 b 3000b470 <_Thread_Change_priority+0xac>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
3000b464: e1a00004 mov r0, r4 3000b468: e1a0e00f mov lr, pc 3000b46c: e593f024 ldr pc, [r3, #36] ; 0x24
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000b470: e10f3000 mrs r3, CPSR 3000b474: e129f005 msr CPSR_fc, r5 3000b478: e129f003 msr CPSR_fc, r3
* This kernel routine implements the scheduling decision logic for
* the scheduler. It does NOT dispatch.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )
{
_Scheduler.Operations.schedule();
3000b47c: e59f3034 ldr r3, [pc, #52] ; 3000b4b8 <_Thread_Change_priority+0xf4> 3000b480: e1a0e00f mov lr, pc 3000b484: e593f008 ldr pc, [r3, #8]
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
3000b488: e59f302c ldr r3, [pc, #44] ; 3000b4bc <_Thread_Change_priority+0xf8> 3000b48c: e5932004 ldr r2, [r3, #4]
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule();
if ( !_Thread_Is_executing_also_the_heir() &&
3000b490: e5931008 ldr r1, [r3, #8] 3000b494: e1520001 cmp r2, r1
3000b498: 0a000003 beq 3000b4ac <_Thread_Change_priority+0xe8>
3000b49c: e5d22074 ldrb r2, [r2, #116] ; 0x74 3000b4a0: e3520000 cmp r2, #0
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
3000b4a4: 13a02001 movne r2, #1 3000b4a8: 15c32010 strbne r2, [r3, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b4ac: e129f005 msr CPSR_fc, r5
3000b4b0: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000b688 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000b688: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000b68c: e1a0100d mov r1, sp <== NOT EXECUTED 3000b690: eb000058 bl 3000b7f8 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000b694: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000b698: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b69c: 1a000005 bne 3000b6b8 <_Thread_Delay_ended+0x30> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
3000b6a0: e59f1014 ldr r1, [pc, #20] ; 3000b6bc <_Thread_Delay_ended+0x34><== NOT EXECUTED 3000b6a4: ebffff85 bl 3000b4c0 <_Thread_Clear_state> <== NOT EXECUTED 3000b6a8: e59f3010 ldr r3, [pc, #16] ; 3000b6c0 <_Thread_Delay_ended+0x38><== NOT EXECUTED 3000b6ac: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b6b0: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000b6b4: e5832000 str r2, [r3] <== NOT EXECUTED
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
3000b6b8: e8bd8008 pop {r3, pc} <== NOT EXECUTED
3000b7f8 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
3000b7f8: e1a02001 mov r2, r1
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
3000b7fc: e2501000 subs r1, r0, #0
3000b800: 1a000007 bne 3000b824 <_Thread_Get+0x2c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b804: e59f3074 ldr r3, [pc, #116] ; 3000b880 <_Thread_Get+0x88> 3000b808: e5930000 ldr r0, [r3] 3000b80c: e2800001 add r0, r0, #1 3000b810: e5830000 str r0, [r3]
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
tp = _Thread_Executing;
3000b814: e59f3068 ldr r3, [pc, #104] ; 3000b884 <_Thread_Get+0x8c>
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
3000b818: e5821000 str r1, [r2]
tp = _Thread_Executing;
3000b81c: e5930004 ldr r0, [r3, #4]
goto done;
3000b820: e12fff1e bx lr
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
3000b824: e1a00c21 lsr r0, r1, #24 3000b828: e2000007 and r0, r0, #7
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000b82c: e2403001 sub r3, r0, #1 3000b830: e3530002 cmp r3, #2
3000b834: 9a00000d bls 3000b870 <_Thread_Get+0x78>
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
3000b838: e3a03001 mov r3, #1 3000b83c: e5823000 str r3, [r2]
{
uint32_t the_api;
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
3000b840: e3a00000 mov r0, #0
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
3000b844: e12fff1e bx lr
}
api_information = _Objects_Information_table[ the_api ];
3000b848: e59fc038 ldr ip, [pc, #56] ; 3000b888 <_Thread_Get+0x90> 3000b84c: e79c0100 ldr r0, [ip, r0, lsl #2]
* There is no way for this to happen if POSIX is enabled. But there
* is actually a test case in sp43 for this which trips it whether or
* not POSIX is enabled. So in the interest of safety, this is left
* on in all configurations.
*/
if ( !api_information ) {
3000b850: e3500000 cmp r0, #0
3000b854: 0a000002 beq 3000b864 <_Thread_Get+0x6c>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
3000b858: e5900004 ldr r0, [r0, #4]
if ( !information ) {
3000b85c: e3500000 cmp r0, #0
3000b860: 1a000001 bne 3000b86c <_Thread_Get+0x74>
*location = OBJECTS_ERROR;
3000b864: e5823000 str r3, [r2] <== NOT EXECUTED
goto done;
3000b868: e12fff1e bx lr <== NOT EXECUTED
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
3000b86c: eafffcbe b 3000ab6c <_Objects_Get>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000b870: e1a03da1 lsr r3, r1, #27
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
3000b874: e3530001 cmp r3, #1
3000b878: 0afffff2 beq 3000b848 <_Thread_Get+0x50>
3000b87c: eaffffed b 3000b838 <_Thread_Get+0x40> <== NOT EXECUTED
3000c128 <_Thread_Start>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
3000c128: e590c010 ldr ip, [r0, #16]
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000c12c: e92d4010 push {r4, lr}
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000c130: e21cc001 ands ip, ip, #1
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000c134: e1a04000 mov r4, r0
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000c138: 0a00000b beq 3000c16c <_Thread_Start+0x44>
the_thread->Start.entry_point = (Thread_Entry) entry_point;
the_thread->Start.prototype = the_prototype;
the_thread->Start.pointer_argument = pointer_argument;
3000c13c: e5803098 str r3, [r0, #152] ; 0x98
the_thread->Start.numeric_argument = numeric_argument;
3000c140: e59d3008 ldr r3, [sp, #8]
Thread_Entry_numeric_type numeric_argument
)
{
if ( _States_Is_dormant( the_thread->current_state ) ) {
the_thread->Start.entry_point = (Thread_Entry) entry_point;
3000c144: e5802090 str r2, [r0, #144] ; 0x90
the_thread->Start.prototype = the_prototype;
3000c148: e5801094 str r1, [r0, #148] ; 0x94
the_thread->Start.pointer_argument = pointer_argument;
the_thread->Start.numeric_argument = numeric_argument;
3000c14c: e580309c str r3, [r0, #156] ; 0x9c
_Thread_Load_environment( the_thread );
3000c150: eb000a55 bl 3000eaac <_Thread_Load_environment>
_Thread_Ready( the_thread );
3000c154: e1a00004 mov r0, r4 3000c158: eb000aeb bl 3000ed0c <_Thread_Ready>
_User_extensions_Thread_start( the_thread );
3000c15c: e1a00004 mov r0, r4 3000c160: eb0000ca bl 3000c490 <_User_extensions_Thread_start>
return true;
3000c164: e3a00001 mov r0, #1
3000c168: e8bd8010 pop {r4, pc}
}
return false;
3000c16c: e1a0000c mov r0, ip <== NOT EXECUTED
}
3000c170: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c174 <_Thread_Tickle_timeslice>:
void _Thread_Tickle_timeslice( void )
{
Thread_Control *executing;
executing = _Thread_Executing;
3000c174: e59f3058 ldr r3, [pc, #88] ; 3000c1d4 <_Thread_Tickle_timeslice+0x60>
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
3000c178: e92d4010 push {r4, lr}
Thread_Control *executing;
executing = _Thread_Executing;
3000c17c: e5934004 ldr r4, [r3, #4]
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
3000c180: e5d43074 ldrb r3, [r4, #116] ; 0x74
3000c184: e3530000 cmp r3, #0
3000c188: 08bd8010 popeq {r4, pc}
return;
if ( !_States_Is_ready( executing->current_state ) )
3000c18c: e5943010 ldr r3, [r4, #16]
3000c190: e3530000 cmp r3, #0
3000c194: 18bd8010 popne {r4, pc}
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
3000c198: e594307c ldr r3, [r4, #124] ; 0x7c
3000c19c: e3530001 cmp r3, #1
3000c1a0: 18bd8010 popne {r4, pc}
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
3000c1a4: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000c1a8: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000c1ac: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c1b0: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000c1b4: c8bd8010 popgt {r4, pc} <== NOT EXECUTED
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
3000c1b8: e59f3018 ldr r3, [pc, #24] ; 3000c1d8 <_Thread_Tickle_timeslice+0x64><== NOT EXECUTED 3000c1bc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c1c0: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield( );
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000c1c4: e59f3010 ldr r3, [pc, #16] ; 3000c1dc <_Thread_Tickle_timeslice+0x68><== NOT EXECUTED
3000c1c8: e5933000 ldr r3, [r3] <== NOT EXECUTED
3000c1cc: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000c1d0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b378 <_Thread_blocking_operation_Cancel>:
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000b378: e3a03000 mov r3, #0 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000b37c: e92d4010 push {r4, lr} <== NOT EXECUTED
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000b380: e5813044 str r3, [r1, #68] ; 0x44 <== NOT EXECUTED
/*
* If the sync state is timed out, this is very likely not needed.
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
3000b384: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000b388: e1a04001 mov r4, r1 <== NOT EXECUTED
/*
* If the sync state is timed out, this is very likely not needed.
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
3000b38c: e3530002 cmp r3, #2 <== NOT EXECUTED 3000b390: 1a000005 bne 3000b3ac <_Thread_blocking_operation_Cancel+0x34><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000b394: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000b398: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000b39c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000b3a0: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3000b3a4: eb0004b2 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED 3000b3a8: ea000000 b 3000b3b0 <_Thread_blocking_operation_Cancel+0x38><== NOT EXECUTED 3000b3ac: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000b3b0: e59f1008 ldr r1, [pc, #8] ; 3000b3c0 <_Thread_blocking_operation_Cancel+0x48><== NOT EXECUTED 3000b3b4: e1a00004 mov r0, r4 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000b3b8: e8bd4010 pop {r4, lr} <== NOT EXECUTED
3000b3bc: ea00003f b 3000b4c0 <_Thread_Clear_state> <== NOT EXECUTED
3000eaf8 <_Thread_queue_Dequeue_fifo>:
*/
Thread_Control *_Thread_queue_Dequeue_fifo(
Thread_queue_Control *the_thread_queue
)
{
3000eaf8: e92d4030 push {r4, r5, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000eafc: e10f3000 mrs r3, CPSR 3000eb00: e3832080 orr r2, r3, #128 ; 0x80 3000eb04: e129f002 msr CPSR_fc, r2
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
3000eb08: e1a02000 mov r2, r0 3000eb0c: e4925004 ldr r5, [r2], #4
{
ISR_Level level;
Thread_Control *the_thread;
_ISR_Disable( level );
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
3000eb10: e1550002 cmp r5, r2
3000eb14: 0a000013 beq 3000eb68 <_Thread_queue_Dequeue_fifo+0x70>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
3000eb18: e5952000 ldr r2, [r5]
the_thread = (Thread_Control *)
3000eb1c: e1a04005 mov r4, r5
head->next = new_first;
3000eb20: e5802000 str r2, [r0]
new_first->previous = head;
3000eb24: e5820004 str r0, [r2, #4]
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
3000eb28: e3a02000 mov r2, #0 3000eb2c: e5852044 str r2, [r5, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000eb30: e5952050 ldr r2, [r5, #80] ; 0x50 3000eb34: e3520002 cmp r2, #2
3000eb38: 0a000001 beq 3000eb44 <_Thread_queue_Dequeue_fifo+0x4c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000eb3c: e129f003 msr CPSR_fc, r3 3000eb40: ea000004 b 3000eb58 <_Thread_queue_Dequeue_fifo+0x60>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000eb44: e3a02003 mov r2, #3 <== NOT EXECUTED 3000eb48: e5852050 str r2, [r5, #80] ; 0x50 <== NOT EXECUTED 3000eb4c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000eb50: e2850048 add r0, r5, #72 ; 0x48 <== NOT EXECUTED 3000eb54: ebfff6c6 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000eb58: e1a00005 mov r0, r5 3000eb5c: e59f1014 ldr r1, [pc, #20] ; 3000eb78 <_Thread_queue_Dequeue_fifo+0x80> 3000eb60: ebfff256 bl 3000b4c0 <_Thread_Clear_state> 3000eb64: ea000001 b 3000eb70 <_Thread_queue_Dequeue_fifo+0x78> 3000eb68: e129f003 msr CPSR_fc, r3
return the_thread;
}
_ISR_Enable( level );
return NULL;
3000eb6c: e3a04000 mov r4, #0
}
3000eb70: e1a00004 mov r0, r4
3000eb74: e8bd8030 pop {r4, r5, pc}
3000bb34 <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
3000bb34: e92d4030 push {r4, r5, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bb38: e10f1000 mrs r1, CPSR 3000bb3c: e3813080 orr r3, r1, #128 ; 0x80 3000bb40: e129f003 msr CPSR_fc, r3
Chain_Node *new_second_node;
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
3000bb44: e3a02000 mov r2, #0
for( index=0 ;
3000bb48: e1a03002 mov r3, r2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000bb4c: e3a0c00c mov ip, #12 3000bb50: e004039c mul r4, ip, r3
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000bb54: e7905002 ldr r5, [r0, r2] 3000bb58: e2844004 add r4, r4, #4 3000bb5c: e0804004 add r4, r0, r4
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
3000bb60: e1550004 cmp r5, r4
3000bb64: 0a000009 beq 3000bb90 <_Thread_queue_Dequeue_priority+0x5c>
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
3000bb68: e3a03000 mov r3, #0 3000bb6c: e5853044 str r3, [r5, #68] ; 0x44
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000bb70: e5953038 ldr r3, [r5, #56] ; 0x38 3000bb74: e285c03c add ip, r5, #60 ; 0x3c
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
next_node = the_thread->Object.Node.next;
previous_node = the_thread->Object.Node.previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000bb78: e153000c cmp r3, ip
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
the_thread = (Thread_Control *) _Chain_First(
3000bb7c: e1a04005 mov r4, r5
dequeue:
the_thread->Wait.queue = NULL;
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
next_node = the_thread->Object.Node.next;
3000bb80: e5952000 ldr r2, [r5]
previous_node = the_thread->Object.Node.previous;
3000bb84: e5950004 ldr r0, [r5, #4]
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000bb88: 1a000007 bne 3000bbac <_Thread_queue_Dequeue_priority+0x78>
3000bb8c: ea000017 b 3000bbf0 <_Thread_queue_Dequeue_priority+0xbc>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000bb90: e2833001 add r3, r3, #1
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000bb94: e3530004 cmp r3, #4
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000bb98: e282200c add r2, r2, #12
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000bb9c: 1affffeb bne 3000bb50 <_Thread_queue_Dequeue_priority+0x1c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bba0: e129f001 msr CPSR_fc, r1
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
return NULL;
3000bba4: e3a04000 mov r4, #0 3000bba8: ea00001f b 3000bc2c <_Thread_queue_Dequeue_priority+0xf8>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000bbac: e595c040 ldr ip, [r5, #64] ; 0x40 <== NOT EXECUTED
next_node = the_thread->Object.Node.next;
previous_node = the_thread->Object.Node.previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
3000bbb0: e593e000 ldr lr, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000bbb4: e5823004 str r3, [r2, #4] <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
3000bbb8: e5803000 str r3, [r0] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000bbbc: e5830004 str r0, [r3, #4] <== NOT EXECUTED
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
next_node->previous = new_first_node;
new_first_node->next = next_node;
3000bbc0: e5832000 str r2, [r3] <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000bbc4: e5950038 ldr r0, [r5, #56] ; 0x38 <== NOT EXECUTED 3000bbc8: e5952040 ldr r2, [r5, #64] ; 0x40 <== NOT EXECUTED 3000bbcc: e1500002 cmp r0, r2 <== NOT EXECUTED 3000bbd0: 0a000008 beq 3000bbf8 <_Thread_queue_Dequeue_priority+0xc4><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000bbd4: e2832038 add r2, r3, #56 ; 0x38 <== NOT EXECUTED
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
head->next = new_second_node;
3000bbd8: e583e038 str lr, [r3, #56] ; 0x38 <== NOT EXECUTED
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
3000bbdc: e58e2004 str r2, [lr, #4] <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
3000bbe0: e583c040 str ip, [r3, #64] ; 0x40 <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
3000bbe4: e283303c add r3, r3, #60 ; 0x3c <== NOT EXECUTED
new_second_node->previous = head;
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
3000bbe8: e58c3000 str r3, [ip] <== NOT EXECUTED 3000bbec: ea000001 b 3000bbf8 <_Thread_queue_Dequeue_priority+0xc4> <== NOT EXECUTED
}
} else {
previous_node->next = next_node;
3000bbf0: e5802000 str r2, [r0]
next_node->previous = previous_node;
3000bbf4: e5820004 str r0, [r2, #4]
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000bbf8: e5953050 ldr r3, [r5, #80] ; 0x50 3000bbfc: e3530002 cmp r3, #2
3000bc00: 0a000001 beq 3000bc0c <_Thread_queue_Dequeue_priority+0xd8>
3000bc04: e129f001 msr CPSR_fc, r1 3000bc08: ea000004 b 3000bc20 <_Thread_queue_Dequeue_priority+0xec>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000bc0c: e3a03003 mov r3, #3 <== NOT EXECUTED 3000bc10: e5853050 str r3, [r5, #80] ; 0x50 <== NOT EXECUTED 3000bc14: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000bc18: e2850048 add r0, r5, #72 ; 0x48 <== NOT EXECUTED 3000bc1c: eb000294 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000bc20: e1a00005 mov r0, r5 3000bc24: e59f1008 ldr r1, [pc, #8] ; 3000bc34 <_Thread_queue_Dequeue_priority+0x100> 3000bc28: ebfffe24 bl 3000b4c0 <_Thread_Clear_state>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000bc2c: e1a00004 mov r0, r4
3000bc30: e8bd8030 pop {r4, r5, pc}
3000eb7c <_Thread_queue_Enqueue_fifo>:
Thread_blocking_operation_States _Thread_queue_Enqueue_fifo (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
3000eb7c: e92d4010 push {r4, lr}
3000eb80: e1a03000 mov r3, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000eb84: e10fc000 mrs ip, CPSR 3000eb88: e38c0080 orr r0, ip, #128 ; 0x80 3000eb8c: e129f000 msr CPSR_fc, r0
Thread_blocking_operation_States sync_state;
ISR_Level level;
_ISR_Disable( level );
sync_state = the_thread_queue->sync_state;
3000eb90: e5930030 ldr r0, [r3, #48] ; 0x30
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000eb94: e3a04000 mov r4, #0
if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
3000eb98: e3500001 cmp r0, #1
ISR_Level level;
_ISR_Disable( level );
sync_state = the_thread_queue->sync_state;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000eb9c: e5834030 str r4, [r3, #48] ; 0x30
if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
3000eba0: 1a000008 bne 3000ebc8 <_Thread_queue_Enqueue_fifo+0x4c>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3000eba4: e5932008 ldr r2, [r3, #8]
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
3000eba8: e2834004 add r4, r3, #4
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3000ebac: e5831008 str r1, [r3, #8]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3000ebb0: e5814000 str r4, [r1]
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
3000ebb4: e5812004 str r2, [r1, #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;
3000ebb8: e5821000 str r1, [r2]
_Chain_Append_unprotected(
&the_thread_queue->Queues.Fifo,
&the_thread->Object.Node
);
the_thread->Wait.queue = the_thread_queue;
3000ebbc: e5813044 str r3, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ebc0: e129f00c msr CPSR_fc, ip
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000ebc4: e8bd8010 pop {r4, pc}
* For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level;
3000ebc8: e582c000 str ip, [r2] <== NOT EXECUTED
return sync_state; }
3000ebcc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000bcd8 <_Thread_queue_Enqueue_priority>:
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000bcd8: e281303c add r3, r1, #60 ; 0x3c
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
3000bcdc: e591c014 ldr ip, [r1, #20]
head->next = tail;
3000bce0: e5813038 str r3, [r1, #56] ; 0x38
head->previous = NULL;
3000bce4: e3a03000 mov r3, #0 3000bce8: e581303c str r3, [r1, #60] ; 0x3c
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
3000bcec: e31c0020 tst ip, #32
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3000bcf0: e2813038 add r3, r1, #56 ; 0x38
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
3000bcf4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
3000bcf8: e5813040 str r3, [r1, #64] ; 0x40
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
3000bcfc: e5907038 ldr r7, [r0, #56] ; 0x38
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
3000bd00: e1a0332c lsr r3, ip, #6
if ( _Thread_queue_Is_reverse_search( priority ) )
3000bd04: 1a000026 bne 3000bda4 <_Thread_queue_Enqueue_priority+0xcc>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
3000bd08: e3a0600c mov r6, #12 3000bd0c: e0030396 mul r3, r6, r3 3000bd10: e0808003 add r8, r0, r3
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
3000bd14: e2833004 add r3, r3, #4 3000bd18: e0806003 add r6, r0, r3
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bd1c: e10f4000 mrs r4, CPSR 3000bd20: e3843080 orr r3, r4, #128 ; 0x80 3000bd24: e129f003 msr CPSR_fc, r3
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
3000bd28: e3e05000 mvn r5, #0
_ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header );
3000bd2c: e5983000 ldr r3, [r8]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
3000bd30: ea00000b b 3000bd64 <_Thread_queue_Enqueue_priority+0x8c>
search_priority = search_thread->current_priority;
3000bd34: e5935014 ldr r5, [r3, #20]
if ( priority <= search_priority )
3000bd38: e15c0005 cmp ip, r5
3000bd3c: 9a00000a bls 3000bd6c <_Thread_queue_Enqueue_priority+0x94>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000bd40: e10fa000 mrs sl, CPSR 3000bd44: e129f004 msr CPSR_fc, r4 3000bd48: e129f00a msr CPSR_fc, sl
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
3000bd4c: e593a010 ldr sl, [r3, #16]
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
3000bd50: e117000a tst r7, sl
3000bd54: 1a000001 bne 3000bd60 <_Thread_queue_Enqueue_priority+0x88>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bd58: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000bd5c: eaffffee b 3000bd1c <_Thread_queue_Enqueue_priority+0x44> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
3000bd60: e5933000 ldr r3, [r3]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
3000bd64: e1530006 cmp r3, r6
3000bd68: 1afffff1 bne 3000bd34 <_Thread_queue_Enqueue_priority+0x5c>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
3000bd6c: e5906030 ldr r6, [r0, #48] ; 0x30 3000bd70: e3560001 cmp r6, #1
3000bd74: 1a000039 bne 3000be60 <_Thread_queue_Enqueue_priority+0x188>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000bd78: e3a02000 mov r2, #0
if ( priority == search_priority )
3000bd7c: e15c0005 cmp ip, r5
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000bd80: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
3000bd84: 0a00002b beq 3000be38 <_Thread_queue_Enqueue_priority+0x160>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
3000bd88: e5932004 ldr r2, [r3, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000bd8c: e5813000 str r3, [r1]
the_node->previous = previous_node;
3000bd90: e5812004 str r2, [r1, #4]
previous_node->next = the_node;
3000bd94: e5821000 str r1, [r2]
search_node->previous = the_node;
3000bd98: e5831004 str r1, [r3, #4]
the_thread->Wait.queue = the_thread_queue;
3000bd9c: e5810044 str r0, [r1, #68] ; 0x44
_ISR_Enable( level );
3000bda0: ea00002b b 3000be54 <_Thread_queue_Enqueue_priority+0x17c>
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
3000bda4: e3a0600c mov r6, #12 3000bda8: e0260693 mla r6, r3, r6, r0
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
3000bdac: e59f80b8 ldr r8, [pc, #184] ; 3000be6c <_Thread_queue_Enqueue_priority+0x194> 3000bdb0: e5d85000 ldrb r5, [r8] 3000bdb4: e2855001 add r5, r5, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bdb8: e10f4000 mrs r4, CPSR 3000bdbc: e3843080 orr r3, r4, #128 ; 0x80 3000bdc0: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
3000bdc4: e5963008 ldr r3, [r6, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
3000bdc8: ea00000b b 3000bdfc <_Thread_queue_Enqueue_priority+0x124>
search_priority = search_thread->current_priority;
3000bdcc: e5935014 ldr r5, [r3, #20]
if ( priority >= search_priority )
3000bdd0: e15c0005 cmp ip, r5
3000bdd4: 2a00000a bcs 3000be04 <_Thread_queue_Enqueue_priority+0x12c>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000bdd8: e10fa000 mrs sl, CPSR <== NOT EXECUTED 3000bddc: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000bde0: e129f00a msr CPSR_fc, sl <== NOT EXECUTED 3000bde4: e593a010 ldr sl, [r3, #16] <== NOT EXECUTED
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) ) {
3000bde8: e117000a tst r7, sl <== NOT EXECUTED 3000bdec: 1a000001 bne 3000bdf8 <_Thread_queue_Enqueue_priority+0x120><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bdf0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000bdf4: eaffffed b 3000bdb0 <_Thread_queue_Enqueue_priority+0xd8> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
3000bdf8: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
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 ) ) {
3000bdfc: e1530006 cmp r3, r6
3000be00: 1afffff1 bne 3000bdcc <_Thread_queue_Enqueue_priority+0xf4>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
3000be04: e5906030 ldr r6, [r0, #48] ; 0x30 3000be08: e3560001 cmp r6, #1
3000be0c: 1a000013 bne 3000be60 <_Thread_queue_Enqueue_priority+0x188>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000be10: e3a02000 mov r2, #0
if ( priority == search_priority )
3000be14: e15c0005 cmp ip, r5
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000be18: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
3000be1c: 0a000005 beq 3000be38 <_Thread_queue_Enqueue_priority+0x160>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
3000be20: e5932000 ldr r2, [r3]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
3000be24: e881000c stm r1, {r2, r3}
search_node->next = the_node; next_node->previous = the_node;
3000be28: e5821004 str r1, [r2, #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;
3000be2c: e5831000 str r1, [r3]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
3000be30: e5810044 str r0, [r1, #68] ; 0x44
_ISR_Enable( level );
3000be34: ea000006 b 3000be54 <_Thread_queue_Enqueue_priority+0x17c>
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;
3000be38: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED
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 );
3000be3c: e283c03c add ip, r3, #60 ; 0x3c <== NOT EXECUTED
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000be40: e581c000 str ip, [r1] <== NOT EXECUTED
the_node->previous = previous_node;
3000be44: e5812004 str r2, [r1, #4] <== NOT EXECUTED
previous_node->next = the_node;
3000be48: e5821000 str r1, [r2] <== NOT EXECUTED
search_node->previous = the_node;
3000be4c: e5831040 str r1, [r3, #64] ; 0x40 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
3000be50: e5810044 str r0, [r1, #68] ; 0x44 <== NOT EXECUTED
3000be54: e129f004 msr CPSR_fc, r4
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000be58: e3a00001 mov r0, #1
3000be5c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
* For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level;
3000be60: e5824000 str r4, [r2] <== NOT EXECUTED
return the_thread_queue->sync_state;
3000be64: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
}
3000be68: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30010174 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
30010174: e92d4010 push {r4, lr}
30010178: e1a04001 mov r4, r1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001017c: e10f3000 mrs r3, CPSR 30010180: e3832080 orr r2, r3, #128 ; 0x80 30010184: e129f002 msr CPSR_fc, r2 30010188: e59f2060 ldr r2, [pc, #96] ; 300101f0 <_Thread_queue_Extract_fifo+0x7c> 3001018c: e5911010 ldr r1, [r1, #16] 30010190: e0012002 and r2, r1, r2
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
30010194: e3520000 cmp r2, #0
30010198: 1a000001 bne 300101a4 <_Thread_queue_Extract_fifo+0x30>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001019c: e129f003 msr CPSR_fc, r3
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
300101a0: e8bd8010 pop {r4, pc}
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
300101a4: e8940006 ldm r4, {r1, r2}
next->previous = previous;
300101a8: e5812004 str r2, [r1, #4]
previous->next = next;
300101ac: e5821000 str r1, [r2]
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
300101b0: e3a02000 mov r2, #0 300101b4: e5842044 str r2, [r4, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
300101b8: e5942050 ldr r2, [r4, #80] ; 0x50 300101bc: e3520002 cmp r2, #2
300101c0: 0a000001 beq 300101cc <_Thread_queue_Extract_fifo+0x58>
300101c4: e129f003 msr CPSR_fc, r3 300101c8: ea000004 b 300101e0 <_Thread_queue_Extract_fifo+0x6c>
300101cc: e3a02003 mov r2, #3 <== NOT EXECUTED 300101d0: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 300101d4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
300101d8: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 300101dc: ebfff124 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
300101e0: e59f100c ldr r1, [pc, #12] ; 300101f4 <_Thread_queue_Extract_fifo+0x80> 300101e4: e1a00004 mov r0, r4
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
300101e8: e8bd4010 pop {r4, lr}
300101ec: eaffecb3 b 3000b4c0 <_Thread_Clear_state>
3000ebe8 <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread,
bool requeuing
)
{
3000ebe8: e92d4070 push {r4, r5, r6, lr}
3000ebec: e20220ff and r2, r2, #255 ; 0xff
3000ebf0: e1a04001 mov r4, r1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ebf4: e10f1000 mrs r1, CPSR 3000ebf8: e3813080 orr r3, r1, #128 ; 0x80 3000ebfc: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
3000ec00: e59f30b0 ldr r3, [pc, #176] ; 3000ecb8 <_Thread_queue_Extract_priority_helper+0xd0> 3000ec04: e5940010 ldr r0, [r4, #16] 3000ec08: e0003003 and r3, r0, r3
Chain_Node *new_second_node;
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
3000ec0c: e3530000 cmp r3, #0
3000ec10: 1a000000 bne 3000ec18 <_Thread_queue_Extract_priority_helper+0x30>
_ISR_Enable( level );
3000ec14: ea000017 b 3000ec78 <_Thread_queue_Extract_priority_helper+0x90>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000ec18: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
3000ec1c: e8941001 ldm r4, {r0, ip} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000ec20: e284503c add r5, r4, #60 ; 0x3c <== NOT EXECUTED
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000ec24: e1530005 cmp r3, r5 <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
3000ec28: 058c0000 streq r0, [ip] <== NOT EXECUTED
next_node->previous = previous_node;
3000ec2c: 0580c004 streq ip, [r0, #4] <== NOT EXECUTED
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000ec30: 0a00000e beq 3000ec70 <_Thread_queue_Extract_priority_helper+0x88><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000ec34: e5945040 ldr r5, [r4, #64] ; 0x40 <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
3000ec38: e5936000 ldr r6, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000ec3c: e5803004 str r3, [r0, #4] <== NOT EXECUTED
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
3000ec40: e58c3000 str r3, [ip] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000ec44: e8831001 stm r3, {r0, ip} <== NOT EXECUTED
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000ec48: e594c038 ldr ip, [r4, #56] ; 0x38 <== NOT EXECUTED 3000ec4c: e5940040 ldr r0, [r4, #64] ; 0x40 <== NOT EXECUTED 3000ec50: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000ec54: 0a000005 beq 3000ec70 <_Thread_queue_Extract_priority_helper+0x88><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000ec58: e2830038 add r0, r3, #56 ; 0x38 <== NOT EXECUTED
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
head->next = new_second_node;
3000ec5c: e5836038 str r6, [r3, #56] ; 0x38 <== NOT EXECUTED
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
3000ec60: e5860004 str r0, [r6, #4] <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
3000ec64: e5835040 str r5, [r3, #64] ; 0x40 <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
3000ec68: e283303c add r3, r3, #60 ; 0x3c <== NOT EXECUTED
new_second_node->previous = head;
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
3000ec6c: e5853000 str r3, [r5] <== NOT EXECUTED
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
3000ec70: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ec74: 0a000001 beq 3000ec80 <_Thread_queue_Extract_priority_helper+0x98><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ec78: e129f001 msr CPSR_fc, r1
3000ec7c: e8bd8070 pop {r4, r5, r6, pc}
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000ec80: e5943050 ldr r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000ec84: e3530002 cmp r3, #2 <== NOT EXECUTED 3000ec88: 0a000001 beq 3000ec94 <_Thread_queue_Extract_priority_helper+0xac><== NOT EXECUTED 3000ec8c: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 3000ec90: ea000004 b 3000eca8 <_Thread_queue_Extract_priority_helper+0xc0><== NOT EXECUTED 3000ec94: e3a03003 mov r3, #3 <== NOT EXECUTED 3000ec98: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000ec9c: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000eca0: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000eca4: ebfff672 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED 3000eca8: e59f100c ldr r1, [pc, #12] ; 3000ecbc <_Thread_queue_Extract_priority_helper+0xd4><== NOT EXECUTED 3000ecac: e1a00004 mov r0, r4 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000ecb0: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
3000ecb4: eafff201 b 3000b4c0 <_Thread_Clear_state> <== NOT EXECUTED
3001ed64 <_Thread_queue_First_priority>:
*/
Thread_Control *_Thread_queue_First_priority (
Thread_queue_Control *the_thread_queue
)
{
3001ed64: e92d4010 push {r4, lr} <== NOT EXECUTED
3001ed68: e3a02000 mov r2, #0 <== NOT EXECUTED
uint32_t index;
for( index=0 ;
3001ed6c: e1a03002 mov r3, r2 <== NOT EXECUTED 3001ed70: e3a0c00c mov ip, #12 <== NOT EXECUTED 3001ed74: e004039c mul r4, ip, r3 <== NOT EXECUTED
return (Thread_Control *) _Chain_First(
&the_thread_queue->Queues.Priority[ index ]
);
}
return NULL;
}
3001ed78: e7901002 ldr r1, [r0, r2] <== NOT EXECUTED 3001ed7c: e2844004 add r4, r4, #4 <== NOT EXECUTED 3001ed80: e0804004 add r4, r0, r4 <== NOT EXECUTED
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
3001ed84: e1510004 cmp r1, r4 <== NOT EXECUTED 3001ed88: 0a000001 beq 3001ed94 <_Thread_queue_First_priority+0x30> <== NOT EXECUTED
return (Thread_Control *) _Chain_First(
3001ed8c: e1a00001 mov r0, r1 <== NOT EXECUTED
3001ed90: e8bd8010 pop {r4, pc} <== NOT EXECUTED
{
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3001ed94: e2833001 add r3, r3, #1 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3001ed98: e3530004 cmp r3, #4 <== NOT EXECUTED
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3001ed9c: e282200c add r2, r2, #12 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3001eda0: 1afffff3 bne 3001ed74 <_Thread_queue_First_priority+0x10> <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
return (Thread_Control *) _Chain_First(
&the_thread_queue->Queues.Priority[ index ]
);
}
return NULL;
3001eda4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3001eda8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ecc0 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
3000ecc0: e1a01000 mov r1, r0 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
3000ecc4: e5900044 ldr r0, [r0, #68] ; 0x44 <== NOT EXECUTED
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
3000ecc8: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000eccc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ecd0: 0a000009 beq 3000ecfc <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000ecd4: e59f202c ldr r2, [pc, #44] ; 3000ed08 <_Thread_queue_Process_timeout+0x48><== NOT EXECUTED 3000ecd8: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 3000ecdc: e1510002 cmp r1, r2 <== NOT EXECUTED 3000ece0: 1a000005 bne 3000ecfc <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
3000ece4: e3530003 cmp r3, #3 <== NOT EXECUTED
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
3000ece8: 1590303c ldrne r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000ecec: 15813034 strne r3, [r1, #52] ; 0x34 <== NOT EXECUTED
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
3000ecf0: 13a03002 movne r3, #2 <== NOT EXECUTED 3000ecf4: 15803030 strne r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000ecf8: e12fff1e bx lr <== NOT EXECUTED
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
3000ecfc: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000ed00: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
3000ed04: eaffffb1 b 3000ebd0 <_Thread_queue_Extract> <== NOT EXECUTED
3000bf30 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000bf30: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
/* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue )
3000bf34: e2504000 subs r4, r0, #0 <== NOT EXECUTED
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000bf38: e1a05001 mov r5, r1 <== NOT EXECUTED
/* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue )
3000bf3c: 0a000011 beq 3000bf88 <_Thread_queue_Requeue+0x58> <== NOT EXECUTED
/*
* If queueing by FIFO, there is nothing to do. This only applies to
* priority blocking discipline.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
3000bf40: e5942034 ldr r2, [r4, #52] ; 0x34 <== NOT EXECUTED 3000bf44: e3520001 cmp r2, #1 <== NOT EXECUTED 3000bf48: 1a00000e bne 3000bf88 <_Thread_queue_Requeue+0x58> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bf4c: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000bf50: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000bf54: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 3000bf58: e59f302c ldr r3, [pc, #44] ; 3000bf8c <_Thread_queue_Requeue+0x5c><== NOT EXECUTED 3000bf5c: e591c010 ldr ip, [r1, #16] <== NOT EXECUTED 3000bf60: e00c3003 and r3, ip, r3 <== NOT EXECUTED
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
3000bf64: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf68: 0a000005 beq 3000bf84 <_Thread_queue_Requeue+0x54> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000bf6c: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
3000bf70: eb000b1c bl 3000ebe8 <_Thread_queue_Extract_priority_helper><== NOT EXECUTED
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
3000bf74: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bf78: e1a01005 mov r1, r5 <== NOT EXECUTED 3000bf7c: e1a0200d mov r2, sp <== NOT EXECUTED 3000bf80: ebffff54 bl 3000bcd8 <_Thread_queue_Enqueue_priority> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bf84: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
}
_ISR_Enable( level );
}
}
3000bf88: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000bf90 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000bf90: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000bf94: e1a0100d mov r1, sp <== NOT EXECUTED 3000bf98: ebfffe16 bl 3000b7f8 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000bf9c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000bfa0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bfa4: 1a000004 bne 3000bfbc <_Thread_queue_Timeout+0x2c> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
3000bfa8: eb000b44 bl 3000ecc0 <_Thread_queue_Process_timeout> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000bfac: e59f300c ldr r3, [pc, #12] ; 3000bfc0 <_Thread_queue_Timeout+0x30><== NOT EXECUTED 3000bfb0: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000bfb4: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000bfb8: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000bfbc: e8bd8008 pop {r3, pc} <== NOT EXECUTED
300186a8 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
300186a8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
300186ac: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
300186b0: e28d9010 add r9, sp, #16 <== NOT EXECUTED 300186b4: e28d6004 add r6, sp, #4 <== NOT EXECUTED 300186b8: e2893004 add r3, r9, #4 <== NOT EXECUTED
head->previous = NULL;
300186bc: e3a02000 mov r2, #0 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
300186c0: e2868004 add r8, r6, #4 <== NOT EXECUTED
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
300186c4: e59fb180 ldr fp, [pc, #384] ; 3001884c <_Timer_server_Body+0x1a4><== NOT EXECUTED
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
300186c8: e1a04000 mov r4, r0 <== NOT EXECUTED 300186cc: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
head->previous = NULL;
300186d0: e58d2014 str r2, [sp, #20] <== NOT EXECUTED
tail->previous = head;
300186d4: e58d9018 str r9, [sp, #24] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
300186d8: e58d8004 str r8, [sp, #4] <== NOT EXECUTED
head->previous = NULL;
300186dc: e58d2008 str r2, [sp, #8] <== NOT EXECUTED
tail->previous = head;
300186e0: e58d600c str r6, [sp, #12] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
300186e4: e58d3000 str r3, [sp] <== NOT EXECUTED
{
/*
* 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;
300186e8: e5849078 str r9, [r4, #120] ; 0x78 <== NOT EXECUTED
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
300186ec: e284a030 add sl, r4, #48 ; 0x30 <== 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 );
300186f0: e2847068 add r7, r4, #104 ; 0x68 <== NOT EXECUTED
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
300186f4: e59b3000 ldr r3, [fp] <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
300186f8: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
300186fc: e1a02006 mov r2, r6 <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
30018700: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
30018704: e1a0000a mov r0, sl <== NOT EXECUTED 30018708: e0611003 rsb r1, r1, r3 <== NOT EXECUTED 3001870c: eb001058 bl 3001c874 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
30018710: e59f2138 ldr r2, [pc, #312] ; 30018850 <_Timer_server_Body+0x1a8><== NOT EXECUTED 30018714: e5925000 ldr r5, [r2] <== NOT EXECUTED
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
30018718: e5942074 ldr r2, [r4, #116] ; 0x74 <== NOT EXECUTED
/*
* 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 ) {
3001871c: e1550002 cmp r5, r2 <== NOT EXECUTED 30018720: 9a000004 bls 30018738 <_Timer_server_Body+0x90> <== NOT EXECUTED
/*
* 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 );
30018724: e0621005 rsb r1, r2, r5 <== NOT EXECUTED 30018728: e1a00007 mov r0, r7 <== NOT EXECUTED 3001872c: e1a02006 mov r2, r6 <== NOT EXECUTED 30018730: eb00104f bl 3001c874 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 30018734: ea000003 b 30018748 <_Timer_server_Body+0xa0> <== 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 );
30018738: 31a00007 movcc r0, r7 <== NOT EXECUTED 3001873c: 33a01001 movcc r1, #1 <== NOT EXECUTED 30018740: 30652002 rsbcc r2, r5, r2 <== NOT EXECUTED 30018744: 3b001022 blcc 3001c7d4 <_Watchdog_Adjust> <== NOT EXECUTED
}
watchdogs->last_snapshot = snapshot;
30018748: e5845074 str r5, [r4, #116] ; 0x74 <== NOT EXECUTED
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
3001874c: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED 30018750: eb000288 bl 30019178 <_Chain_Get> <== NOT EXECUTED
if ( timer == NULL ) {
30018754: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30018758: 0a000009 beq 30018784 <_Timer_server_Body+0xdc> <== NOT EXECUTED
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001875c: e5953038 ldr r3, [r5, #56] ; 0x38 <== NOT EXECUTED 30018760: e3530001 cmp r3, #1 <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
30018764: 01a0000a moveq r0, sl <== NOT EXECUTED
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
30018768: 0a000002 beq 30018778 <_Timer_server_Body+0xd0> <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
3001876c: e3530003 cmp r3, #3 <== NOT EXECUTED 30018770: 1afffff5 bne 3001874c <_Timer_server_Body+0xa4> <== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
30018774: e1a00007 mov r0, r7 <== NOT EXECUTED 30018778: e2851010 add r1, r5, #16 <== NOT EXECUTED 3001877c: eb001067 bl 3001c920 <_Watchdog_Insert> <== NOT EXECUTED 30018780: eafffff1 b 3001874c <_Timer_server_Body+0xa4> <== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
30018784: ebffff95 bl 300185e0 <arm_interrupt_disable> <== NOT EXECUTED
if ( _Chain_Is_empty( insert_chain ) ) {
30018788: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3001878c: e59d2000 ldr r2, [sp] <== NOT EXECUTED 30018790: e1530002 cmp r3, r2 <== NOT EXECUTED 30018794: 1a000006 bne 300187b4 <_Timer_server_Body+0x10c> <== NOT EXECUTED
ts->insert_chain = NULL;
30018798: e5845078 str r5, [r4, #120] ; 0x78 <== NOT EXECUTED 3001879c: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
_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 ) ) {
300187a0: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 300187a4: e1530008 cmp r3, r8 <== NOT EXECUTED
)
{
if ( !_Chain_Is_empty(the_chain))
return _Chain_Get_first_unprotected(the_chain);
else
return NULL;
300187a8: 13a05000 movne r5, #0 <== NOT EXECUTED 300187ac: 1a000002 bne 300187bc <_Timer_server_Body+0x114> <== NOT EXECUTED 300187b0: ea000013 b 30018804 <_Timer_server_Body+0x15c> <== NOT EXECUTED 300187b4: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 300187b8: eaffffcd b 300186f4 <_Timer_server_Body+0x4c> <== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
300187bc: ebffff87 bl 300185e0 <arm_interrupt_disable> <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
300187c0: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
300187c4: e1530008 cmp r3, r8 <== NOT EXECUTED 300187c8: 0a00000b beq 300187fc <_Timer_server_Body+0x154> <== 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;
300187cc: e5932000 ldr r2, [r3] <== NOT EXECUTED
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
300187d0: e3530000 cmp r3, #0 <== NOT EXECUTED
head->next = new_first;
300187d4: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
new_first->previous = head;
300187d8: e5826004 str r6, [r2, #4] <== NOT EXECUTED 300187dc: 0a000006 beq 300187fc <_Timer_server_Body+0x154> <== NOT EXECUTED
watchdog->state = WATCHDOG_INACTIVE;
300187e0: e5835008 str r5, [r3, #8] <== NOT EXECUTED 300187e4: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
/*
* 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 );
300187e8: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 300187ec: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 300187f0: e1a0e00f mov lr, pc <== NOT EXECUTED 300187f4: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED
}
300187f8: eaffffef b 300187bc <_Timer_server_Body+0x114> <== NOT EXECUTED 300187fc: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 30018800: eaffffb8 b 300186e8 <_Timer_server_Body+0x40> <== NOT EXECUTED
} else {
ts->active = false;
30018804: e3a03000 mov r3, #0 <== NOT EXECUTED 30018808: e5c4307c strb r3, [r4, #124] ; 0x7c <== NOT EXECUTED
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
3001880c: ebffff77 bl 300185f0 <_Thread_Disable_dispatch> <== NOT EXECUTED
_Thread_Set_state( ts->thread, STATES_DELAYING );
30018810: e3a01008 mov r1, #8 <== NOT EXECUTED 30018814: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018818: eb000e72 bl 3001c1e8 <_Thread_Set_state> <== NOT EXECUTED
_Timer_server_Reset_interval_system_watchdog( ts );
3001881c: e1a00004 mov r0, r4 <== NOT EXECUTED 30018820: ebffff78 bl 30018608 <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED
_Timer_server_Reset_tod_system_watchdog( ts );
30018824: e1a00004 mov r0, r4 <== NOT EXECUTED 30018828: ebffff8a bl 30018658 <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED
_Thread_Enable_dispatch();
3001882c: eb000c4f bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
ts->active = true;
30018830: e3a03001 mov r3, #1 <== NOT EXECUTED 30018834: e5c4307c strb r3, [r4, #124] ; 0x7c <== NOT EXECUTED
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
30018838: e2840008 add r0, r4, #8 <== NOT EXECUTED 3001883c: eb00108f bl 3001ca80 <_Watchdog_Remove> <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
30018840: e2840040 add r0, r4, #64 ; 0x40 <== NOT EXECUTED 30018844: eb00108d bl 3001ca80 <_Watchdog_Remove> <== NOT EXECUTED 30018848: eaffffa6 b 300186e8 <_Timer_server_Body+0x40> <== NOT EXECUTED
30018608 <_Timer_server_Reset_interval_system_watchdog>:
}
static void _Timer_server_Reset_interval_system_watchdog(
Timer_server_Control *ts
)
{
30018608: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
3001860c: e2805008 add r5, r0, #8 <== NOT EXECUTED
}
static void _Timer_server_Reset_interval_system_watchdog(
Timer_server_Control *ts
)
{
30018610: e1a04000 mov r4, r0 <== NOT EXECUTED
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
30018614: e1a00005 mov r0, r5 <== NOT EXECUTED 30018618: eb001118 bl 3001ca80 <_Watchdog_Remove> <== NOT EXECUTED
{
ISR_Level level;
_Timer_server_Stop_interval_system_watchdog( ts );
_ISR_Disable( level );
3001861c: ebffffef bl 300185e0 <arm_interrupt_disable> <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
30018620: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30018624: e2842034 add r2, r4, #52 ; 0x34 <== NOT EXECUTED
ISR_Level level;
_Timer_server_Stop_interval_system_watchdog( ts );
_ISR_Disable( level );
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
30018628: e1530002 cmp r3, r2 <== NOT EXECUTED 3001862c: 0a000006 beq 3001864c <_Timer_server_Reset_interval_system_watchdog+0x44><== NOT EXECUTED
Watchdog_Interval delta_interval =
30018630: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30018634: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30018638: e59f0014 ldr r0, [pc, #20] ; 30018654 <_Timer_server_Reset_interval_system_watchdog+0x4c><== NOT EXECUTED 3001863c: e1a01005 mov r1, r5 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30018640: e5843014 str r3, [r4, #20] <== NOT EXECUTED
delta_interval
);
} else {
_ISR_Enable( level );
}
}
30018644: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30018648: ea0010b4 b 3001c920 <_Watchdog_Insert> <== NOT EXECUTED
3001864c: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
30018650: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30018658 <_Timer_server_Reset_tod_system_watchdog>:
}
static void _Timer_server_Reset_tod_system_watchdog(
Timer_server_Control *ts
)
{
30018658: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
3001865c: e2805040 add r5, r0, #64 ; 0x40 <== NOT EXECUTED
}
static void _Timer_server_Reset_tod_system_watchdog(
Timer_server_Control *ts
)
{
30018660: e1a04000 mov r4, r0 <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
30018664: e1a00005 mov r0, r5 <== NOT EXECUTED 30018668: eb001104 bl 3001ca80 <_Watchdog_Remove> <== NOT EXECUTED
{
ISR_Level level;
_Timer_server_Stop_tod_system_watchdog( ts );
_ISR_Disable( level );
3001866c: ebffffdb bl 300185e0 <arm_interrupt_disable> <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
30018670: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED 30018674: e284206c add r2, r4, #108 ; 0x6c <== NOT EXECUTED
ISR_Level level;
_Timer_server_Stop_tod_system_watchdog( ts );
_ISR_Disable( level );
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
30018678: e1530002 cmp r3, r2 <== NOT EXECUTED 3001867c: 0a000006 beq 3001869c <_Timer_server_Reset_tod_system_watchdog+0x44><== NOT EXECUTED
Watchdog_Interval delta_interval =
30018680: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 30018684: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
30018688: e59f0014 ldr r0, [pc, #20] ; 300186a4 <_Timer_server_Reset_tod_system_watchdog+0x4c><== NOT EXECUTED 3001868c: e1a01005 mov r1, r5 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30018690: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
delta_interval
);
} else {
_ISR_Enable( level );
}
}
30018694: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
30018698: ea0010a0 b 3001c920 <_Watchdog_Insert> <== NOT EXECUTED
3001869c: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
300186a0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30018854 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
30018854: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
30018858: e5906078 ldr r6, [r0, #120] ; 0x78 <== NOT EXECUTED
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
3001885c: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
30018860: e3560000 cmp r6, #0 <== NOT EXECUTED
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
30018864: e1a05001 mov r5, r1 <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
30018868: 1a000039 bne 30018954 <_Timer_server_Schedule_operation_method+0x100><== NOT EXECUTED
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
3001886c: ebffff5f bl 300185f0 <_Thread_Disable_dispatch> <== NOT EXECUTED
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
30018870: e5953038 ldr r3, [r5, #56] ; 0x38 <== NOT EXECUTED 30018874: e3530001 cmp r3, #1 <== NOT EXECUTED 30018878: 1a000017 bne 300188dc <_Timer_server_Schedule_operation_method+0x88><== NOT EXECUTED
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
3001887c: ebffff57 bl 300185e0 <arm_interrupt_disable> <== NOT EXECUTED
snapshot = _Watchdog_Ticks_since_boot;
30018880: e59f30d8 ldr r3, [pc, #216] ; 30018960 <_Timer_server_Schedule_operation_method+0x10c><== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30018884: e284c034 add ip, r4, #52 ; 0x34 <== NOT EXECUTED 30018888: e5932000 ldr r2, [r3] <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001888c: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
last_snapshot = ts->Interval_watchdogs.last_snapshot;
30018890: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
30018894: e153000c cmp r3, ip <== NOT EXECUTED 30018898: 0a000004 beq 300188b0 <_Timer_server_Schedule_operation_method+0x5c><== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
3001889c: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
300188a0: e0611002 rsb r1, r1, r2 <== NOT EXECUTED
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
300188a4: e15c0001 cmp ip, r1 <== NOT EXECUTED
delta_interval -= delta;
300188a8: 8061600c rsbhi r6, r1, ip <== NOT EXECUTED
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
300188ac: e5836010 str r6, [r3, #16] <== NOT EXECUTED
}
ts->Interval_watchdogs.last_snapshot = snapshot;
300188b0: e584203c str r2, [r4, #60] ; 0x3c <== NOT EXECUTED 300188b4: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
300188b8: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 300188bc: e2851010 add r1, r5, #16 <== NOT EXECUTED 300188c0: eb001016 bl 3001c920 <_Watchdog_Insert> <== NOT EXECUTED
if ( !ts->active ) {
300188c4: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 300188c8: e3530000 cmp r3, #0 <== NOT EXECUTED 300188cc: 1a00001e bne 3001894c <_Timer_server_Schedule_operation_method+0xf8><== NOT EXECUTED
_Timer_server_Reset_interval_system_watchdog( ts );
300188d0: e1a00004 mov r0, r4 <== NOT EXECUTED 300188d4: ebffff4b bl 30018608 <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED 300188d8: ea00001b b 3001894c <_Timer_server_Schedule_operation_method+0xf8><== NOT EXECUTED
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
300188dc: e3530003 cmp r3, #3 <== NOT EXECUTED 300188e0: 1a000019 bne 3001894c <_Timer_server_Schedule_operation_method+0xf8><== NOT EXECUTED
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
300188e4: ebffff3d bl 300185e0 <arm_interrupt_disable> <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
300188e8: e5942068 ldr r2, [r4, #104] ; 0x68 <== NOT EXECUTED
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
300188ec: e59f3070 ldr r3, [pc, #112] ; 30018964 <_Timer_server_Schedule_operation_method+0x110><== NOT EXECUTED 300188f0: e284c06c add ip, r4, #108 ; 0x6c <== NOT EXECUTED
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
300188f4: e152000c cmp r2, ip <== NOT EXECUTED
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
300188f8: e5933000 ldr r3, [r3] <== NOT EXECUTED
last_snapshot = ts->TOD_watchdogs.last_snapshot;
300188fc: e5941074 ldr r1, [r4, #116] ; 0x74 <== NOT EXECUTED
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
30018900: 0a000008 beq 30018928 <_Timer_server_Schedule_operation_method+0xd4><== NOT EXECUTED
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
30018904: e592c010 ldr ip, [r2, #16] <== NOT EXECUTED
if ( snapshot > last_snapshot ) {
30018908: e1530001 cmp r3, r1 <== NOT EXECUTED
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
3001890c: 908c6001 addls r6, ip, r1 <== NOT EXECUTED
delta_interval += delta;
30018910: 90636006 rsbls r6, r3, r6 <== NOT EXECUTED
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
if ( snapshot > last_snapshot ) {
30018914: 9a000002 bls 30018924 <_Timer_server_Schedule_operation_method+0xd0><== NOT EXECUTED
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
30018918: e0611003 rsb r1, r1, r3 <== NOT EXECUTED
if (delta_interval > delta) {
3001891c: e15c0001 cmp ip, r1 <== NOT EXECUTED
delta_interval -= delta;
30018920: 8061600c rsbhi r6, r1, ip <== NOT EXECUTED
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
30018924: e5826010 str r6, [r2, #16] <== NOT EXECUTED
}
ts->TOD_watchdogs.last_snapshot = snapshot;
30018928: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED 3001892c: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
30018930: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED 30018934: e2851010 add r1, r5, #16 <== NOT EXECUTED 30018938: eb000ff8 bl 3001c920 <_Watchdog_Insert> <== NOT EXECUTED
if ( !ts->active ) {
3001893c: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 30018940: e3530000 cmp r3, #0 <== NOT EXECUTED
_Timer_server_Reset_tod_system_watchdog( ts );
30018944: 01a00004 moveq r0, r4 <== NOT EXECUTED 30018948: 0bffff42 bleq 30018658 <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
}
}
3001894c: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
30018950: ea000c06 b 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
30018954: e5900078 ldr r0, [r0, #120] ; 0x78 <== NOT EXECUTED
} }
30018958: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
3001895c: ea0001f2 b 3001912c <_Chain_Append> <== NOT EXECUTED
3000c1e0 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
3000c1e0: e1a03000 mov r3, r0
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000c1e4: e5932000 ldr r2, [r3]
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
uint32_t seconds = add->tv_sec;
3000c1e8: e5910000 ldr r0, [r1]
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
3000c1ec: e593c004 ldr ip, [r3, #4]
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000c1f0: e0822000 add r2, r2, r0 3000c1f4: e5832000 str r2, [r3]
time->tv_nsec += add->tv_nsec;
3000c1f8: e5912004 ldr r2, [r1, #4] 3000c1fc: e08c2002 add r2, ip, r2 3000c200: e5832004 str r2, [r3, #4]
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000c204: e59fc02c ldr ip, [pc, #44] ; 3000c238 <_Timespec_Add_to+0x58> 3000c208: ea000006 b 3000c228 <_Timespec_Add_to+0x48>
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000c20c: e59f2028 ldr r2, [pc, #40] ; 3000c23c <_Timespec_Add_to+0x5c><== NOT EXECUTED
time->tv_sec++;
seconds++;
3000c210: e2800001 add r0, r0, #1 <== NOT EXECUTED
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000c214: e0812002 add r2, r1, r2 <== NOT EXECUTED 3000c218: e5832004 str r2, [r3, #4] <== NOT EXECUTED
time->tv_sec++;
3000c21c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c220: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000c224: e5832000 str r2, [r3] <== NOT EXECUTED
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000c228: e5931004 ldr r1, [r3, #4] 3000c22c: e151000c cmp r1, ip
3000c230: 8afffff5 bhi 3000c20c <_Timespec_Add_to+0x2c>
time->tv_sec++;
seconds++;
}
return seconds;
}
3000c234: e12fff1e bx lr
3000dcf4 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000dcf4: e92d40f0 push {r4, r5, r6, r7, lr}
3000dcf8: e1a05002 mov r5, r2
* in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec;
3000dcfc: e5912004 ldr r2, [r1, #4]
* For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000dd00: e5917000 ldr r7, [r1]
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000dd04: e590c000 ldr ip, [r0]
left += lhs->tv_nsec;
3000dd08: e5906004 ldr r6, [r0, #4]
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000dd0c: e59f0064 ldr r0, [pc, #100] ; 3000dd78 <_Timespec_Divide+0x84>
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000dd10: e1a04003 mov r4, r3
* in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec;
3000dd14: e1a03fc2 asr r3, r2, #31 3000dd18: e0e32790 smlal r2, r3, r0, r7
if ( right == 0 ) {
3000dd1c: e1921003 orrs r1, r2, r3
*ival_percentage = 0;
3000dd20: 05851000 streq r1, [r5]
*fval_percentage = 0;
3000dd24: 05841000 streq r1, [r4]
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
3000dd28: 08bd80f0 popeq {r4, r5, r6, r7, pc}
/* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec;
3000dd2c: e1a07fc6 asr r7, r6, #31 <== NOT EXECUTED 3000dd30: e0e76c90 smlal r6, r7, r0, ip <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
3000dd34: e59fc040 ldr ip, [pc, #64] ; 3000dd7c <_Timespec_Divide+0x88><== NOT EXECUTED 3000dd38: e0810c96 umull r0, r1, r6, ip <== NOT EXECUTED 3000dd3c: e021179c mla r1, ip, r7, r1 <== NOT EXECUTED 3000dd40: eb003bf7 bl 3001cd24 <__udivdi3> <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000dd44: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000dd48: e3a03000 mov r3, #0 <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
3000dd4c: e1a07000 mov r7, r0 <== NOT EXECUTED 3000dd50: e1a06001 mov r6, r1 <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000dd54: eb003bf2 bl 3001cd24 <__udivdi3> <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000dd58: e1a01006 mov r1, r6 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
3000dd5c: e5850000 str r0, [r5] <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000dd60: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
3000dd64: e1a00007 mov r0, r7 <== NOT EXECUTED
3000dd68: e3a03000 mov r3, #0 <== NOT EXECUTED
3000dd6c: eb003cfe bl 3001d16c <__umoddi3> <== NOT EXECUTED
3000dd70: e5840000 str r0, [r4] <== NOT EXECUTED
3000dd74: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000dcf0 <_Timespec_Divide_by_integer>:
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3000dcf0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; t *= TOD_NANOSECONDS_PER_SECOND;
3000dcf4: e59fc06c ldr ip, [pc, #108] ; 3000dd68 <_Timespec_Divide_by_integer+0x78><== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
t = time->tv_sec;
3000dcf8: e590e000 ldr lr, [r0] <== NOT EXECUTED
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3000dcfc: e1a03001 mov r3, r1 <== NOT EXECUTED 3000dd00: e1a04002 mov r4, r2 <== NOT EXECUTED
/* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; t *= TOD_NANOSECONDS_PER_SECOND;
3000dd04: e0821c9e umull r1, r2, lr, ip <== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
t = time->tv_sec;
3000dd08: e1a0500e mov r5, lr <== NOT EXECUTED 3000dd0c: e1a06fc5 asr r6, r5, #31 <== NOT EXECUTED
t *= TOD_NANOSECONDS_PER_SECOND;
3000dd10: e022269c mla r2, ip, r6, r2 <== NOT EXECUTED
t += time->tv_nsec;
3000dd14: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3000dd18: e0915000 adds r5, r1, r0 <== NOT EXECUTED 3000dd1c: e0a26fc0 adc r6, r2, r0, asr #31 <== NOT EXECUTED 3000dd20: e1a01006 mov r1, r6 <== NOT EXECUTED 3000dd24: e1a02003 mov r2, r3 <== NOT EXECUTED 3000dd28: e1a00005 mov r0, r5 <== NOT EXECUTED 3000dd2c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000dd30: eb003a36 bl 3001c610 <__udivdi3> <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000dd34: e59f202c ldr r2, [pc, #44] ; 3000dd68 <_Timespec_Divide_by_integer+0x78><== NOT EXECUTED 3000dd38: e3a03000 mov r3, #0 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3000dd3c: e1a06000 mov r6, r0 <== NOT EXECUTED 3000dd40: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000dd44: eb003a31 bl 3001c610 <__udivdi3> <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
3000dd48: e1a01005 mov r1, r5 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000dd4c: e5840000 str r0, [r4] <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
3000dd50: e59f2010 ldr r2, [pc, #16] ; 3000dd68 <_Timespec_Divide_by_integer+0x78><== NOT EXECUTED 3000dd54: e1a00006 mov r0, r6 <== NOT EXECUTED 3000dd58: e3a03000 mov r3, #0 <== NOT EXECUTED 3000dd5c: eb003b3d bl 3001ca58 <__umoddi3> <== NOT EXECUTED 3000dd60: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
3000dd64: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30020a9c <_Timespec_From_ticks>:
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
30020a9c: e59f3038 ldr r3, [pc, #56] ; 30020adc <_Timespec_From_ticks+0x40><== NOT EXECUTED
void _Timespec_From_ticks(
uint32_t ticks,
struct timespec *time
)
{
30020aa0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
30020aa4: e593500c ldr r5, [r3, #12] <== NOT EXECUTED
void _Timespec_From_ticks(
uint32_t ticks,
struct timespec *time
)
{
30020aa8: e1a04001 mov r4, r1 <== NOT EXECUTED
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
30020aac: e0050590 mul r5, r0, r5 <== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
30020ab0: e59f1028 ldr r1, [pc, #40] ; 30020ae0 <_Timespec_From_ticks+0x44><== NOT EXECUTED 30020ab4: e1a00005 mov r0, r5 <== NOT EXECUTED 30020ab8: ebfff67d bl 3001e4b4 <__aeabi_uidiv> <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
30020abc: e59f101c ldr r1, [pc, #28] ; 30020ae0 <_Timespec_From_ticks+0x44><== NOT EXECUTED
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
30020ac0: e5840000 str r0, [r4] <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
30020ac4: e1a00005 mov r0, r5 <== NOT EXECUTED 30020ac8: ebfff711 bl 3001e714 <__umodsi3> <== NOT EXECUTED 30020acc: e3a03ffa mov r3, #1000 ; 0x3e8 <== NOT EXECUTED 30020ad0: e0030390 mul r3, r0, r3 <== NOT EXECUTED 30020ad4: e5843004 str r3, [r4, #4] <== NOT EXECUTED
TOD_NANOSECONDS_PER_MICROSECOND;
}
30020ad8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30020ae4 <_Timespec_Is_valid>:
bool _Timespec_Is_valid(
const struct timespec *time
)
{
if ( !time )
30020ae4: e3500000 cmp r0, #0 <== NOT EXECUTED 30020ae8: 012fff1e bxeq lr <== NOT EXECUTED
return false;
if ( time->tv_sec < 0 )
30020aec: e5903000 ldr r3, [r0] <== NOT EXECUTED 30020af0: e3530000 cmp r3, #0 <== NOT EXECUTED
return false;
30020af4: b3a00000 movlt r0, #0 <== NOT EXECUTED
)
{
if ( !time )
return false;
if ( time->tv_sec < 0 )
30020af8: b12fff1e bxlt lr <== NOT EXECUTED
return false;
if ( time->tv_nsec < 0 )
30020afc: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 30020b00: e3530000 cmp r3, #0 <== NOT EXECUTED 30020b04: ba000004 blt 30020b1c <_Timespec_Is_valid+0x38> <== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
30020b08: e59f0014 ldr r0, [pc, #20] ; 30020b24 <_Timespec_Is_valid+0x40><== NOT EXECUTED 30020b0c: e1530000 cmp r3, r0 <== NOT EXECUTED 30020b10: 83a00000 movhi r0, #0 <== NOT EXECUTED 30020b14: 93a00001 movls r0, #1 <== NOT EXECUTED 30020b18: e12fff1e bx lr <== NOT EXECUTED
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
30020b1c: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
30020b20: e12fff1e bx lr <== NOT EXECUTED
3000dda4 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
3000dda4: e5902000 ldr r2, [r0] 3000dda8: e5913000 ldr r3, [r1] 3000ddac: e1520003 cmp r2, r3
return true;
3000ddb0: b3a00001 movlt r0, #1
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
3000ddb4: b12fff1e bxlt lr
return true;
if ( lhs->tv_sec > rhs->tv_sec )
3000ddb8: ca000005 bgt 3000ddd4 <_Timespec_Less_than+0x30>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Less_than(
3000ddbc: e5900004 ldr r0, [r0, #4] 3000ddc0: e5913004 ldr r3, [r1, #4] 3000ddc4: e1500003 cmp r0, r3 3000ddc8: a3a00000 movge r0, #0 3000ddcc: b3a00001 movlt r0, #1 3000ddd0: e12fff1e bx lr
{
if ( lhs->tv_sec < rhs->tv_sec )
return true;
if ( lhs->tv_sec > rhs->tv_sec )
return false;
3000ddd4: e3a00000 mov r0, #0 <== NOT EXECUTED
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
return true;
return false;
}
3000ddd8: e12fff1e bx lr <== NOT EXECUTED
30020b28 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
30020b28: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
30020b2c: e5906000 ldr r6, [r0] <== NOT EXECUTED
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
30020b30: e1a05000 mov r5, r0 <== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
30020b34: e3560000 cmp r6, #0 <== NOT EXECUTED
30020b38: 1a000002 bne 30020b48 <_Timespec_To_ticks+0x20> <== NOT EXECUTED
30020b3c: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED
30020b40: e3500000 cmp r0, #0 <== NOT EXECUTED
30020b44: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
30020b48: eb00007f bl 30020d4c <TOD_TICKS_PER_SECOND_method> <== NOT EXECUTED
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
30020b4c: e59f3020 ldr r3, [pc, #32] ; 30020b74 <_Timespec_To_ticks+0x4c><== NOT EXECUTED 30020b50: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30020b54: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
30020b58: e0040096 mul r4, r6, r0 <== NOT EXECUTED
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
30020b5c: e0010193 mul r1, r3, r1 <== NOT EXECUTED 30020b60: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 30020b64: ebfff652 bl 3001e4b4 <__aeabi_uidiv> <== NOT EXECUTED
if (ticks)
30020b68: e0940000 adds r0, r4, r0 <== NOT EXECUTED
return ticks;
return 1;
30020b6c: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
30020b70: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000c3a4 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000c3a4: e92d41f0 push {r4, r5, r6, r7, r8, lr}
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
3000c3a8: e59f503c ldr r5, [pc, #60] ; 3000c3ec <_User_extensions_Fatal+0x48>
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000c3ac: e1a08000 mov r8, r0 3000c3b0: e1a07002 mov r7, r2 3000c3b4: e20160ff and r6, r1, #255 ; 0xff
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
3000c3b8: e5954008 ldr r4, [r5, #8]
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000c3bc: ea000007 b 3000c3e0 <_User_extensions_Fatal+0x3c>
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
3000c3c0: e5943030 ldr r3, [r4, #48] ; 0x30 3000c3c4: e3530000 cmp r3, #0
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
3000c3c8: 11a00008 movne r0, r8 3000c3cc: 11a01006 movne r1, r6 3000c3d0: 11a02007 movne r2, r7 3000c3d4: 11a0e00f movne lr, pc 3000c3d8: 112fff13 bxne r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
3000c3dc: e5944004 ldr r4, [r4, #4]
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000c3e0: e1540005 cmp r4, r5
3000c3e4: 1afffff5 bne 3000c3c0 <_User_extensions_Fatal+0x1c>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
3000c3e8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000da30 <_User_extensions_Remove_set>:
#include <rtems/score/userext.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
3000da30: e92d4010 push {r4, lr}
3000da34: e1a04000 mov r4, r0
_Chain_Extract( &the_extension->Node );
3000da38: ebfff69e bl 3000b4b8 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
3000da3c: e5943024 ldr r3, [r4, #36] ; 0x24
3000da40: e3530000 cmp r3, #0
3000da44: 08bd8010 popeq {r4, pc}
_Chain_Extract( &the_extension->Switch.Node );
3000da48: e2840008 add r0, r4, #8 <== NOT EXECUTED
}
3000da4c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
_Chain_Extract( &the_extension->Switch.Node );
3000da50: eafff698 b 3000b4b8 <_Chain_Extract> <== NOT EXECUTED
3000e090 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
3000e090: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000e094: e1a04000 mov r4, r0
3000e098: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000e09c: e10f3000 mrs r3, CPSR 3000e0a0: e3832080 orr r2, r3, #128 ; 0x80 3000e0a4: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
3000e0a8: e1a06000 mov r6, r0 3000e0ac: e4962004 ldr r2, [r6], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
3000e0b0: e1520006 cmp r2, r6
3000e0b4: 0a00001b beq 3000e128 <_Watchdog_Adjust+0x98>
switch ( direction ) {
3000e0b8: e3510000 cmp r1, #0 <== NOT EXECUTED
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000e0bc: 03a08001 moveq r8, #1 <== NOT EXECUTED
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000e0c0: 0a000016 beq 3000e120 <_Watchdog_Adjust+0x90> <== NOT EXECUTED 3000e0c4: e3510001 cmp r1, #1 <== NOT EXECUTED 3000e0c8: 1a000016 bne 3000e128 <_Watchdog_Adjust+0x98> <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
3000e0cc: e5921010 ldr r1, [r2, #16] <== NOT EXECUTED 3000e0d0: e0815005 add r5, r1, r5 <== NOT EXECUTED 3000e0d4: ea000004 b 3000e0ec <_Watchdog_Adjust+0x5c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000e0d8: e5942000 ldr r2, [r4] <== NOT EXECUTED
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
3000e0dc: e5927010 ldr r7, [r2, #16] <== NOT EXECUTED 3000e0e0: e1550007 cmp r5, r7 <== NOT EXECUTED 3000e0e4: 2a000002 bcs 3000e0f4 <_Watchdog_Adjust+0x64> <== NOT EXECUTED
_Watchdog_First( header )->delta_interval -= units;
3000e0e8: e0655007 rsb r5, r5, r7 <== NOT EXECUTED 3000e0ec: e5825010 str r5, [r2, #16] <== NOT EXECUTED
break;
3000e0f0: ea00000c b 3000e128 <_Watchdog_Adjust+0x98> <== NOT EXECUTED
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000e0f4: e5828010 str r8, [r2, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000e0f8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Tickle( header );
3000e0fc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000e100: eb00008b bl 3000e334 <_Watchdog_Tickle> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000e104: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000e108: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000e10c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000e110: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000e114: e1520006 cmp r2, r6 <== NOT EXECUTED 3000e118: 0a000002 beq 3000e128 <_Watchdog_Adjust+0x98> <== NOT EXECUTED
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
3000e11c: e0675005 rsb r5, r7, r5 <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000e120: e3550000 cmp r5, #0 <== NOT EXECUTED 3000e124: 1affffeb bne 3000e0d8 <_Watchdog_Adjust+0x48> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000e128: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
3000e12c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3001c874 <_Watchdog_Adjust_to_chain>:
{
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
if ( units <= 0 ) {
3001c874: e3510000 cmp r1, #0 <== NOT EXECUTED
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
3001c878: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
if ( units <= 0 ) {
3001c87c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001c880: e10f5000 mrs r5, CPSR <== NOT EXECUTED 3001c884: e3853080 orr r3, r5, #128 ; 0x80 <== NOT EXECUTED 3001c888: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/*
* The first set happens in less than units, so take all of them
* off the chain and adjust units to reflect this.
*/
units -= first->delta_interval;
first->delta_interval = 0;
3001c88c: e3a08000 mov r8, #0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3001c890: e2806004 add r6, r0, #4 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
3001c894: e2827004 add r7, r2, #4 <== NOT EXECUTED 3001c898: ea000001 b 3001c8a4 <_Watchdog_Adjust_to_chain+0x30> <== NOT EXECUTED
}
_ISR_Disable( level );
while ( 1 ) {
if ( units <= 0 ) {
3001c89c: e3510000 cmp r1, #0 <== NOT EXECUTED 3001c8a0: 0a00001c beq 3001c918 <_Watchdog_Adjust_to_chain+0xa4> <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001c8a4: e590c000 ldr ip, [r0] <== NOT EXECUTED
while ( 1 ) {
if ( units <= 0 ) {
break;
}
if ( _Chain_Is_empty( header ) ) {
3001c8a8: e15c0006 cmp ip, r6 <== NOT EXECUTED 3001c8ac: 0a000019 beq 3001c918 <_Watchdog_Adjust_to_chain+0xa4> <== NOT EXECUTED
/*
* If it is longer than "units" until the first element on the chain
* fires, then bump it and quit.
*/
if ( units < first->delta_interval ) {
3001c8b0: e59c4010 ldr r4, [ip, #16] <== NOT EXECUTED 3001c8b4: e1a0300c mov r3, ip <== NOT EXECUTED 3001c8b8: e1510004 cmp r1, r4 <== NOT EXECUTED
first->delta_interval -= units;
3001c8bc: 30611004 rsbcc r1, r1, r4 <== NOT EXECUTED 3001c8c0: 358c1010 strcc r1, [ip, #16] <== NOT EXECUTED
break;
3001c8c4: 3a000013 bcc 3001c918 <_Watchdog_Adjust_to_chain+0xa4> <== NOT EXECUTED
/*
* The first set happens in less than units, so take all of them
* off the chain and adjust units to reflect this.
*/
units -= first->delta_interval;
3001c8c8: e0641001 rsb r1, r4, r1 <== NOT EXECUTED
first->delta_interval = 0;
3001c8cc: e58c8010 str r8, [ip, #16] <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3001c8d0: e8931010 ldm r3, {r4, ip} <== NOT EXECUTED
next->previous = previous;
3001c8d4: e584c004 str ip, [r4, #4] <== NOT EXECUTED
previous->next = next;
3001c8d8: e58c4000 str r4, [ip] <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3001c8dc: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
the_node->next = tail;
3001c8e0: e5837000 str r7, [r3] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node;
3001c8e4: e58c3000 str r3, [ip] <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3001c8e8: e5823008 str r3, [r2, #8] <== NOT EXECUTED
old_last->next = the_node; the_node->previous = old_last;
3001c8ec: e583c004 str ip, [r3, #4] <== NOT EXECUTED
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3001c8f0: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001c8f4: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED 3001c8f8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001c8fc: e5903000 ldr r3, [r0] <== NOT EXECUTED
_Chain_Extract_unprotected( &first->Node );
_Chain_Append_unprotected( to_fire, &first->Node );
_ISR_Flash( level );
if ( _Chain_Is_empty( header ) )
3001c900: e1530006 cmp r3, r6 <== NOT EXECUTED 3001c904: 0affffe4 beq 3001c89c <_Watchdog_Adjust_to_chain+0x28> <== NOT EXECUTED
break;
first = _Watchdog_First( header );
if ( first->delta_interval != 0 )
3001c908: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001c90c: e35c0000 cmp ip, #0 <== NOT EXECUTED 3001c910: 0affffee beq 3001c8d0 <_Watchdog_Adjust_to_chain+0x5c> <== NOT EXECUTED 3001c914: eaffffe0 b 3001c89c <_Watchdog_Adjust_to_chain+0x28> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001c918: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
3001c91c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c514 <_Watchdog_Insert>:
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
3000c514: e59f30f4 ldr r3, [pc, #244] ; 3000c610 <_Watchdog_Insert+0xfc>
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
3000c518: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
3000c51c: e5934000 ldr r4, [r3]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c520: e10fc000 mrs ip, CPSR 3000c524: e38c3080 orr r3, ip, #128 ; 0x80 3000c528: e129f003 msr CPSR_fc, r3
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
3000c52c: e5913008 ldr r3, [r1, #8] 3000c530: e3530000 cmp r3, #0
3000c534: 0a000000 beq 3000c53c <_Watchdog_Insert+0x28>
_ISR_Enable( level );
3000c538: ea000032 b 3000c608 <_Watchdog_Insert+0xf4> <== NOT EXECUTED
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
3000c53c: e3a03001 mov r3, #1 3000c540: e5813008 str r3, [r1, #8]
_Watchdog_Sync_count++;
3000c544: e59f30c8 ldr r3, [pc, #200] ; 3000c614 <_Watchdog_Insert+0x100>
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000c548: e59f60c8 ldr r6, [pc, #200] ; 3000c618 <_Watchdog_Insert+0x104>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
3000c54c: e5932000 ldr r2, [r3]
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000c550: e1a07006 mov r7, r6
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
3000c554: e2822001 add r2, r2, #1 3000c558: e5832000 str r2, [r3]
restart:
delta_interval = the_watchdog->initial;
3000c55c: e591200c ldr r2, [r1, #12]
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000c560: e5903000 ldr r3, [r0]
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000c564: e3520000 cmp r2, #0
3000c568: 0a000014 beq 3000c5c0 <_Watchdog_Insert+0xac>
3000c56c: e5935000 ldr r5, [r3] 3000c570: e3550000 cmp r5, #0
3000c574: 0a000011 beq 3000c5c0 <_Watchdog_Insert+0xac>
break;
if ( delta_interval < after->delta_interval ) {
3000c578: e5935010 ldr r5, [r3, #16] 3000c57c: e1520005 cmp r2, r5
after->delta_interval -= delta_interval;
3000c580: 30625005 rsbcc r5, r2, r5 3000c584: 35835010 strcc r5, [r3, #16]
break;
3000c588: 3a00000c bcc 3000c5c0 <_Watchdog_Insert+0xac>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000c58c: e10f8000 mrs r8, CPSR 3000c590: e129f00c msr CPSR_fc, ip 3000c594: e129f008 msr CPSR_fc, r8
delta_interval -= after->delta_interval;
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
3000c598: e5918008 ldr r8, [r1, #8] 3000c59c: e3580001 cmp r8, #1
3000c5a0: 1a000012 bne 3000c5f0 <_Watchdog_Insert+0xdc>
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000c5a4: e5968000 ldr r8, [r6] 3000c5a8: e1580004 cmp r8, r4
_Watchdog_Sync_level = insert_isr_nest_level;
3000c5ac: 85874000 strhi r4, [r7]
goto restart;
3000c5b0: 8affffe9 bhi 3000c55c <_Watchdog_Insert+0x48>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
3000c5b4: e0652002 rsb r2, r5, r2
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
3000c5b8: e5933000 ldr r3, [r3]
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
goto restart;
}
}
3000c5bc: eaffffe8 b 3000c564 <_Watchdog_Insert+0x50>
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
3000c5c0: e5933004 ldr r3, [r3, #4]
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
3000c5c4: e3a00002 mov r0, #2
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
3000c5c8: e5812010 str r2, [r1, #16] 3000c5cc: e5810008 str r0, [r1, #8]
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000c5d0: e5932000 ldr r2, [r3]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000c5d4: e5813004 str r3, [r1, #4]
before_node = after_node->next; after_node->next = the_node;
3000c5d8: e5831000 str r1, [r3]
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
3000c5dc: e59f3038 ldr r3, [pc, #56] ; 3000c61c <_Watchdog_Insert+0x108>
the_node->next = before_node; before_node->previous = the_node;
3000c5e0: e5821004 str r1, [r2, #4] 3000c5e4: e5933000 ldr r3, [r3]
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
3000c5e8: e5812000 str r2, [r1] 3000c5ec: e5813014 str r3, [r1, #20]
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
3000c5f0: e59f3020 ldr r3, [pc, #32] ; 3000c618 <_Watchdog_Insert+0x104> 3000c5f4: e5834000 str r4, [r3]
_Watchdog_Sync_count--;
3000c5f8: e59f3014 ldr r3, [pc, #20] ; 3000c614 <_Watchdog_Insert+0x100> 3000c5fc: e5932000 ldr r2, [r3] 3000c600: e2422001 sub r2, r2, #1 3000c604: e5832000 str r2, [r3]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c608: e129f00c msr CPSR_fc, ip
3000c60c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000db70 <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
3000db70: e92d401f push {r0, r1, r2, r3, r4, lr} <== NOT EXECUTED
3000db74: e1a03001 mov r3, r1 <== NOT EXECUTED
printk(
3000db78: e2501000 subs r1, r0, #0 <== NOT EXECUTED
3000db7c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
3000db80: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED
3000db84: e593001c ldr r0, [r3, #28] <== NOT EXECUTED
3000db88: 059f102c ldreq r1, [pc, #44] ; 3000dbbc <_Watchdog_Report+0x4c><== NOT EXECUTED
3000db8c: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
3000db90: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
3000db94: 01a02001 moveq r2, r1 <== NOT EXECUTED
3000db98: e58d000c str r0, [sp, #12] <== NOT EXECUTED
3000db9c: e5930024 ldr r0, [r3, #36] ; 0x24 <== NOT EXECUTED
3000dba0: 159f2018 ldrne r2, [pc, #24] ; 3000dbc0 <_Watchdog_Report+0x50><== NOT EXECUTED
3000dba4: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
3000dba8: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
3000dbac: e59f0010 ldr r0, [pc, #16] ; 3000dbc4 <_Watchdog_Report+0x54><== NOT EXECUTED
3000dbb0: ebffe876 bl 30007d90 <printk> <== NOT EXECUTED
watch,
watch->routine,
watch->id,
watch->user_data
);
}
3000dbb4: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000dbb8: e8bd8000 pop {pc} <== NOT EXECUTED
3000daf8 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
3000daf8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000dafc: e1a04000 mov r4, r0 <== NOT EXECUTED
3000db00: e1a05001 mov r5, r1 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000db04: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000db08: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000db0c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
3000db10: e59f004c ldr r0, [pc, #76] ; 3000db64 <_Watchdog_Report_chain+0x6c><== NOT EXECUTED 3000db14: e1a02005 mov r2, r5 <== NOT EXECUTED 3000db18: e1a01004 mov r1, r4 <== NOT EXECUTED 3000db1c: ebffe89b bl 30007d90 <printk> <== NOT EXECUTED
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
3000db20: e4957004 ldr r7, [r5], #4 <== NOT EXECUTED
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
3000db24: e1570005 cmp r7, r5 <== NOT EXECUTED 3000db28: 0a000009 beq 3000db54 <_Watchdog_Report_chain+0x5c> <== NOT EXECUTED
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
3000db2c: e1a01007 mov r1, r7 <== NOT EXECUTED 3000db30: e3a00000 mov r0, #0 <== NOT EXECUTED 3000db34: eb00000d bl 3000db70 <_Watchdog_Report> <== NOT EXECUTED
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
node != _Chain_Tail(header) ;
node = node->next )
3000db38: e5977000 ldr r7, [r7] <== NOT EXECUTED
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
3000db3c: e1570005 cmp r7, r5 <== NOT EXECUTED 3000db40: 1afffff9 bne 3000db2c <_Watchdog_Report_chain+0x34> <== NOT EXECUTED
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
3000db44: e59f001c ldr r0, [pc, #28] ; 3000db68 <_Watchdog_Report_chain+0x70><== NOT EXECUTED 3000db48: e1a01004 mov r1, r4 <== NOT EXECUTED 3000db4c: ebffe88f bl 30007d90 <printk> <== NOT EXECUTED 3000db50: ea000001 b 3000db5c <_Watchdog_Report_chain+0x64> <== NOT EXECUTED
} else {
printk( "Chain is empty\n" );
3000db54: e59f0010 ldr r0, [pc, #16] ; 3000db6c <_Watchdog_Report_chain+0x74><== NOT EXECUTED 3000db58: ebffe88c bl 30007d90 <printk> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000db5c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
}
_ISR_Enable( level );
}
3000db60: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000c718 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
3000c718: e92d40f0 push {r4, r5, r6, r7, lr}
3000c71c: e1a06000 mov r6, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c720: e10f7000 mrs r7, CPSR 3000c724: e3873080 orr r3, r7, #128 ; 0x80 3000c728: e129f003 msr CPSR_fc, r3
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000c72c: e1a05000 mov r5, r0 3000c730: e4953004 ldr r3, [r5], #4
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000c734: e1530005 cmp r3, r5
3000c738: 0a000018 beq 3000c7a0 <_Watchdog_Tickle+0x88>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
3000c73c: e5932010 ldr r2, [r3, #16]
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000c740: e1a04003 mov r4, r3 3000c744: e3520000 cmp r2, #0
3000c748: 0a000003 beq 3000c75c <_Watchdog_Tickle+0x44>
the_watchdog->delta_interval--;
3000c74c: e2422001 sub r2, r2, #1 3000c750: e5832010 str r2, [r3, #16]
if ( the_watchdog->delta_interval != 0 )
3000c754: e3520000 cmp r2, #0
3000c758: 1a000010 bne 3000c7a0 <_Watchdog_Tickle+0x88>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
3000c75c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c760: ebffffc3 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c764: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
switch( watchdog_state ) {
3000c768: e3500002 cmp r0, #2 <== NOT EXECUTED
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
3000c76c: 05940020 ldreq r0, [r4, #32] <== NOT EXECUTED 3000c770: 05941024 ldreq r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000c774: 01a0e00f moveq lr, pc <== NOT EXECUTED 3000c778: 0594f01c ldreq pc, [r4, #28] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c77c: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000c780: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3000c784: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000c788: e5964000 ldr r4, [r6] <== NOT EXECUTED
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
3000c78c: e1540005 cmp r4, r5 <== NOT EXECUTED 3000c790: 0a000002 beq 3000c7a0 <_Watchdog_Tickle+0x88> <== NOT EXECUTED
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
3000c794: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 3000c798: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c79c: eaffffed b 3000c758 <_Watchdog_Tickle+0x40> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c7a0: e129f007 msr CPSR_fc, r7
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000c7a4: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000c828 <_Workspace_Allocate_or_fatal_error>:
3000c828: e3a02000 mov r2, #0
* _Workspace_Allocate_or_fatal_error
*/
void *_Workspace_Allocate_or_fatal_error(
size_t size
)
{
3000c82c: e1a01000 mov r1, r0
3000c830: e52de004 push {lr} ; (str lr, [sp, #-4]!)
3000c834: e59f0018 ldr r0, [pc, #24] ; 3000c854 <_Workspace_Allocate_or_fatal_error+0x2c>
3000c838: e1a03002 mov r3, r2
3000c83c: eb00079e bl 3000e6bc <_Heap_Allocate_aligned_with_boundary>
__builtin_return_address( 1 ),
memory
);
#endif
if ( memory == NULL )
3000c840: e3500000 cmp r0, #0
3000c844: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
_Internal_error_Occurred(
3000c848: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c84c: e3a02003 mov r2, #3 <== NOT EXECUTED 3000c850: ebfff792 bl 3000a6a0 <_Internal_error_Occurred> <== NOT EXECUTED
3000c7a8 <_Workspace_Handler_initialization>:
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
3000c7a8: e59f3048 ldr r3, [pc, #72] ; 3000c7f8 <_Workspace_Handler_initialization+0x50>
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
3000c7ac: e92d4030 push {r4, r5, lr}
uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start;
3000c7b0: e5935000 ldr r5, [r3]
uintptr_t size = Configuration.work_space_size;
3000c7b4: e5934004 ldr r4, [r3, #4]
if ( Configuration.do_zero_of_workspace )
3000c7b8: e5d33028 ldrb r3, [r3, #40] ; 0x28 3000c7bc: e3530000 cmp r3, #0
memset( starting_address, 0, size );
3000c7c0: 11a00005 movne r0, r5 3000c7c4: 13a01000 movne r1, #0 3000c7c8: 11a02004 movne r2, r4 3000c7cc: 1b0010ff blne 30010bd0 <memset>
memory_available = _Heap_Initialize(
3000c7d0: e59f0024 ldr r0, [pc, #36] ; 3000c7fc <_Workspace_Handler_initialization+0x54> 3000c7d4: e1a01005 mov r1, r5 3000c7d8: e1a02004 mov r2, r4 3000c7dc: e3a03008 mov r3, #8 3000c7e0: ebfff71b bl 3000a454 <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
3000c7e4: e3500000 cmp r0, #0
3000c7e8: 18bd8030 popne {r4, r5, pc}
_Internal_error_Occurred(
3000c7ec: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c7f0: e3a02002 mov r2, #2 <== NOT EXECUTED 3000c7f4: ebfff7a9 bl 3000a6a0 <_Internal_error_Occurred> <== NOT EXECUTED
300091d0 <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300091d0: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300091d4: e3520000 cmp r2, #0 <== NOT EXECUTED
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300091d8: e1a0c001 mov ip, r1 <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300091dc: 059f1028 ldreq r1, [pc, #40] ; 3000920c <__assert_func+0x3c><== NOT EXECUTED 300091e0: 159f1028 ldrne r1, [pc, #40] ; 30009210 <__assert_func+0x40><== NOT EXECUTED 300091e4: 01a02001 moveq r2, r1 <== NOT EXECUTED
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300091e8: e1a0e000 mov lr, r0 <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300091ec: e88d0006 stm sp, {r1, r2} <== NOT EXECUTED
300091f0: e59f001c ldr r0, [pc, #28] ; 30009214 <__assert_func+0x44> <== NOT EXECUTED
300091f4: e1a01003 mov r1, r3 <== NOT EXECUTED
300091f8: e1a0200e mov r2, lr <== NOT EXECUTED
300091fc: e1a0300c mov r3, ip <== NOT EXECUTED
30009200: eb000411 bl 3000a24c <printk> <== NOT EXECUTED
file,
line,
(func) ? ", function: " : "",
(func) ? func : ""
);
rtems_fatal_error_occurred(0);
30009204: e3a00000 mov r0, #0 <== NOT EXECUTED 30009208: eb000fe8 bl 3000d1b0 <rtems_fatal_error_occurred> <== NOT EXECUTED
3001378c <__env_lock>:
3001378c: e12fff1e bx lr <== NOT EXECUTED
30013790 <__env_unlock>:
30013790: e12fff1e bx lr <== NOT EXECUTED
3000697c <__getpid>:
#include <unistd.h>
pid_t __getpid(void)
{
return getpid();
3000697c: eaffffff b 30006980 <getpid> <== NOT EXECUTED
300246d8 <__kill>:
#endif
int __kill( pid_t pid, int sig )
{
return 0;
}
300246d8: e3a00000 mov r0, #0 <== NOT EXECUTED 300246dc: e12fff1e bx lr <== NOT EXECUTED
30007a9c <_chown_helper>:
const char *path,
uid_t owner,
gid_t group,
int follow_link
)
{
30007a9c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30007aa0: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
30007aa4: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30007aa8: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
30007aac: e1a08003 mov r8, r3 <== NOT EXECUTED
30007ab0: e1a05822 lsr r5, r2, #16 <== NOT EXECUTED
30007ab4: e1a07000 mov r7, r0 <== NOT EXECUTED
30007ab8: e1a06821 lsr r6, r1, #16 <== NOT EXECUTED
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, follow_link ) )
30007abc: eb002f69 bl 30013868 <strlen> <== NOT EXECUTED 30007ac0: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30007ac4: e1a01000 mov r1, r0 <== NOT EXECUTED 30007ac8: e3a02000 mov r2, #0 <== NOT EXECUTED 30007acc: e1a00007 mov r0, r7 <== NOT EXECUTED 30007ad0: e1a03004 mov r3, r4 <== NOT EXECUTED 30007ad4: e58d8000 str r8, [sp] <== NOT EXECUTED 30007ad8: eb000030 bl 30007ba0 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 30007adc: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30007ae0: 13e05000 mvnne r5, #0 <== NOT EXECUTED
)
{
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, follow_link ) )
30007ae4: 1a000008 bne 30007b0c <_chown_helper+0x70> <== NOT EXECUTED
return -1;
result = (*loc.ops->chown_h)( &loc, owner, group );
30007ae8: e1a02005 mov r2, r5 <== NOT EXECUTED 30007aec: e1a00004 mov r0, r4 <== NOT EXECUTED 30007af0: e1a01006 mov r1, r6 <== NOT EXECUTED 30007af4: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30007af8: e1a0e00f mov lr, pc <== NOT EXECUTED 30007afc: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED 30007b00: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30007b04: e1a00004 mov r0, r4 <== NOT EXECUTED 30007b08: eb000054 bl 30007c60 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
30007b0c: e1a00005 mov r0, r5 <== NOT EXECUTED
30007b10: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30007b14: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30006d68 <_fcntl_r>:
int fd,
int cmd,
int arg
)
{
return fcntl( fd, cmd, arg );
30006d68: e1a00001 mov r0, r1 <== NOT EXECUTED 30006d6c: e1a01002 mov r1, r2 <== NOT EXECUTED 30006d70: e1a02003 mov r2, r3 <== NOT EXECUTED 30006d74: eaffff8a b 30006ba4 <fcntl> <== NOT EXECUTED
300246b8 <_getpid_r>:
pid_t _getpid_r(
struct _reent *ptr __attribute__((unused))
)
{
return getpid();
}
300246b8: e3a00001 mov r0, #1 <== NOT EXECUTED 300246bc: e12fff1e bx lr <== NOT EXECUTED
300063ac <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
300063ac: eaffffe5 b 30006348 <gettimeofday> <== NOT EXECUTED
300063a0 <_gettimeofday_r>:
struct _reent *ignored_reentrancy_stuff __attribute__((unused)),
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
300063a0: e1a00001 mov r0, r1 <== NOT EXECUTED 300063a4: e1a01002 mov r1, r2 <== NOT EXECUTED 300063a8: eaffffe6 b 30006348 <gettimeofday> <== NOT EXECUTED
300246d0 <_kill_r>:
#include <reent.h>
int _kill_r( struct _reent *ptr, pid_t pid, int sig )
{
return 0;
}
300246d0: e3a00000 mov r0, #0 <== NOT EXECUTED 300246d4: e12fff1e bx lr <== NOT EXECUTED
300098ec <_link_r>:
struct _reent *ptr __attribute__((unused)),
const char *existing,
const char *new
)
{
return link( existing, new );
300098ec: e1a00001 mov r0, r1 <== NOT EXECUTED 300098f0: e1a01002 mov r1, r2 <== NOT EXECUTED 300098f4: eaffffc0 b 300097fc <link> <== NOT EXECUTED
30015ae4 <_lseek_r>:
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
30015ae4: e1a00001 mov r0, r1 <== NOT EXECUTED 30015ae8: e1a01002 mov r1, r2 <== NOT EXECUTED 30015aec: e1a02003 mov r2, r3 <== NOT EXECUTED 30015af0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30015af4: eaffffc1 b 30015a00 <lseek> <== NOT EXECUTED
3000822c <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
3000822c: e1a00001 mov r0, r1 <== NOT EXECUTED 30008230: e1a01002 mov r1, r2 <== NOT EXECUTED 30008234: eaffffd9 b 300081a0 <lstat> <== NOT EXECUTED
30015c34 <_read_r>:
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
30015c34: e1a00001 mov r0, r1 <== NOT EXECUTED 30015c38: e1a01002 mov r1, r2 <== NOT EXECUTED 30015c3c: e1a02003 mov r2, r3 <== NOT EXECUTED 30015c40: eaffffd0 b 30015b88 <read> <== NOT EXECUTED
30015c44 <_realloc_r>:
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
return realloc( ptr, size );
30015c44: e1a00001 mov r0, r1 <== NOT EXECUTED 30015c48: e1a01002 mov r1, r2 <== NOT EXECUTED 30015c4c: ea000011 b 30015c98 <realloc> <== NOT EXECUTED
3000a6a0 <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
3000a6a0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
3000a6a4: e1a00001 mov r0, r1 <== NOT EXECUTED
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
3000a6a8: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED 3000a6ac: e1a04001 mov r4, r1 <== NOT EXECUTED 3000a6b0: e1a06002 mov r6, r2 <== NOT EXECUTED
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
3000a6b4: ebfffaad bl 30009170 <rtems_filesystem_dirname> <== NOT EXECUTED
if ( old_parent_pathlen == 0 )
3000a6b8: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000a6bc: e28d3018 add r3, sp, #24 <== NOT EXECUTED 3000a6c0: 1a000005 bne 3000a6dc <_rename_r+0x3c> <== NOT EXECUTED
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
3000a6c4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a6c8: e28d1044 add r1, sp, #68 ; 0x44 <== NOT EXECUTED 3000a6cc: e1a02003 mov r2, r3 <== NOT EXECUTED 3000a6d0: eb0000dd bl 3000aa4c <rtems_filesystem_get_start_loc> <== NOT EXECUTED
rtems_filesystem_location_info_t old_parent_loc; rtems_filesystem_location_info_t new_parent_loc; int i; int result; const char *name; bool free_old_parentloc = false;
3000a6d4: e1a05007 mov r5, r7 <== NOT EXECUTED 3000a6d8: ea000008 b 3000a700 <_rename_r+0x60> <== NOT EXECUTED
old_parent_pathlen = rtems_filesystem_dirname ( old );
if ( old_parent_pathlen == 0 )
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
3000a6dc: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a6e0: e58d2000 str r2, [sp] <== NOT EXECUTED 3000a6e4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a6e8: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a6ec: e2822002 add r2, r2, #2 <== NOT EXECUTED 3000a6f0: ebfffa8b bl 30009124 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
3000a6f4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a6f8: 1a000054 bne 3000a850 <_rename_r+0x1b0> <== NOT EXECUTED
return -1;
free_old_parentloc = true;
3000a6fc: e3a05001 mov r5, #1 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
3000a700: e28dc02c add ip, sp, #44 ; 0x2c <== NOT EXECUTED
3000a704: e28de018 add lr, sp, #24 <== NOT EXECUTED
3000a708: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
3000a70c: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000a710: e59e3000 ldr r3, [lr] <== NOT EXECUTED
name = old + old_parent_pathlen;
3000a714: e0844007 add r4, r4, r7 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
3000a718: e58c3000 str r3, [ip] <== NOT EXECUTED
name = old + old_parent_pathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000a71c: e1a00004 mov r0, r4 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
3000a720: e58d4040 str r4, [sp, #64] ; 0x40 <== NOT EXECUTED
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000a724: eb003289 bl 30017150 <strlen> <== NOT EXECUTED 3000a728: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a72c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a730: ebfffa9c bl 300091a8 <rtems_filesystem_prefix_separators> <== NOT EXECUTED 3000a734: e0844000 add r4, r4, r0 <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
3000a738: e1a00004 mov r0, r4 <== NOT EXECUTED
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000a73c: e58d4040 str r4, [sp, #64] ; 0x40 <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
3000a740: eb003282 bl 30017150 <strlen> <== NOT EXECUTED 3000a744: e28d802c add r8, sp, #44 ; 0x2c <== NOT EXECUTED 3000a748: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a74c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a750: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a754: e1a03008 mov r3, r8 <== NOT EXECUTED 3000a758: e58d2000 str r2, [sp] <== NOT EXECUTED 3000a75c: ebfffa54 bl 300090b4 <rtems_filesystem_evaluate_relative_path><== NOT EXECUTED
0, &old_loc, false );
if ( result != 0 ) {
3000a760: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a764: 0a000003 beq 3000a778 <_rename_r+0xd8> <== NOT EXECUTED
if ( free_old_parentloc )
3000a768: e3550000 cmp r5, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
3000a76c: 128d0018 addne r0, sp, #24 <== NOT EXECUTED
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
3000a770: 0a000036 beq 3000a850 <_rename_r+0x1b0> <== NOT EXECUTED 3000a774: ea000013 b 3000a7c8 <_rename_r+0x128> <== NOT EXECUTED
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
3000a778: e28d4004 add r4, sp, #4 <== NOT EXECUTED 3000a77c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a780: e28d1044 add r1, sp, #68 ; 0x44 <== NOT EXECUTED 3000a784: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a788: eb0000af bl 3000aa4c <rtems_filesystem_get_start_loc> <== NOT EXECUTED
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
3000a78c: e59d0044 ldr r0, [sp, #68] ; 0x44 <== NOT EXECUTED 3000a790: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a794: e0860000 add r0, r6, r0 <== NOT EXECUTED 3000a798: e28d2040 add r2, sp, #64 ; 0x40 <== NOT EXECUTED 3000a79c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000a7a0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a7a4: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
if ( result != 0 ) {
3000a7a8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a7ac: 0a000007 beq 3000a7d0 <_rename_r+0x130> <== NOT EXECUTED
rtems_filesystem_freenode( &new_parent_loc );
3000a7b0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a7b4: ebfffaff bl 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_old_parentloc )
3000a7b8: e3550000 cmp r5, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
3000a7bc: 128d0018 addne r0, sp, #24 <== NOT EXECUTED 3000a7c0: 1bfffafc blne 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &old_loc );
3000a7c4: e28d002c add r0, sp, #44 ; 0x2c <== NOT EXECUTED 3000a7c8: ebfffafa bl 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED 3000a7cc: ea00001f b 3000a850 <_rename_r+0x1b0> <== NOT EXECUTED
/*
* Check to see if the caller is trying to rename across file system
* boundaries.
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
3000a7d0: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 3000a7d4: e59d2028 ldr r2, [sp, #40] ; 0x28 <== NOT EXECUTED 3000a7d8: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a7dc: 0a00000a beq 3000a80c <_rename_r+0x16c> <== NOT EXECUTED
rtems_filesystem_freenode( &new_parent_loc );
3000a7e0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a7e4: ebfffaf3 bl 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_old_parentloc )
3000a7e8: e3550000 cmp r5, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
3000a7ec: 128d0018 addne r0, sp, #24 <== NOT EXECUTED 3000a7f0: 1bfffaf0 blne 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &old_loc );
3000a7f4: e28d002c add r0, sp, #44 ; 0x2c <== NOT EXECUTED 3000a7f8: ebfffaee bl 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EXDEV );
3000a7fc: eb002588 bl 30013e24 <__errno> <== NOT EXECUTED 3000a800: e3a03012 mov r3, #18 <== NOT EXECUTED 3000a804: e5803000 str r3, [r0] <== NOT EXECUTED 3000a808: ea000010 b 3000a850 <_rename_r+0x1b0> <== NOT EXECUTED
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
3000a80c: e28d6018 add r6, sp, #24 <== NOT EXECUTED 3000a810: e1a01008 mov r1, r8 <== NOT EXECUTED 3000a814: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a818: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED 3000a81c: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED 3000a820: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a824: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a828: e59cf040 ldr pc, [ip, #64] ; 0x40 <== NOT EXECUTED 3000a82c: e1a07000 mov r7, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &new_parent_loc );
3000a830: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a834: ebfffadf bl 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_old_parentloc )
3000a838: e3550000 cmp r5, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
3000a83c: 11a00006 movne r0, r6 <== NOT EXECUTED 3000a840: 1bfffadc blne 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &old_loc );
3000a844: e28d002c add r0, sp, #44 ; 0x2c <== NOT EXECUTED 3000a848: ebfffada bl 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
3000a84c: ea000000 b 3000a854 <_rename_r+0x1b4> <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
return -1;
3000a850: e3e07000 mvn r7, #0 <== NOT EXECUTED
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
return result;
}
3000a854: e1a00007 mov r0, r7 <== NOT EXECUTED
3000a858: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
3000a85c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300071a0 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
300071a0: e1a00001 mov r0, r1 <== NOT EXECUTED 300071a4: e1a01002 mov r1, r2 <== NOT EXECUTED 300071a8: eaffffd8 b 30007110 <stat> <== NOT EXECUTED
30008df4 <_times>:
#endif
clock_t _times(
struct tms *ptms
)
{
30008df4: e92d407f push {r0, r1, r2, r3, r4, r5, r6, lr} <== NOT EXECUTED
rtems_interval ticks;
if ( !ptms )
30008df8: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30008dfc: 1a000004 bne 30008e14 <_times+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
30008e00: eb001dc2 bl 30010510 <__errno> <== NOT EXECUTED 30008e04: e3a0300e mov r3, #14 <== NOT EXECUTED 30008e08: e5803000 str r3, [r0] <== NOT EXECUTED 30008e0c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30008e10: ea000019 b 30008e7c <_times+0x88> <== NOT EXECUTED
/*
* This call does not depend on TOD being initialized and can't fail.
*/
ticks = rtems_clock_get_ticks_since_boot();
30008e14: eb0000e2 bl 300091a4 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
30008e18: e59f3064 ldr r3, [pc, #100] ; 30008e84 <_times+0x90> <== NOT EXECUTED
/*
* This call does not depend on TOD being initialized and can't fail.
*/
ticks = rtems_clock_get_ticks_since_boot();
30008e1c: e1a05000 mov r5, r0 <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
30008e20: e593600c ldr r6, [r3, #12] <== NOT EXECUTED 30008e24: e59f105c ldr r1, [pc, #92] ; 30008e88 <_times+0x94> <== NOT EXECUTED 30008e28: e1a00006 mov r0, r6 <== NOT EXECUTED 30008e2c: eb002b4f bl 30013b70 <__aeabi_uidiv> <== NOT EXECUTED 30008e30: e58d0000 str r0, [sp] <== NOT EXECUTED 30008e34: e3a00ffa mov r0, #1000 ; 0x3e8 <== NOT EXECUTED 30008e38: e59f104c ldr r1, [pc, #76] ; 30008e8c <_times+0x98> <== NOT EXECUTED 30008e3c: e0000096 mul r0, r6, r0 <== NOT EXECUTED 30008e40: eb002be2 bl 30013dd0 <__umodsi3> <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
30008e44: e59f3044 ldr r3, [pc, #68] ; 30008e90 <_times+0x9c> <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
30008e48: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
30008e4c: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 30008e50: e1a0100d mov r1, sp <== NOT EXECUTED 30008e54: e2800084 add r0, r0, #132 ; 0x84 <== NOT EXECUTED 30008e58: e28d3008 add r3, sp, #8 <== NOT EXECUTED 30008e5c: e28d200c add r2, sp, #12 <== NOT EXECUTED 30008e60: eb000d88 bl 3000c488 <_Timespec_Divide> <== NOT EXECUTED
&_Thread_Executing->cpu_time_used,
&per_tick,
&ticks,
&fractional_ticks
);
ptms->tms_utime = ticks;
30008e64: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
}
#else
ptms->tms_utime = _Thread_Executing->cpu_time_used;
#endif
ptms->tms_stime = ticks;
30008e68: e8840028 stm r4, {r3, r5} <== NOT EXECUTED
ptms->tms_cutime = 0;
30008e6c: e3a03000 mov r3, #0 <== NOT EXECUTED 30008e70: e5843008 str r3, [r4, #8] <== NOT EXECUTED
ptms->tms_cstime = 0;
30008e74: e584300c str r3, [r4, #12] <== NOT EXECUTED
return ticks;
30008e78: e1a00005 mov r0, r5 <== NOT EXECUTED
}
30008e7c: e28dd010 add sp, sp, #16 <== NOT EXECUTED
30008e80: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30008e98 <_times_r>:
clock_t _times_r(
struct _reent *ptr __attribute__((unused)),
struct tms *ptms
)
{
return _times( ptms );
30008e98: e1a00001 mov r0, r1 <== NOT EXECUTED 30008e9c: eaffffd4 b 30008df4 <_times> <== NOT EXECUTED
30009ee8 <_unlink_r>:
int _unlink_r(
struct _reent *ptr __attribute__((unused)),
const char *path
)
{
return unlink( path );
30009ee8: e1a00001 mov r0, r1 <== NOT EXECUTED 30009eec: eaffffa9 b 30009d98 <unlink> <== NOT EXECUTED
300081f8 <access>:
int access(
const char *path,
int amode
)
{
300081f8: e92d4010 push {r4, lr} <== NOT EXECUTED
300081fc: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
30008200: e1a04001 mov r4, r1 <== NOT EXECUTED
struct stat statbuf;
if ( stat(path, &statbuf) )
30008204: e1a0100d mov r1, sp <== NOT EXECUTED 30008208: eb0005b3 bl 300098dc <stat> <== NOT EXECUTED 3000820c: e3500000 cmp r0, #0 <== NOT EXECUTED 30008210: 1a000010 bne 30008258 <access+0x60> <== NOT EXECUTED
return -1;
if ( amode & R_OK ) {
30008214: e3140004 tst r4, #4 <== NOT EXECUTED 30008218: 0a000002 beq 30008228 <access+0x30> <== NOT EXECUTED
if (!( statbuf.st_mode & S_IREAD ))
3000821c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30008220: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30008224: 0a00000b beq 30008258 <access+0x60> <== NOT EXECUTED
return -1;
}
if ( amode & W_OK ) {
30008228: e3140002 tst r4, #2 <== NOT EXECUTED 3000822c: 0a000002 beq 3000823c <access+0x44> <== NOT EXECUTED
if ( !( statbuf.st_mode & S_IWRITE ) )
30008230: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30008234: e3130080 tst r3, #128 ; 0x80 <== NOT EXECUTED 30008238: 0a000006 beq 30008258 <access+0x60> <== NOT EXECUTED
return -1;
}
if ( amode & X_OK ) {
3000823c: e2140001 ands r0, r4, #1 <== NOT EXECUTED 30008240: 0a000005 beq 3000825c <access+0x64> <== NOT EXECUTED
if ( !( statbuf.st_mode & S_IEXEC ) )
30008244: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30008248: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED
return -1;
}
return 0;
3000824c: 03e00000 mvneq r0, #0 <== NOT EXECUTED 30008250: 13a00000 movne r0, #0 <== NOT EXECUTED 30008254: ea000000 b 3000825c <access+0x64> <== NOT EXECUTED
return -1;
}
if ( amode & W_OK ) {
if ( !( statbuf.st_mode & S_IWRITE ) )
return -1;
30008258: e3e00000 mvn r0, #0 <== NOT EXECUTED
if ( !( statbuf.st_mode & S_IEXEC ) )
return -1;
}
return 0;
}
3000825c: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
30008260: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300077f4 <cfgetispeed>:
speed_t cfgetispeed(
const struct termios *tp
)
{
return (tp->c_cflag / (CIBAUD / CBAUD)) & CBAUD;
300077f4: e1d030ba ldrh r3, [r0, #10] <== NOT EXECUTED
}
300077f8: e59f0004 ldr r0, [pc, #4] ; 30007804 <cfgetispeed+0x10> <== NOT EXECUTED 300077fc: e0030000 and r0, r3, r0 <== NOT EXECUTED 30007800: e12fff1e bx lr <== NOT EXECUTED
30007808 <cfgetospeed>:
speed_t cfgetospeed(
const struct termios *tp
)
{
return tp->c_cflag & CBAUD;
30007808: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
}
3000780c: e59f0004 ldr r0, [pc, #4] ; 30007818 <cfgetospeed+0x10> <== NOT EXECUTED 30007810: e0030000 and r0, r3, r0 <== NOT EXECUTED 30007814: e12fff1e bx lr <== NOT EXECUTED
3000781c <cfsetispeed>:
int cfsetispeed(
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
3000781c: e3c13a01 bic r3, r1, #4096 ; 0x1000 <== NOT EXECUTED 30007820: e3d3300f bics r3, r3, #15 <== NOT EXECUTED
int cfsetispeed(
struct termios *tp,
speed_t speed
)
{
30007824: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( speed & ~CBAUD )
30007828: 0a000004 beq 30007840 <cfsetispeed+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000782c: eb002a25 bl 300120c8 <__errno> <== NOT EXECUTED
30007830: e3a03016 mov r3, #22 <== NOT EXECUTED
30007834: e5803000 str r3, [r0] <== NOT EXECUTED
30007838: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000783c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
tp->c_cflag = (tp->c_cflag & ~CIBAUD) | (speed * (CIBAUD / CBAUD));
30007840: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED 30007844: e3c22201 bic r2, r2, #268435456 ; 0x10000000 <== NOT EXECUTED 30007848: e3c2280f bic r2, r2, #983040 ; 0xf0000 <== NOT EXECUTED 3000784c: e1821801 orr r1, r2, r1, lsl #16 <== NOT EXECUTED 30007850: e5801008 str r1, [r0, #8] <== NOT EXECUTED
return 0;
30007854: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30007858: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000785c <cfsetospeed>:
int cfsetospeed(
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
3000785c: e3c13a01 bic r3, r1, #4096 ; 0x1000 <== NOT EXECUTED 30007860: e3d3300f bics r3, r3, #15 <== NOT EXECUTED
int cfsetospeed(
struct termios *tp,
speed_t speed
)
{
30007864: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( speed & ~CBAUD )
30007868: 0a000004 beq 30007880 <cfsetospeed+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000786c: eb002a15 bl 300120c8 <__errno> <== NOT EXECUTED
30007870: e3a03016 mov r3, #22 <== NOT EXECUTED
30007874: e5803000 str r3, [r0] <== NOT EXECUTED
30007878: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000787c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
30007880: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED 30007884: e3c22a01 bic r2, r2, #4096 ; 0x1000 <== NOT EXECUTED 30007888: e3c2200f bic r2, r2, #15 <== NOT EXECUTED 3000788c: e1811002 orr r1, r1, r2 <== NOT EXECUTED 30007890: e5801008 str r1, [r0, #8] <== NOT EXECUTED
return 0;
30007894: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30007898: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007a30 <chmod>:
int chmod(
const char *path,
mode_t mode
)
{
30007a30: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30007a34: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30007a38: e1a05001 mov r5, r1 <== NOT EXECUTED
30007a3c: e1a06000 mov r6, r0 <== NOT EXECUTED
int status;
rtems_filesystem_location_info_t loc;
int result;
status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
30007a40: eb002f88 bl 30013868 <strlen> <== NOT EXECUTED 30007a44: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30007a48: e3a03001 mov r3, #1 <== NOT EXECUTED 30007a4c: e1a01000 mov r1, r0 <== NOT EXECUTED 30007a50: e58d3000 str r3, [sp] <== NOT EXECUTED 30007a54: e1a00006 mov r0, r6 <== NOT EXECUTED 30007a58: e3a02000 mov r2, #0 <== NOT EXECUTED 30007a5c: e1a03004 mov r3, r4 <== NOT EXECUTED 30007a60: eb00004e bl 30007ba0 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
if ( status != 0 )
30007a64: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30007a68: 13e05000 mvnne r5, #0 <== NOT EXECUTED
int status;
rtems_filesystem_location_info_t loc;
int result;
status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
if ( status != 0 )
30007a6c: 1a000007 bne 30007a90 <chmod+0x60> <== NOT EXECUTED
return -1;
result = (*loc.handlers->fchmod_h)( &loc, mode );
30007a70: e1a01005 mov r1, r5 <== NOT EXECUTED 30007a74: e1a00004 mov r0, r4 <== NOT EXECUTED 30007a78: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30007a7c: e1a0e00f mov lr, pc <== NOT EXECUTED 30007a80: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED 30007a84: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30007a88: e1a00004 mov r0, r4 <== NOT EXECUTED 30007a8c: eb000073 bl 30007c60 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
30007a90: e1a00005 mov r0, r5 <== NOT EXECUTED
30007a94: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30007a98: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30007b18 <chown>:
int chown(
const char *path,
uid_t owner,
gid_t group
)
{
30007b18: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 30007b1c: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
return _chown_helper( path, owner, group, true );
30007b20: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 30007b24: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED 30007b28: e3a03001 mov r3, #1 <== NOT EXECUTED 30007b2c: eaffffda b 30007a9c <_chown_helper> <== NOT EXECUTED
30005c84 <devFS_Show>:
{
int i;
rtems_filesystem_location_info_t *temp_loc;
rtems_device_name_t *device_name_table;
temp_loc = &rtems_filesystem_root;
30005c84: e59f3060 ldr r3, [pc, #96] ; 30005cec <devFS_Show+0x68> <== NOT EXECUTED
#include <rtems/seterr.h>
#include "devfs.h"
int devFS_Show(void)
{
30005c88: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int i;
rtems_filesystem_location_info_t *temp_loc;
rtems_device_name_t *device_name_table;
temp_loc = &rtems_filesystem_root;
30005c8c: e5933000 ldr r3, [r3] <== NOT EXECUTED
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
30005c90: e5934018 ldr r4, [r3, #24] <== NOT EXECUTED
if (!device_name_table)
30005c94: e3540000 cmp r4, #0 <== NOT EXECUTED 30005c98: 13a05000 movne r5, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++){
30005c9c: 159f604c ldrne r6, [pc, #76] ; 30005cf0 <devFS_Show+0x6c> <== NOT EXECUTED
rtems_filesystem_location_info_t *temp_loc;
rtems_device_name_t *device_name_table;
temp_loc = &rtems_filesystem_root;
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
if (!device_name_table)
30005ca0: 1a00000c bne 30005cd8 <devFS_Show+0x54> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
30005ca4: eb002205 bl 3000e4c0 <__errno> <== NOT EXECUTED
30005ca8: e3a0300e mov r3, #14 <== NOT EXECUTED
30005cac: e5803000 str r3, [r0] <== NOT EXECUTED
30005cb0: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005cb4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
for (i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name){
30005cb8: e5941000 ldr r1, [r4] <== NOT EXECUTED 30005cbc: e3510000 cmp r1, #0 <== NOT EXECUTED
printk("/%s %d %d\n", device_name_table[i].device_name,
30005cc0: 159f002c ldrne r0, [pc, #44] ; 30005cf4 <devFS_Show+0x70> <== NOT EXECUTED 30005cc4: 15942008 ldrne r2, [r4, #8] <== NOT EXECUTED 30005cc8: 1594300c ldrne r3, [r4, #12] <== NOT EXECUTED 30005ccc: 1b000466 blne 30006e6c <printk> <== NOT EXECUTED
temp_loc = &rtems_filesystem_root;
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++){
30005cd0: e2855001 add r5, r5, #1 <== NOT EXECUTED 30005cd4: e2844014 add r4, r4, #20 <== NOT EXECUTED 30005cd8: e5963000 ldr r3, [r6] <== NOT EXECUTED 30005cdc: e1550003 cmp r5, r3 <== NOT EXECUTED 30005ce0: 3afffff4 bcc 30005cb8 <devFS_Show+0x34> <== NOT EXECUTED
if (device_name_table[i].device_name){
printk("/%s %d %d\n", device_name_table[i].device_name,
device_name_table[i].major, device_name_table[i].minor);
}
}
return 0;
30005ce4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30005ce8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000e640 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3000e640: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
3000e644: e3d27007 bics r7, r2, #7
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3000e648: e1a09000 mov r9, r0 3000e64c: e1a04001 mov r4, r1 3000e650: e1a05003 mov r5, r3
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
3000e654: 0a000002 beq 3000e664 <devFS_evaluate_path+0x24>
rtems_set_errno_and_return_minus_one( EPERM );
3000e658: eb000622 bl 3000fee8 <__errno> <== NOT EXECUTED 3000e65c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000e660: ea000005 b 3000e67c <devFS_evaluate_path+0x3c> <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
3000e664: e5936000 ldr r6, [r3]
if (!device_name_table)
3000e668: e3560000 cmp r6, #0
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
3000e66c: 159fa094 ldrne sl, [pc, #148] ; 3000e708 <devFS_evaluate_path+0xc8>
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
3000e670: 1a00001c bne 3000e6e8 <devFS_evaluate_path+0xa8>
rtems_set_errno_and_return_minus_one( EFAULT );
3000e674: eb00061b bl 3000fee8 <__errno> <== NOT EXECUTED
3000e678: e3a0300e mov r3, #14 <== NOT EXECUTED
3000e67c: e5803000 str r3, [r0] <== NOT EXECUTED
3000e680: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000e684: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
3000e688: e5968000 ldr r8, [r6] 3000e68c: e3580000 cmp r8, #0
3000e690: 0a000012 beq 3000e6e0 <devFS_evaluate_path+0xa0>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
3000e694: e1a00009 mov r0, r9 3000e698: e1a01008 mov r1, r8 3000e69c: e1a02004 mov r2, r4 3000e6a0: eb000b6f bl 30011464 <strncmp> 3000e6a4: e3500000 cmp r0, #0
3000e6a8: 1a00000c bne 3000e6e0 <devFS_evaluate_path+0xa0>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
3000e6ac: e7d80004 ldrb r0, [r8, r4] 3000e6b0: e3500000 cmp r0, #0
3000e6b4: 1a000009 bne 3000e6e0 <devFS_evaluate_path+0xa0>
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
3000e6b8: e59f304c ldr r3, [pc, #76] ; 3000e70c <devFS_evaluate_path+0xcc>
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
3000e6bc: e5856000 str r6, [r5]
pathloc->handlers = &devFS_file_handlers;
3000e6c0: e5853008 str r3, [r5, #8]
pathloc->ops = &devFS_ops;
3000e6c4: e59f3044 ldr r3, [pc, #68] ; 3000e710 <devFS_evaluate_path+0xd0> 3000e6c8: e585300c str r3, [r5, #12]
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000e6cc: e59f3040 ldr r3, [pc, #64] ; 3000e714 <devFS_evaluate_path+0xd4> 3000e6d0: e5933000 ldr r3, [r3] 3000e6d4: e5933028 ldr r3, [r3, #40] ; 0x28 3000e6d8: e5853010 str r3, [r5, #16]
return 0;
3000e6dc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
3000e6e0: e2877001 add r7, r7, #1 3000e6e4: e2866014 add r6, r6, #20 3000e6e8: e59a3000 ldr r3, [sl] 3000e6ec: e1570003 cmp r7, r3
3000e6f0: 3affffe4 bcc 3000e688 <devFS_evaluate_path+0x48>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
3000e6f4: eb0005fb bl 3000fee8 <__errno> 3000e6f8: e3a03002 mov r3, #2 3000e6fc: e5803000 str r3, [r0] 3000e700: e3e00000 mvn r0, #0
}
3000e704: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
30007578 <devFS_initialize>:
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
30007578: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_device_name_t *device_name_table;
/* allocate device only filesystem name table */
device_name_table = (rtems_device_name_t *)_Workspace_Allocate(
3000757c: e59f7058 ldr r7, [pc, #88] ; 300075dc <devFS_initialize+0x64>
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
30007580: e1a04000 mov r4, r0
rtems_device_name_t *device_name_table;
/* allocate device only filesystem name table */
device_name_table = (rtems_device_name_t *)_Workspace_Allocate(
30007584: e5970000 ldr r0, [r7] 30007588: e3a06014 mov r6, #20 3000758c: e0000096 mul r0, r6, r0 30007590: eb001aac bl 3000e048 <_Workspace_Allocate>
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* no memory for device filesystem */
if (!device_name_table)
30007594: e2505000 subs r5, r0, #0
30007598: 1a000004 bne 300075b0 <devFS_initialize+0x38>
rtems_set_errno_and_return_minus_one( ENOMEM );
3000759c: eb002251 bl 3000fee8 <__errno> <== NOT EXECUTED
300075a0: e3a0300c mov r3, #12 <== NOT EXECUTED
300075a4: e5803000 str r3, [r0] <== NOT EXECUTED
300075a8: e3e00000 mvn r0, #0 <== NOT EXECUTED
300075ac: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
memset(
300075b0: e5972000 ldr r2, [r7] 300075b4: e3a01000 mov r1, #0 300075b8: e0020296 mul r2, r6, r2 300075bc: eb002686 bl 30010fdc <memset>
device_name_table, 0,
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* set file handlers */
temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers;
300075c0: e59f3018 ldr r3, [pc, #24] ; 300075e0 <devFS_initialize+0x68>
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
/* Set the node_access to device name table */
temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table;
300075c4: e584501c str r5, [r4, #28]
device_name_table, 0,
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* set file handlers */
temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers;
300075c8: e5843024 str r3, [r4, #36] ; 0x24
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
300075cc: e2833038 add r3, r3, #56 ; 0x38 300075d0: e5843028 str r3, [r4, #40] ; 0x28
/* Set the node_access to device name table */
temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table;
return 0;
300075d4: e3a00000 mov r0, #0
}
300075d8: e8bd80f0 pop {r4, r5, r6, r7, pc}
300075e4 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
300075e4: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
300075e8: e58d2000 str r2, [sp]
300075ec: e1a09003 mov r9, r3
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
300075f0: e5d03000 ldrb r3, [r0]
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
300075f4: e1a04000 mov r4, r0
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
300075f8: e3530064 cmp r3, #100 ; 0x64
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
300075fc: e1a05001 mov r5, r1
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
30007600: 1a000008 bne 30007628 <devFS_mknod+0x44>
30007604: e5d03001 ldrb r3, [r0, #1] 30007608: e3530065 cmp r3, #101 ; 0x65
3000760c: 1a000005 bne 30007628 <devFS_mknod+0x44>
30007610: e5d03002 ldrb r3, [r0, #2] 30007614: e3530076 cmp r3, #118 ; 0x76
30007618: 1a000002 bne 30007628 <devFS_mknod+0x44>
(path[2] == 'v') && (path[3] == '\0'))
3000761c: e5d00003 ldrb r0, [r0, #3] 30007620: e3500000 cmp r0, #0
30007624: 0a000039 beq 30007710 <devFS_mknod+0x12c>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
30007628: e205aa0f and sl, r5, #61440 ; 0xf000 3000762c: e35a0a02 cmp sl, #8192 ; 0x2000 30007630: 135a0a06 cmpne sl, #24576 ; 0x6000 30007634: 03a0a000 moveq sl, #0 30007638: 13a0a001 movne sl, #1
3000763c: 0a000002 beq 3000764c <devFS_mknod+0x68>
rtems_set_errno_and_return_minus_one( EINVAL );
30007640: eb002228 bl 3000fee8 <__errno> <== NOT EXECUTED 30007644: e3a03016 mov r3, #22 <== NOT EXECUTED 30007648: ea000008 b 30007670 <devFS_mknod+0x8c> <== NOT EXECUTED
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
3000764c: e59d3028 ldr r3, [sp, #40] ; 0x28 30007650: e5936000 ldr r6, [r3]
if (!device_name_table)
30007654: e3560000 cmp r6, #0 30007658: 13e07000 mvnne r7, #0 3000765c: 11a0800a movne r8, sl
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
30007660: 159fb0ac ldrne fp, [pc, #172] ; 30007714 <devFS_mknod+0x130>
30007664: 1a000011 bne 300076b0 <devFS_mknod+0xcc>
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
30007668: eb00221e bl 3000fee8 <__errno> <== NOT EXECUTED 3000766c: e3a0300e mov r3, #14 <== NOT EXECUTED 30007670: e5803000 str r3, [r0] <== NOT EXECUTED 30007674: e3e00000 mvn r0, #0 <== NOT EXECUTED 30007678: ea000024 b 30007710 <devFS_mknod+0x12c> <== NOT EXECUTED
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
3000767c: e796100a ldr r1, [r6, sl] 30007680: e3510000 cmp r1, #0
30007684: 0a000006 beq 300076a4 <devFS_mknod+0xc0>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
30007688: e1a00004 mov r0, r4 3000768c: eb0026d0 bl 300111d4 <strcmp> 30007690: e3500000 cmp r0, #0
30007694: 1a000003 bne 300076a8 <devFS_mknod+0xc4>
rtems_set_errno_and_return_minus_one( EEXIST );
30007698: eb002212 bl 3000fee8 <__errno> <== NOT EXECUTED 3000769c: e3a03011 mov r3, #17 <== NOT EXECUTED 300076a0: eafffff2 b 30007670 <devFS_mknod+0x8c> <== NOT EXECUTED
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
300076a4: e1a07008 mov r7, r8
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
300076a8: e2888001 add r8, r8, #1 300076ac: e28aa014 add sl, sl, #20 300076b0: e59b3000 ldr r3, [fp] 300076b4: e1580003 cmp r8, r3
300076b8: 3affffef bcc 3000767c <devFS_mknod+0x98>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
300076bc: e3770001 cmn r7, #1
300076c0: 1a000004 bne 300076d8 <devFS_mknod+0xf4>
rtems_set_errno_and_return_minus_one( ENOMEM );
300076c4: eb002207 bl 3000fee8 <__errno> <== NOT EXECUTED 300076c8: e3a0300c mov r3, #12 <== NOT EXECUTED 300076cc: e5803000 str r3, [r0] <== NOT EXECUTED 300076d0: e1a00007 mov r0, r7 <== NOT EXECUTED 300076d4: ea00000d b 30007710 <devFS_mknod+0x12c> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300076d8: e10fa000 mrs sl, CPSR 300076dc: e38a3080 orr r3, sl, #128 ; 0x80 300076e0: e129f003 msr CPSR_fc, r3
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
300076e4: e3a03014 mov r3, #20 300076e8: e0070793 mul r7, r3, r7
device_name_table[slot].device_name_length = strlen(path);
300076ec: e1a00004 mov r0, r4
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
300076f0: e7864007 str r4, [r6, r7]
device_name_table[slot].device_name_length = strlen(path);
300076f4: eb002742 bl 30011404 <strlen>
device_name_table[slot].major = major;
300076f8: e59d3000 ldr r3, [sp]
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
300076fc: e0868007 add r8, r6, r7
device_name_table[slot].device_name_length = strlen(path);
30007700: e9880209 stmib r8, {r0, r3, r9}
device_name_table[slot].major = major; device_name_table[slot].minor = minor; device_name_table[slot].mode = mode;
30007704: e5885010 str r5, [r8, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007708: e129f00a msr CPSR_fc, sl
_ISR_Enable(level);
return 0;
3000770c: e3a00000 mov r0, #0
}
30007710: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000777c <devFS_read>:
ssize_t devFS_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
3000777c: e92d487f push {r0, r1, r2, r3, r4, r5, r6, fp, lr} <== NOT EXECUTED
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
30007780: e280c00c add ip, r0, #12 <== NOT EXECUTED
30007784: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
args.buffer = buffer; args.count = count;
30007788: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags;
3000778c: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED
{
rtems_libio_rw_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
30007790: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
30007794: e58d2014 str r2, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
30007798: e3a02000 mov r2, #0 <== NOT EXECUTED
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
3000779c: e58d0000 str r0, [sp] <== NOT EXECUTED
args.offset = iop->offset; args.buffer = buffer;
300077a0: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
300077a4: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
status = rtems_io_read(
300077a8: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 300077ac: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 300077b0: e1a0200d mov r2, sp <== NOT EXECUTED
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
300077b4: e98d1800 stmib sp, {fp, ip} <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
300077b8: eb000f33 bl 3000b48c <rtems_io_read> <== NOT EXECUTED
np->major,
np->minor,
(void *) &args
);
if ( status )
300077bc: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
300077c0: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
300077c4: 1b001bd6 blne 3000e724 <rtems_deviceio_errno> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
300077c8: e28dd01c add sp, sp, #28 <== NOT EXECUTED
300077cc: e8bd8800 pop {fp, pc} <== NOT EXECUTED
3000fa28 <device_ftruncate>:
rtems_libio_t *iop,
rtems_off64_t length
)
{
return 0;
}
3000fa28: e3a00000 mov r0, #0 <== NOT EXECUTED 3000fa2c: e12fff1e bx lr <== NOT EXECUTED
3000fa1c <device_lseek>:
rtems_off64_t offset,
int whence
)
{
return offset;
}
3000fa1c: e1a00001 mov r0, r1 <== NOT EXECUTED 3000fa20: e1a01002 mov r1, r2 <== NOT EXECUTED 3000fa24: e12fff1e bx lr <== NOT EXECUTED
3000f944 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
3000f944: e92d487f push {r0, r1, r2, r3, r4, r5, r6, fp, lr} <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
3000f948: e280c00c add ip, r0, #12 <== NOT EXECUTED
3000f94c: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
args.buffer = buffer; args.count = count;
3000f950: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags;
3000f954: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED
{
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
3000f958: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
3000f95c: e58d2014 str r2, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
3000f960: e3a02000 mov r2, #0 <== NOT EXECUTED
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
3000f964: e58d0000 str r0, [sp] <== NOT EXECUTED
args.offset = iop->offset; args.buffer = buffer;
3000f968: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
3000f96c: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
status = rtems_io_read(
3000f970: e5930050 ldr r0, [r3, #80] ; 0x50 <== NOT EXECUTED 3000f974: e5931054 ldr r1, [r3, #84] ; 0x54 <== NOT EXECUTED 3000f978: e1a0200d mov r2, sp <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
3000f97c: e98d1800 stmib sp, {fp, ip} <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
3000f980: eb0001b4 bl 30010058 <rtems_io_read> <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
3000f984: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
3000f988: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
3000f98c: 1b000219 blne 300101f8 <rtems_deviceio_errno> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
3000f990: e28dd01c add sp, sp, #28 <== NOT EXECUTED
3000f994: e8bd8800 pop {fp, pc} <== NOT EXECUTED
30007134 <drainOutput>:
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30007134: e59030b4 ldr r3, [r0, #180] ; 0xb4
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
30007138: e92d4030 push {r4, r5, lr}
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
3000713c: e3530000 cmp r3, #0
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
30007140: e1a04000 mov r4, r0
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30007144: 08bd8030 popeq {r4, r5, pc}
rtems_interrupt_disable (level);
30007148: ebfffff5 bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
3000714c: e3a05002 mov r5, #2 <== NOT EXECUTED
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
30007150: ea000008 b 30007178 <drainOutput+0x44> <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
30007154: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007158: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
3000715c: e3a01000 mov r1, #0 <== NOT EXECUTED 30007160: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED 30007164: e1a02001 mov r2, r1 <== NOT EXECUTED 30007168: eb0008cc bl 300094a0 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3000716c: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
30007170: 1b000a64 blne 30009b08 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
30007174: ebffffea bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
30007178: e5942084 ldr r2, [r4, #132] ; 0x84 <== NOT EXECUTED
3000717c: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
30007180: e1520003 cmp r2, r3 <== NOT EXECUTED
30007184: 1afffff2 bne 30007154 <drainOutput+0x20> <== NOT EXECUTED
30007188: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
3000718c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30006a68 <dup>:
int dup(
int fildes
)
{
return fcntl( fildes, F_DUPFD, 0 );
30006a68: e3a01000 mov r1, #0 <== NOT EXECUTED 30006a6c: e1a02001 mov r2, r1 <== NOT EXECUTED 30006a70: ea00004b b 30006ba4 <fcntl> <== NOT EXECUTED
30006a1c <dup2>:
int dup2(
int fildes,
int fildes2
)
{
30006a1c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30006a20: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
30006a24: e1a04001 mov r4, r1 <== NOT EXECUTED
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
30006a28: e1a0100d mov r1, sp <== NOT EXECUTED
int dup2(
int fildes,
int fildes2
)
{
30006a2c: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
30006a30: eb00015f bl 30006fb4 <fstat> <== NOT EXECUTED
if ( status == -1 )
30006a34: e3700001 cmn r0, #1 <== NOT EXECUTED
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
30006a38: e1a0500d mov r5, sp <== NOT EXECUTED
if ( status == -1 )
30006a3c: 0a000007 beq 30006a60 <dup2+0x44> <== NOT EXECUTED
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
30006a40: e1a00004 mov r0, r4 <== NOT EXECUTED 30006a44: e1a0100d mov r1, sp <== NOT EXECUTED 30006a48: eb000159 bl 30006fb4 <fstat> <== NOT EXECUTED
if ( status == -1 )
30006a4c: e3700001 cmn r0, #1 <== NOT EXECUTED
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
30006a50: 11a00006 movne r0, r6 <== NOT EXECUTED 30006a54: 13a01000 movne r1, #0 <== NOT EXECUTED 30006a58: 11a02004 movne r2, r4 <== NOT EXECUTED 30006a5c: 1b000050 blne 30006ba4 <fcntl> <== NOT EXECUTED
}
30006a60: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
30006a64: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30007d88 <echo>:
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
30007d88: e591303c ldr r3, [r1, #60] ; 0x3c <== NOT EXECUTED
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
30007d8c: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) &&
30007d90: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
30007d94: e1a04001 mov r4, r1 <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) &&
30007d98: 0a000019 beq 30007e04 <echo+0x7c> <== NOT EXECUTED
iscntrl(c) && (c != '\t') && (c != '\n')) {
30007d9c: e59f306c ldr r3, [pc, #108] ; 30007e10 <echo+0x88> <== NOT EXECUTED 30007da0: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007da4: e0833000 add r3, r3, r0 <== NOT EXECUTED 30007da8: e5d33001 ldrb r3, [r3, #1] <== NOT EXECUTED
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
30007dac: e3130020 tst r3, #32 <== NOT EXECUTED 30007db0: 03a03000 moveq r3, #0 <== NOT EXECUTED 30007db4: 13a03001 movne r3, #1 <== NOT EXECUTED
iscntrl(c) && (c != '\t') && (c != '\n')) {
30007db8: e3500009 cmp r0, #9 <== NOT EXECUTED 30007dbc: 03a03000 moveq r3, #0 <== NOT EXECUTED 30007dc0: 12033001 andne r3, r3, #1 <== NOT EXECUTED 30007dc4: e3530000 cmp r3, #0 <== NOT EXECUTED 30007dc8: 0a00000d beq 30007e04 <echo+0x7c> <== NOT EXECUTED 30007dcc: e350000a cmp r0, #10 <== NOT EXECUTED 30007dd0: 0a00000b beq 30007e04 <echo+0x7c> <== NOT EXECUTED
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
30007dd4: e2200040 eor r0, r0, #64 ; 0x40 <== NOT EXECUTED
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
30007dd8: e3a0305e mov r3, #94 ; 0x5e <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
30007ddc: e5cd0001 strb r0, [sp, #1] <== NOT EXECUTED
rtems_termios_puts (echobuf, 2, tty);
30007de0: e3a01002 mov r1, #2 <== NOT EXECUTED 30007de4: e1a0000d mov r0, sp <== NOT EXECUTED 30007de8: e1a02004 mov r2, r4 <== NOT EXECUTED
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
30007dec: e5cd3000 strb r3, [sp] <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
30007df0: ebffff50 bl 30007b38 <rtems_termios_puts> <== NOT EXECUTED
tty->column += 2;
30007df4: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30007df8: e2833002 add r3, r3, #2 <== NOT EXECUTED 30007dfc: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
30007e00: ea000001 b 30007e0c <echo+0x84> <== NOT EXECUTED
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
30007e04: e1a01004 mov r1, r4 <== NOT EXECUTED 30007e08: ebffff8a bl 30007c38 <oproc> <== NOT EXECUTED
} }
30007e0c: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
300072bc <endgrent>:
void endgrent(void)
{
if (group_fp != NULL)
300072bc: e59f300c ldr r3, [pc, #12] ; 300072d0 <endgrent+0x14> <== NOT EXECUTED 300072c0: e59301c4 ldr r0, [r3, #452] ; 0x1c4 <== NOT EXECUTED 300072c4: e3500000 cmp r0, #0 <== NOT EXECUTED 300072c8: 012fff1e bxeq lr <== NOT EXECUTED
fclose(group_fp);
300072cc: ea0027f0 b 30011294 <fclose> <== NOT EXECUTED
3000716c <endpwent>:
void endpwent(void)
{
if (passwd_fp != NULL)
3000716c: e59f300c ldr r3, [pc, #12] ; 30007180 <endpwent+0x14> <== NOT EXECUTED 30007170: e59300e8 ldr r0, [r3, #232] ; 0xe8 <== NOT EXECUTED 30007174: e3500000 cmp r0, #0 <== NOT EXECUTED 30007178: 012fff1e bxeq lr <== NOT EXECUTED
fclose(passwd_fp);
3000717c: ea002844 b 30011294 <fclose> <== NOT EXECUTED
30007e14 <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)
30007e14: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
30007e18: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
if (tty->ccount == 0)
30007e1c: e3530000 cmp r3, #0 <== NOT EXECUTED
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
30007e20: e1a04000 mov r4, r0 <== NOT EXECUTED 30007e24: e1a07001 mov r7, r1 <== NOT EXECUTED
if (tty->ccount == 0)
30007e28: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return;
if (lineFlag) {
30007e2c: e3510000 cmp r1, #0 <== NOT EXECUTED 30007e30: 0a000060 beq 30007fb8 <erase+0x1a4> <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
30007e34: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED 30007e38: e2132008 ands r2, r3, #8 <== NOT EXECUTED
tty->ccount = 0;
30007e3c: 05802020 streq r2, [r0, #32] <== NOT EXECUTED
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
30007e40: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
30007e44: e2133010 ands r3, r3, #16 <== NOT EXECUTED 30007e48: 1a00005a bne 30007fb8 <erase+0x1a4> <== NOT EXECUTED
tty->ccount = 0;
30007e4c: e5803020 str r3, [r0, #32] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
30007e50: e1a01004 mov r1, r4 <== NOT EXECUTED 30007e54: e5d00044 ldrb r0, [r0, #68] ; 0x44 <== NOT EXECUTED 30007e58: ebffffca bl 30007d88 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
30007e5c: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 30007e60: e3130020 tst r3, #32 <== NOT EXECUTED
echo ('\n', tty);
30007e64: 13a0000a movne r0, #10 <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
30007e68: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30007e6c: ea00000b b 30007ea0 <erase+0x8c> <== NOT EXECUTED
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
30007e70: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
30007e74: e2411001 sub r1, r1, #1 <== NOT EXECUTED 30007e78: e594001c ldr r0, [r4, #28] <== NOT EXECUTED 30007e7c: e5841020 str r1, [r4, #32] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
30007e80: e3130008 tst r3, #8 <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
30007e84: e7d05001 ldrb r5, [r0, r1] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
30007e88: 0a000047 beq 30007fac <erase+0x198> <== NOT EXECUTED
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
30007e8c: e3570000 cmp r7, #0 <== NOT EXECUTED 30007e90: 1a000005 bne 30007eac <erase+0x98> <== NOT EXECUTED 30007e94: e3130010 tst r3, #16 <== NOT EXECUTED 30007e98: 1a000003 bne 30007eac <erase+0x98> <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
30007e9c: e5d40043 ldrb r0, [r4, #67] ; 0x43 <== NOT EXECUTED 30007ea0: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
30007ea4: e8bd41f0 pop {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
30007ea8: eaffffb6 b 30007d88 <echo> <== NOT EXECUTED
} else if (c == '\t') {
30007eac: e3550009 cmp r5, #9 <== NOT EXECUTED 30007eb0: 1a00001f bne 30007f34 <erase+0x120> <== NOT EXECUTED
int col = tty->read_start_column;
30007eb4: e594502c ldr r5, [r4, #44] ; 0x2c <== NOT EXECUTED
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
30007eb8: e5968000 ldr r8, [r6] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
int col = tty->read_start_column;
int i = 0;
30007ebc: e3a02000 mov r2, #0 <== NOT EXECUTED
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)
30007ec0: e2033c02 and r3, r3, #512 ; 0x200 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
30007ec4: ea00000c b 30007efc <erase+0xe8> <== NOT EXECUTED
c = tty->cbuf[i++];
30007ec8: e7d0c002 ldrb ip, [r0, r2] <== NOT EXECUTED 30007ecc: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (c == '\t') {
30007ed0: e35c0009 cmp ip, #9 <== NOT EXECUTED
col = (col | 7) + 1;
30007ed4: 03855007 orreq r5, r5, #7 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
30007ed8: 0a000006 beq 30007ef8 <erase+0xe4> <== NOT EXECUTED
col = (col | 7) + 1;
} else if (iscntrl (c)) {
30007edc: e088c00c add ip, r8, ip <== NOT EXECUTED 30007ee0: e5dcc001 ldrb ip, [ip, #1] <== NOT EXECUTED 30007ee4: e31c0020 tst ip, #32 <== NOT EXECUTED 30007ee8: 0a000002 beq 30007ef8 <erase+0xe4> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
30007eec: e3530000 cmp r3, #0 <== NOT EXECUTED
col += 2;
30007ef0: 12855002 addne r5, r5, #2 <== NOT EXECUTED 30007ef4: ea000000 b 30007efc <erase+0xe8> <== NOT EXECUTED
} else {
col++;
30007ef8: e2855001 add r5, r5, #1 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
30007efc: e1520001 cmp r2, r1 <== NOT EXECUTED 30007f00: 1afffff0 bne 30007ec8 <erase+0xb4> <== NOT EXECUTED 30007f04: ea000006 b 30007f24 <erase+0x110> <== NOT EXECUTED
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
30007f08: e59f00bc ldr r0, [pc, #188] ; 30007fcc <erase+0x1b8> <== NOT EXECUTED 30007f0c: e3a01001 mov r1, #1 <== NOT EXECUTED 30007f10: e1a02004 mov r2, r4 <== NOT EXECUTED 30007f14: ebffff07 bl 30007b38 <rtems_termios_puts> <== NOT EXECUTED
tty->column--;
30007f18: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30007f1c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30007f20: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
30007f24: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30007f28: e1530005 cmp r3, r5 <== NOT EXECUTED 30007f2c: cafffff5 bgt 30007f08 <erase+0xf4> <== NOT EXECUTED 30007f30: ea00001d b 30007fac <erase+0x198> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
30007f34: e5962000 ldr r2, [r6] <== NOT EXECUTED 30007f38: e2855001 add r5, r5, #1 <== NOT EXECUTED 30007f3c: e7d22005 ldrb r2, [r2, r5] <== NOT EXECUTED 30007f40: e3120020 tst r2, #32 <== NOT EXECUTED 30007f44: 0a000009 beq 30007f70 <erase+0x15c> <== NOT EXECUTED 30007f48: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED 30007f4c: 0a000007 beq 30007f70 <erase+0x15c> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
30007f50: e59f0078 ldr r0, [pc, #120] ; 30007fd0 <erase+0x1bc> <== NOT EXECUTED 30007f54: e3a01003 mov r1, #3 <== NOT EXECUTED 30007f58: e1a02004 mov r2, r4 <== NOT EXECUTED 30007f5c: ebfffef5 bl 30007b38 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
30007f60: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30007f64: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
30007f68: 12433001 subne r3, r3, #1 <== NOT EXECUTED 30007f6c: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
30007f70: e5963000 ldr r3, [r6] <== NOT EXECUTED 30007f74: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED 30007f78: e3130020 tst r3, #32 <== NOT EXECUTED 30007f7c: 0a000002 beq 30007f8c <erase+0x178> <== NOT EXECUTED 30007f80: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 30007f84: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED 30007f88: 0a000007 beq 30007fac <erase+0x198> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
30007f8c: e59f003c ldr r0, [pc, #60] ; 30007fd0 <erase+0x1bc> <== NOT EXECUTED 30007f90: e3a01003 mov r1, #3 <== NOT EXECUTED 30007f94: e1a02004 mov r2, r4 <== NOT EXECUTED 30007f98: ebfffee6 bl 30007b38 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
30007f9c: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30007fa0: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
30007fa4: 12433001 subne r3, r3, #1 <== NOT EXECUTED 30007fa8: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
}
}
if (!lineFlag)
30007fac: e3570000 cmp r7, #0 <== NOT EXECUTED
30007fb0: 1a000001 bne 30007fbc <erase+0x1a8> <== NOT EXECUTED
30007fb4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30007fb8: e59f6014 ldr r6, [pc, #20] ; 30007fd4 <erase+0x1c0> <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
30007fbc: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED
30007fc0: e3510000 cmp r1, #0 <== NOT EXECUTED
30007fc4: 1affffa9 bne 30007e70 <erase+0x5c> <== NOT EXECUTED
30007fc8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30007028 <fchdir>:
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
30007028: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
3000702c: e59f3120 ldr r3, [pc, #288] ; 30007154 <fchdir+0x12c> <== NOT EXECUTED
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
30007030: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
30007034: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007038: e1500003 cmp r0, r3 <== NOT EXECUTED 3000703c: 2a000006 bcs 3000705c <fchdir+0x34> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
30007040: e59f3110 ldr r3, [pc, #272] ; 30007158 <fchdir+0x130> <== NOT EXECUTED 30007044: e3a04038 mov r4, #56 ; 0x38 <== NOT EXECUTED 30007048: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000704c: e0243490 mla r4, r0, r4, r3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
30007050: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 30007054: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007058: 1a000002 bne 30007068 <fchdir+0x40> <== NOT EXECUTED 3000705c: eb0028b9 bl 30011348 <__errno> <== NOT EXECUTED 30007060: e3a03009 mov r3, #9 <== NOT EXECUTED 30007064: ea00000e b 300070a4 <fchdir+0x7c> <== NOT EXECUTED
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30007068: e3130002 tst r3, #2 <== NOT EXECUTED 3000706c: 1a000002 bne 3000707c <fchdir+0x54> <== NOT EXECUTED 30007070: eb0028b4 bl 30011348 <__errno> <== NOT EXECUTED 30007074: e3a03016 mov r3, #22 <== NOT EXECUTED 30007078: ea000009 b 300070a4 <fchdir+0x7c> <== NOT EXECUTED
/*
* Verify you can change directory into this node.
*/
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
3000707c: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 30007080: e2844018 add r4, r4, #24 <== NOT EXECUTED 30007084: e1a00004 mov r0, r4 <== NOT EXECUTED 30007088: e1a0e00f mov lr, pc <== NOT EXECUTED 3000708c: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED 30007090: e3500001 cmp r0, #1 <== NOT EXECUTED 30007094: e1a06000 mov r6, r0 <== NOT EXECUTED 30007098: 0a000003 beq 300070ac <fchdir+0x84> <== NOT EXECUTED
RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000709c: eb0028a9 bl 30011348 <__errno> <== NOT EXECUTED 300070a0: e3a03014 mov r3, #20 <== NOT EXECUTED 300070a4: e5803000 str r3, [r0] <== NOT EXECUTED 300070a8: ea00001d b 30007124 <fchdir+0xfc> <== NOT EXECUTED
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
300070ac: e59f50a8 ldr r5, [pc, #168] ; 3000715c <fchdir+0x134> <== NOT EXECUTED
300070b0: e28de004 add lr, sp, #4 <== NOT EXECUTED
300070b4: e5957000 ldr r7, [r5] <== NOT EXECUTED
300070b8: e287c004 add ip, r7, #4 <== NOT EXECUTED
300070bc: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
300070c0: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
300070c4: e59c3000 ldr r3, [ip] <== NOT EXECUTED
300070c8: e58e3000 str r3, [lr] <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
300070cc: e287e004 add lr, r7, #4 <== NOT EXECUTED
300070d0: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
300070d4: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
300070d8: e5943000 ldr r3, [r4] <== NOT EXECUTED
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
300070dc: e28d4018 add r4, sp, #24 <== NOT EXECUTED
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
rtems_filesystem_current = iop->pathinfo;
300070e0: e58c3000 str r3, [ip] <== NOT EXECUTED
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
300070e4: e3a02000 mov r2, #0 <== NOT EXECUTED 300070e8: e1a01006 mov r1, r6 <== NOT EXECUTED 300070ec: e59f006c ldr r0, [pc, #108] ; 30007160 <fchdir+0x138> <== NOT EXECUTED 300070f0: e1a03004 mov r3, r4 <== NOT EXECUTED 300070f4: e58d2000 str r2, [sp] <== NOT EXECUTED 300070f8: ebffff9a bl 30006f68 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 300070fc: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30007100: e28d0004 add r0, sp, #4 <== NOT EXECUTED 30007104: 0a000008 beq 3000712c <fchdir+0x104> <== NOT EXECUTED
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
30007108: e595c000 ldr ip, [r5] <== NOT EXECUTED
3000710c: e1a04000 mov r4, r0 <== NOT EXECUTED
30007110: e28cc004 add ip, ip, #4 <== NOT EXECUTED
30007114: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
30007118: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000711c: e5943000 ldr r3, [r4] <== NOT EXECUTED
30007120: e58c3000 str r3, [ip] <== NOT EXECUTED
return -1;
30007124: e3e00000 mvn r0, #0 <== NOT EXECUTED 30007128: ea000007 b 3000714c <fchdir+0x124> <== NOT EXECUTED
} /* release the old one */ rtems_filesystem_freenode( &saved );
3000712c: eb00004a bl 3000725c <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_current = loc;
30007130: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
30007134: e595c000 ldr ip, [r5] <== NOT EXECUTED
30007138: e28cc004 add ip, ip, #4 <== NOT EXECUTED
3000713c: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30007140: e5943000 ldr r3, [r4] <== NOT EXECUTED
return 0;
30007144: e1a00006 mov r0, r6 <== NOT EXECUTED
return -1;
}
/* release the old one */
rtems_filesystem_freenode( &saved );
rtems_filesystem_current = loc;
30007148: e58c3000 str r3, [ip] <== NOT EXECUTED
return 0;
}
3000714c: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
30007150: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30007164 <fchmod>:
mode_t mode
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007164: e59f3064 ldr r3, [pc, #100] ; 300071d0 <fchmod+0x6c> <== NOT EXECUTED
int fchmod(
int fd,
mode_t mode
)
{
30007168: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
3000716c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007170: e1500003 cmp r0, r3 <== NOT EXECUTED 30007174: 2a000006 bcs 30007194 <fchmod+0x30> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
30007178: e59f3054 ldr r3, [pc, #84] ; 300071d4 <fchmod+0x70> <== NOT EXECUTED 3000717c: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 30007180: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007184: e0203092 mla r0, r2, r0, r3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
30007188: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000718c: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007190: 1a000002 bne 300071a0 <fchmod+0x3c> <== NOT EXECUTED 30007194: eb00286b bl 30011348 <__errno> <== NOT EXECUTED 30007198: e3a03009 mov r3, #9 <== NOT EXECUTED 3000719c: ea000003 b 300071b0 <fchmod+0x4c> <== NOT EXECUTED
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
300071a0: e3130004 tst r3, #4 <== NOT EXECUTED
300071a4: 1a000004 bne 300071bc <fchmod+0x58> <== NOT EXECUTED
300071a8: eb002866 bl 30011348 <__errno> <== NOT EXECUTED
300071ac: e3a03016 mov r3, #22 <== NOT EXECUTED
300071b0: e5803000 str r3, [r0] <== NOT EXECUTED
300071b4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300071b8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode );
300071bc: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 300071c0: e2800018 add r0, r0, #24 <== NOT EXECUTED 300071c4: e1a0e00f mov lr, pc <== NOT EXECUTED 300071c8: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED
}
300071cc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300071d8 <fchown>:
gid_t group
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300071d8: e59f3074 ldr r3, [pc, #116] ; 30007254 <fchown+0x7c> <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
300071dc: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300071e0: e5933000 ldr r3, [r3] <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
300071e4: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300071e8: e1500003 cmp r0, r3 <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
300071ec: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
300071f0: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED
300071f4: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300071f8: 2a000006 bcs 30007218 <fchown+0x40> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
300071fc: e59f3054 ldr r3, [pc, #84] ; 30007258 <fchown+0x80> <== NOT EXECUTED 30007200: e3a0c038 mov ip, #56 ; 0x38 <== NOT EXECUTED 30007204: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007208: e020309c mla r0, ip, r0, r3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
3000720c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 30007210: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007214: 1a000002 bne 30007224 <fchown+0x4c> <== NOT EXECUTED 30007218: eb00284a bl 30011348 <__errno> <== NOT EXECUTED 3000721c: e3a03009 mov r3, #9 <== NOT EXECUTED 30007220: ea000003 b 30007234 <fchown+0x5c> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007224: e3130004 tst r3, #4 <== NOT EXECUTED
30007228: 1a000004 bne 30007240 <fchown+0x68> <== NOT EXECUTED
3000722c: eb002845 bl 30011348 <__errno> <== NOT EXECUTED
30007230: e3a03016 mov r3, #22 <== NOT EXECUTED
30007234: e5803000 str r3, [r0] <== NOT EXECUTED
30007238: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000723c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group );
30007240: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 30007244: e2800018 add r0, r0, #24 <== NOT EXECUTED 30007248: e1a0e00f mov lr, pc <== NOT EXECUTED 3000724c: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED
}
30007250: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006ba4 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
30006ba4: e92d000e push {r1, r2, r3}
30006ba8: e92d40f1 push {r0, r4, r5, r6, r7, lr}
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006bac: e59f21a4 ldr r2, [pc, #420] ; 30006d58 <fcntl+0x1b4>
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
30006bb0: e28d301c add r3, sp, #28
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006bb4: e5921000 ldr r1, [r2]
int fcntl(
int fd,
int cmd,
...
)
{
30006bb8: e59d7018 ldr r7, [sp, #24]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006bbc: e1500001 cmp r0, r1
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
30006bc0: e58d3000 str r3, [sp]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006bc4: 2a000006 bcs 30006be4 <fcntl+0x40>
iop = rtems_libio_iop( fd );
30006bc8: e59f218c ldr r2, [pc, #396] ; 30006d5c <fcntl+0x1b8> 30006bcc: e3a04038 mov r4, #56 ; 0x38 30006bd0: e5922000 ldr r2, [r2] 30006bd4: e0242490 mla r4, r0, r4, r2
rtems_libio_check_is_open(iop);
30006bd8: e5940014 ldr r0, [r4, #20] 30006bdc: e3100c01 tst r0, #256 ; 0x100
30006be0: 1a000002 bne 30006bf0 <fcntl+0x4c>
30006be4: eb002977 bl 300111c8 <__errno> <== NOT EXECUTED 30006be8: e3a03009 mov r3, #9 <== NOT EXECUTED 30006bec: ea000047 b 30006d10 <fcntl+0x16c> <== NOT EXECUTED
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
30006bf0: e3570009 cmp r7, #9 30006bf4: 979ff107 ldrls pc, [pc, r7, lsl #2] 30006bf8: ea000042 b 30006d08 <fcntl+0x164> 30006bfc: 30006c24 .word 0x30006c24 30006c00: 30006c94 .word 0x30006c94 30006c04: 30006ca4 .word 0x30006ca4 30006c08: 30006cc4 .word 0x30006cc4 30006c0c: 30006cd0 .word 0x30006cd0 30006c10: 30006cfc .word 0x30006cfc 30006c14: 30006cfc .word 0x30006cfc 30006c18: 30006cfc .word 0x30006cfc 30006c1c: 30006cfc .word 0x30006cfc 30006c20: 30006cfc .word 0x30006cfc
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
30006c24: e5933000 ldr r3, [r3] <== NOT EXECUTED
if ( fd2 )
30006c28: e3530000 cmp r3, #0 <== NOT EXECUTED 30006c2c: 0a000004 beq 30006c44 <fcntl+0xa0> <== NOT EXECUTED
diop = rtems_libio_iop( fd2 );
30006c30: e1530001 cmp r3, r1 <== NOT EXECUTED 30006c34: 33a06038 movcc r6, #56 ; 0x38 <== NOT EXECUTED 30006c38: 30262693 mlacc r6, r3, r6, r2 <== NOT EXECUTED 30006c3c: 3a000005 bcc 30006c58 <fcntl+0xb4> <== NOT EXECUTED 30006c40: ea000003 b 30006c54 <fcntl+0xb0> <== NOT EXECUTED
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
30006c44: eb000190 bl 3000728c <rtems_libio_allocate> <== NOT EXECUTED
if ( diop == 0 ) {
30006c48: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30006c4c: 1a000001 bne 30006c58 <fcntl+0xb4> <== NOT EXECUTED 30006c50: ea00003b b 30006d44 <fcntl+0x1a0> <== NOT EXECUTED
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
30006c54: e3a06000 mov r6, #0 <== NOT EXECUTED
ret = -1;
break;
}
}
diop->flags = iop->flags;
30006c58: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
diop->pathinfo = iop->pathinfo;
30006c5c: e286c018 add ip, r6, #24 <== NOT EXECUTED 30006c60: e2845018 add r5, r4, #24 <== NOT EXECUTED
ret = -1;
break;
}
}
diop->flags = iop->flags;
30006c64: e5863014 str r3, [r6, #20] <== NOT EXECUTED
diop->pathinfo = iop->pathinfo;
30006c68: e8b5000f ldm r5!, {r0, r1, r2, r3} <== NOT EXECUTED
30006c6c: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30006c70: e5953000 ldr r3, [r5] <== NOT EXECUTED
30006c74: e58c3000 str r3, [ip] <== NOT EXECUTED
ret = (int) (diop - rtems_libio_iops);
30006c78: e59f30dc ldr r3, [pc, #220] ; 30006d5c <fcntl+0x1b8> <== NOT EXECUTED 30006c7c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30006c80: e0636006 rsb r6, r3, r6 <== NOT EXECUTED 30006c84: e59f30d4 ldr r3, [pc, #212] ; 30006d60 <fcntl+0x1bc> <== NOT EXECUTED 30006c88: e1a061c6 asr r6, r6, #3 <== NOT EXECUTED 30006c8c: e0060693 mul r6, r3, r6 <== NOT EXECUTED 30006c90: ea000020 b 30006d18 <fcntl+0x174> <== NOT EXECUTED
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
30006c94: e3100b02 tst r0, #2048 ; 0x800 30006c98: 03a06000 moveq r6, #0 30006c9c: 13a06001 movne r6, #1 30006ca0: ea00001e b 30006d20 <fcntl+0x17c>
* 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 ) )
30006ca4: e5936000 ldr r6, [r3] 30006ca8: e3560000 cmp r6, #0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
30006cac: 13800b02 orrne r0, r0, #2048 ; 0x800
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
30006cb0: 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;
30006cb4: 15840014 strne r0, [r4, #20]
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
30006cb8: 05840014 streq r0, [r4, #20]
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
30006cbc: 0a000017 beq 30006d20 <fcntl+0x17c>
30006cc0: ea00000b b 30006cf4 <fcntl+0x150>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
30006cc4: eb00015e bl 30007244 <rtems_libio_to_fcntl_flags> 30006cc8: e1a06000 mov r6, r0 30006ccc: ea000011 b 30006d18 <fcntl+0x174>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
30006cd0: e5930000 ldr r0, [r3] 30006cd4: eb00014d bl 30007210 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
30006cd8: e5942014 ldr r2, [r4, #20] 30006cdc: e59f3080 ldr r3, [pc, #128] ; 30006d64 <fcntl+0x1c0> 30006ce0: e3c22c02 bic r2, r2, #512 ; 0x200 30006ce4: e0003003 and r3, r0, r3 30006ce8: e3c22001 bic r2, r2, #1 30006cec: e1833002 orr r3, r3, r2 30006cf0: e5843014 str r3, [r4, #20]
rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0;
30006cf4: e3a06000 mov r6, #0 30006cf8: ea000008 b 30006d20 <fcntl+0x17c>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
30006cfc: eb002931 bl 300111c8 <__errno> 30006d00: e3a03086 mov r3, #134 ; 0x86 30006d04: ea000001 b 30006d10 <fcntl+0x16c>
ret = -1;
break;
default:
errno = EINVAL;
30006d08: eb00292e bl 300111c8 <__errno> 30006d0c: e3a03016 mov r3, #22 30006d10: e5803000 str r3, [r0] 30006d14: ea00000a b 30006d44 <fcntl+0x1a0>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
30006d18: e3560000 cmp r6, #0
30006d1c: ba000009 blt 30006d48 <fcntl+0x1a4>
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
30006d20: e5943020 ldr r3, [r4, #32] 30006d24: e1a01004 mov r1, r4 30006d28: e1a00007 mov r0, r7 30006d2c: e1a0e00f mov lr, pc 30006d30: e593f030 ldr pc, [r3, #48] ; 0x30
if (err) {
30006d34: e2504000 subs r4, r0, #0
30006d38: 0a000002 beq 30006d48 <fcntl+0x1a4>
errno = err;
30006d3c: eb002921 bl 300111c8 <__errno> <== NOT EXECUTED 30006d40: e5804000 str r4, [r0] <== NOT EXECUTED
ret = -1;
30006d44: e3e06000 mvn r6, #0
va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; }
30006d48: e1a00006 mov r0, r6
30006d4c: e8bd40f8 pop {r3, r4, r5, r6, r7, lr}
30006d50: e28dd00c add sp, sp, #12
30006d54: e12fff1e bx lr
30006d78 <fdatasync>:
int fd
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30006d78: e59f3060 ldr r3, [pc, #96] ; 30006de0 <fdatasync+0x68> <== NOT EXECUTED
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
30006d7c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30006d80: e5933000 ldr r3, [r3] <== NOT EXECUTED 30006d84: e1500003 cmp r0, r3 <== NOT EXECUTED 30006d88: 2a000006 bcs 30006da8 <fdatasync+0x30> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
30006d8c: e59f3050 ldr r3, [pc, #80] ; 30006de4 <fdatasync+0x6c> <== NOT EXECUTED 30006d90: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 30006d94: e5933000 ldr r3, [r3] <== NOT EXECUTED 30006d98: e0203092 mla r0, r2, r0, r3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
30006d9c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 30006da0: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30006da4: 1a000002 bne 30006db4 <fdatasync+0x3c> <== NOT EXECUTED 30006da8: eb002906 bl 300111c8 <__errno> <== NOT EXECUTED 30006dac: e3a03009 mov r3, #9 <== NOT EXECUTED 30006db0: ea000003 b 30006dc4 <fdatasync+0x4c> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30006db4: e3130004 tst r3, #4 <== NOT EXECUTED
30006db8: 1a000004 bne 30006dd0 <fdatasync+0x58> <== NOT EXECUTED
30006dbc: eb002901 bl 300111c8 <__errno> <== NOT EXECUTED
30006dc0: e3a03016 mov r3, #22 <== NOT EXECUTED
30006dc4: e5803000 str r3, [r0] <== NOT EXECUTED
30006dc8: e3e00000 mvn r0, #0 <== NOT EXECUTED
30006dcc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
30006dd0: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 30006dd4: e1a0e00f mov lr, pc <== NOT EXECUTED 30006dd8: e593f02c ldr pc, [r3, #44] ; 0x2c <== NOT EXECUTED
}
30006ddc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000f870 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000f870: e92d45f3 push {r0, r1, r4, r5, r6, r7, r8, sl, lr}
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
3000f874: e59f5378 ldr r5, [pc, #888] ; 3000fbf4 <fifo_open+0x384>
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000f878: e1a08000 mov r8, r0
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
3000f87c: e5954000 ldr r4, [r5]
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000f880: e1a07001 mov r7, r1
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
3000f884: e3540000 cmp r4, #0
3000f888: 1a000012 bne 3000f8d8 <fifo_open+0x68>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
3000f88c: e59f3364 ldr r3, [pc, #868] ; 3000fbf8 <fifo_open+0x388> 3000f890: e1a01004 mov r1, r4 3000f894: e5930000 ldr r0, [r3] 3000f898: e1a02004 mov r2, r4 3000f89c: ebffeeb3 bl 3000b370 <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
3000f8a0: e5953000 ldr r3, [r5] 3000f8a4: e3530000 cmp r3, #0
3000f8a8: 1a000005 bne 3000f8c4 <fifo_open+0x54>
sc = rtems_semaphore_create(
3000f8ac: e59f0348 ldr r0, [pc, #840] ; 3000fbfc <fifo_open+0x38c> 3000f8b0: e3a01001 mov r1, #1 3000f8b4: e3a02054 mov r2, #84 ; 0x54 3000f8b8: e58d5000 str r5, [sp] 3000f8bc: ebffee19 bl 3000b128 <rtems_semaphore_create> 3000f8c0: e1a04000 mov r4, r0
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3000f8c4: e59f332c ldr r3, [pc, #812] ; 3000fbf8 <fifo_open+0x388> 3000f8c8: e5930000 ldr r0, [r3] 3000f8cc: ebffeeed bl 3000b488 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
3000f8d0: e3540000 cmp r4, #0
3000f8d4: 1a000006 bne 3000f8f4 <fifo_open+0x84>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3000f8d8: e59f3314 ldr r3, [pc, #788] ; 3000fbf4 <fifo_open+0x384> 3000f8dc: e3a01000 mov r1, #0 3000f8e0: e5930000 ldr r0, [r3] 3000f8e4: e1a02001 mov r2, r1 3000f8e8: ebffeea0 bl 3000b370 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
3000f8ec: e2505000 subs r5, r0, #0
3000f8f0: 0a000000 beq 3000f8f8 <fifo_open+0x88>
return 0;
} else {
return -ENOMEM;
3000f8f4: e3e0500b mvn r5, #11 <== NOT EXECUTED
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
if (err)
3000f8f8: e2556000 subs r6, r5, #0
3000f8fc: 1a0000ba bne 3000fbec <fifo_open+0x37c>
return err;
pipe = *pipep;
3000f900: e5984000 ldr r4, [r8]
if (pipe == NULL) {
3000f904: e3540000 cmp r4, #0
3000f908: 1a00003c bne 3000fa00 <fifo_open+0x190>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
3000f90c: e3a00034 mov r0, #52 ; 0x34 3000f910: ebffe2aa bl 300083c0 <malloc>
if (pipe == NULL)
3000f914: e250a000 subs sl, r0, #0
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
3000f918: e1a04000 mov r4, r0
if (pipe == NULL)
3000f91c: 0a000035 beq 3000f9f8 <fifo_open+0x188>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
3000f920: e1a01005 mov r1, r5 3000f924: e3a02034 mov r2, #52 ; 0x34 3000f928: eb000dba bl 30013018 <memset>
pipe->Size = PIPE_BUF;
3000f92c: e3a00c02 mov r0, #512 ; 0x200 3000f930: e5840004 str r0, [r4, #4]
pipe->Buffer = malloc(pipe->Size);
3000f934: ebffe2a1 bl 300083c0 <malloc>
if (! pipe->Buffer)
3000f938: 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);
3000f93c: e5840000 str r0, [r4]
if (! pipe->Buffer)
3000f940: 0a00002a beq 3000f9f0 <fifo_open+0x180>
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
3000f944: e59f62b4 ldr r6, [pc, #692] ; 3000fc00 <fifo_open+0x390>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
3000f948: e59f02b4 ldr r0, [pc, #692] ; 3000fc04 <fifo_open+0x394>
rtems_build_name ('P', 'I', 'r', c),
3000f94c: e5d63000 ldrb r3, [r6]
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
3000f950: e1a01005 mov r1, r5 3000f954: e1830000 orr r0, r3, r0 3000f958: e1a02005 mov r2, r5 3000f95c: e284302c add r3, r4, #44 ; 0x2c 3000f960: eb0003dd bl 300108dc <rtems_barrier_create> 3000f964: e3500000 cmp r0, #0
3000f968: 1a00001e bne 3000f9e8 <fifo_open+0x178>
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),
3000f96c: e5d63000 ldrb r3, [r6]
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(
3000f970: e59f0290 ldr r0, [pc, #656] ; 3000fc08 <fifo_open+0x398> 3000f974: e1a01005 mov r1, r5 3000f978: e1830000 orr r0, r3, r0 3000f97c: e1a02005 mov r2, r5 3000f980: e2843030 add r3, r4, #48 ; 0x30 3000f984: eb0003d4 bl 300108dc <rtems_barrier_create> 3000f988: e3500000 cmp r0, #0
3000f98c: 1a000013 bne 3000f9e0 <fifo_open+0x170>
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,
3000f990: e5d63000 ldrb r3, [r6]
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(
3000f994: e59f0270 ldr r0, [pc, #624] ; 3000fc0c <fifo_open+0x39c> 3000f998: e2842028 add r2, r4, #40 ; 0x28 3000f99c: e58d2000 str r2, [sp] 3000f9a0: e1830000 orr r0, r3, r0 3000f9a4: e3a01001 mov r1, #1 3000f9a8: e3a02010 mov r2, #16 3000f9ac: e1a03005 mov r3, r5 3000f9b0: ebffeddc bl 3000b128 <rtems_semaphore_create> 3000f9b4: e3500000 cmp r0, #0
3000f9b8: 1a000006 bne 3000f9d8 <fifo_open+0x168>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
3000f9bc: e5d63000 ldrb r3, [r6] 3000f9c0: e353007a cmp r3, #122 ; 0x7a 3000f9c4: e2832001 add r2, r3, #1
c = 'a';
3000f9c8: 03a03061 moveq r3, #97 ; 0x61
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
3000f9cc: e5c62000 strb r2, [r6]
c = 'a';
3000f9d0: 05c63000 strbeq r3, [r6] 3000f9d4: ea000009 b 3000fa00 <fifo_open+0x190>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
3000f9d8: e59a0030 ldr r0, [sl, #48] ; 0x30 <== NOT EXECUTED 3000f9dc: eb0003ee bl 3001099c <rtems_barrier_delete> <== NOT EXECUTED
err_wbar: rtems_barrier_delete(pipe->readBarrier);
3000f9e0: e59a002c ldr r0, [sl, #44] ; 0x2c <== NOT EXECUTED 3000f9e4: eb0003ec bl 3001099c <rtems_barrier_delete> <== NOT EXECUTED
err_rbar: free(pipe->Buffer);
3000f9e8: e59a0000 ldr r0, [sl] <== NOT EXECUTED 3000f9ec: ebffe0a0 bl 30007c74 <free> <== NOT EXECUTED
err_buf: free(pipe);
3000f9f0: e1a0000a mov r0, sl <== NOT EXECUTED 3000f9f4: ebffe09e bl 30007c74 <free> <== NOT EXECUTED
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
3000f9f8: e3e0600b mvn r6, #11 <== NOT EXECUTED 3000f9fc: ea00000d b 3000fa38 <fifo_open+0x1c8> <== NOT EXECUTED
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
3000fa00: e3a01000 mov r1, #0 3000fa04: e5940028 ldr r0, [r4, #40] ; 0x28 3000fa08: e1a02001 mov r2, r1 3000fa0c: ebffee57 bl 3000b370 <rtems_semaphore_obtain>
err = -EINTR;
if (*pipep == NULL) {
3000fa10: e5983000 ldr r3, [r8]
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
3000fa14: e3500000 cmp r0, #0 3000fa18: 03a06000 moveq r6, #0 3000fa1c: 13e06003 mvnne r6, #3
if (*pipep == NULL) {
3000fa20: e3530000 cmp r3, #0
3000fa24: 1a000003 bne 3000fa38 <fifo_open+0x1c8>
if (err)
3000fa28: e3560000 cmp r6, #0
pipe_free(pipe);
else
*pipep = pipe;
3000fa2c: 05884000 streq r4, [r8]
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
pipe_free(pipe);
3000fa30: 11a00004 movne r0, r4 3000fa34: 1bffff54 blne 3000f78c <pipe_free>
else
*pipep = pipe;
}
out:
pipe_unlock();
3000fa38: ebffff4f bl 3000f77c <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
3000fa3c: e3560000 cmp r6, #0
3000fa40: 1a000069 bne 3000fbec <fifo_open+0x37c>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
3000fa44: e5973014 ldr r3, [r7, #20]
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
3000fa48: e5984000 ldr r4, [r8]
switch (LIBIO_ACCMODE(iop)) {
3000fa4c: e2033006 and r3, r3, #6 3000fa50: e3530004 cmp r3, #4
3000fa54: 0a000024 beq 3000faec <fifo_open+0x27c>
3000fa58: e3530006 cmp r3, #6
3000fa5c: 0a000047 beq 3000fb80 <fifo_open+0x310>
3000fa60: e3530002 cmp r3, #2
3000fa64: 1a000059 bne 3000fbd0 <fifo_open+0x360>
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
3000fa68: e5943020 ldr r3, [r4, #32] 3000fa6c: e2833001 add r3, r3, #1 3000fa70: e5843020 str r3, [r4, #32]
if (pipe->Readers ++ == 0)
3000fa74: e5943010 ldr r3, [r4, #16] 3000fa78: e2832001 add r2, r3, #1 3000fa7c: e3530000 cmp r3, #0 3000fa80: e5842010 str r2, [r4, #16]
PIPE_WAKEUPWRITERS(pipe);
3000fa84: 05940030 ldreq r0, [r4, #48] ; 0x30 3000fa88: 028d1004 addeq r1, sp, #4 3000fa8c: 0b0003ea bleq 30010a3c <rtems_barrier_release>
if (pipe->Writers == 0) {
3000fa90: e5943014 ldr r3, [r4, #20] 3000fa94: e3530000 cmp r3, #0
3000fa98: 1a00004c bne 3000fbd0 <fifo_open+0x360>
/* Not an error */
if (LIBIO_NODELAY(iop))
3000fa9c: e5973014 ldr r3, [r7, #20] 3000faa0: e3130001 tst r3, #1
3000faa4: 1a000049 bne 3000fbd0 <fifo_open+0x360>
break;
prevCounter = pipe->writerCounter;
3000faa8: e5945024 ldr r5, [r4, #36] ; 0x24 <== NOT EXECUTED
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
3000faac: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000fab0: ebffee74 bl 3000b488 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
3000fab4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000fab8: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED 3000fabc: eb0003f4 bl 30010a94 <rtems_barrier_wait> <== NOT EXECUTED 3000fac0: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000fac4: 1a000044 bne 3000fbdc <fifo_open+0x36c> <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
3000fac8: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000facc: e1a02001 mov r2, r1 <== NOT EXECUTED 3000fad0: ebffee26 bl 3000b370 <rtems_semaphore_obtain> <== NOT EXECUTED 3000fad4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fad8: 1a00003f bne 3000fbdc <fifo_open+0x36c> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
3000fadc: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3000fae0: e1550003 cmp r5, r3 <== NOT EXECUTED 3000fae4: 0afffff0 beq 3000faac <fifo_open+0x23c> <== NOT EXECUTED 3000fae8: ea000038 b 3000fbd0 <fifo_open+0x360> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
3000faec: e5943024 ldr r3, [r4, #36] ; 0x24 3000faf0: e2833001 add r3, r3, #1 3000faf4: e5843024 str r3, [r4, #36] ; 0x24
if (pipe->Writers ++ == 0)
3000faf8: e5943014 ldr r3, [r4, #20] 3000fafc: e2832001 add r2, r3, #1 3000fb00: e3530000 cmp r3, #0 3000fb04: e5842014 str r2, [r4, #20]
PIPE_WAKEUPREADERS(pipe);
3000fb08: 0594002c ldreq r0, [r4, #44] ; 0x2c 3000fb0c: 028d1004 addeq r1, sp, #4 3000fb10: 0b0003c9 bleq 30010a3c <rtems_barrier_release>
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
3000fb14: e5943010 ldr r3, [r4, #16] 3000fb18: e3530000 cmp r3, #0
3000fb1c: 1a00002b bne 3000fbd0 <fifo_open+0x360>
3000fb20: e5973014 ldr r3, [r7, #20] <== NOT EXECUTED 3000fb24: e3130001 tst r3, #1 <== NOT EXECUTED
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
3000fb28: 05945020 ldreq r5, [r4, #32] <== NOT EXECUTED
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
3000fb2c: 0a000003 beq 3000fb40 <fifo_open+0x2d0> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
3000fb30: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000fb34: ebffee53 bl 3000b488 <rtems_semaphore_release> <== NOT EXECUTED
err = -ENXIO;
3000fb38: e3e06005 mvn r6, #5 <== NOT EXECUTED
goto out_error;
3000fb3c: ea000027 b 3000fbe0 <fifo_open+0x370> <== NOT EXECUTED
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
3000fb40: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000fb44: ebffee4f bl 3000b488 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
3000fb48: e3a01000 mov r1, #0 <== NOT EXECUTED 3000fb4c: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 3000fb50: eb0003cf bl 30010a94 <rtems_barrier_wait> <== NOT EXECUTED 3000fb54: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000fb58: 1a00001f bne 3000fbdc <fifo_open+0x36c> <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
3000fb5c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000fb60: e1a02001 mov r2, r1 <== NOT EXECUTED 3000fb64: ebffee01 bl 3000b370 <rtems_semaphore_obtain> <== NOT EXECUTED 3000fb68: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fb6c: 1a00001a bne 3000fbdc <fifo_open+0x36c> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
3000fb70: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000fb74: e1550003 cmp r5, r3 <== NOT EXECUTED 3000fb78: 0afffff0 beq 3000fb40 <fifo_open+0x2d0> <== NOT EXECUTED 3000fb7c: ea000013 b 3000fbd0 <fifo_open+0x360> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
3000fb80: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000fb84: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000fb88: e5843020 str r3, [r4, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
3000fb8c: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 3000fb90: e2832001 add r2, r3, #1 <== NOT EXECUTED 3000fb94: e3530000 cmp r3, #0 <== NOT EXECUTED 3000fb98: e5842010 str r2, [r4, #16] <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
3000fb9c: 05940030 ldreq r0, [r4, #48] ; 0x30 <== NOT EXECUTED 3000fba0: 028d1004 addeq r1, sp, #4 <== NOT EXECUTED 3000fba4: 0b0003a4 bleq 30010a3c <rtems_barrier_release> <== NOT EXECUTED
pipe->writerCounter ++;
3000fba8: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3000fbac: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000fbb0: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
3000fbb4: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000fbb8: e2832001 add r2, r3, #1 <== NOT EXECUTED 3000fbbc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000fbc0: e5842014 str r2, [r4, #20] <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
3000fbc4: 0594002c ldreq r0, [r4, #44] ; 0x2c <== NOT EXECUTED 3000fbc8: 028d1004 addeq r1, sp, #4 <== NOT EXECUTED 3000fbcc: 0b00039a bleq 30010a3c <rtems_barrier_release> <== NOT EXECUTED
break;
}
PIPE_UNLOCK(pipe);
3000fbd0: e5940028 ldr r0, [r4, #40] ; 0x28 3000fbd4: ebffee2b bl 3000b488 <rtems_semaphore_release>
return 0;
3000fbd8: ea000003 b 3000fbec <fifo_open+0x37c>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
3000fbdc: e3e06003 mvn r6, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
3000fbe0: e1a00008 mov r0, r8 <== NOT EXECUTED 3000fbe4: e1a01007 mov r1, r7 <== NOT EXECUTED 3000fbe8: ebfffef4 bl 3000f7c0 <pipe_release> <== NOT EXECUTED
return err; }
3000fbec: e1a00006 mov r0, r6
3000fbf0: e8bd85fc pop {r2, r3, r4, r5, r6, r7, r8, sl, pc}
30006364 <flockfile>:
#include <stdio.h>
/* This is a non-functional stub */
void flockfile(FILE* file)
{
}
30006364: e12fff1e bx lr <== NOT EXECUTED
30006de8 <fpathconf>:
{
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
30006de8: e59f3104 ldr r3, [pc, #260] ; 30006ef4 <fpathconf+0x10c> <== NOT EXECUTED
long fpathconf(
int fd,
int name
)
{
30006dec: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
30006df0: e5933000 ldr r3, [r3] <== NOT EXECUTED 30006df4: e1500003 cmp r0, r3 <== NOT EXECUTED 30006df8: 2a000006 bcs 30006e18 <fpathconf+0x30> <== NOT EXECUTED
iop = rtems_libio_iop(fd);
30006dfc: e59f30f4 ldr r3, [pc, #244] ; 30006ef8 <fpathconf+0x110> <== NOT EXECUTED 30006e00: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 30006e04: e5933000 ldr r3, [r3] <== NOT EXECUTED 30006e08: e0203092 mla r0, r2, r0, r3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
30006e0c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 30006e10: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30006e14: 1a000002 bne 30006e24 <fpathconf+0x3c> <== NOT EXECUTED 30006e18: eb0028ea bl 300111c8 <__errno> <== NOT EXECUTED 30006e1c: e3a03009 mov r3, #9 <== NOT EXECUTED 30006e20: ea000003 b 30006e34 <fpathconf+0x4c> <== NOT EXECUTED
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
30006e24: e3130002 tst r3, #2 <== NOT EXECUTED
30006e28: 1a000004 bne 30006e40 <fpathconf+0x58> <== NOT EXECUTED
30006e2c: eb0028e5 bl 300111c8 <__errno> <== NOT EXECUTED
30006e30: e3a03016 mov r3, #22 <== NOT EXECUTED
30006e34: e5803000 str r3, [r0] <== NOT EXECUTED
30006e38: e3e00000 mvn r0, #0 <== NOT EXECUTED
30006e3c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
30006e40: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
switch ( name ) {
30006e44: e351000b cmp r1, #11 <== NOT EXECUTED 30006e48: 979ff101 ldrls pc, [pc, r1, lsl #2] <== NOT EXECUTED 30006e4c: ea000023 b 30006ee0 <fpathconf+0xf8> <== NOT EXECUTED 30006e50: 30006e80 .word 0x30006e80 <== NOT EXECUTED 30006e54: 30006e88 .word 0x30006e88 <== NOT EXECUTED 30006e58: 30006e90 .word 0x30006e90 <== NOT EXECUTED 30006e5c: 30006e98 .word 0x30006e98 <== NOT EXECUTED 30006e60: 30006ea0 .word 0x30006ea0 <== NOT EXECUTED 30006e64: 30006ea8 .word 0x30006ea8 <== NOT EXECUTED 30006e68: 30006eb0 .word 0x30006eb0 <== NOT EXECUTED 30006e6c: 30006eb8 .word 0x30006eb8 <== NOT EXECUTED 30006e70: 30006ec0 .word 0x30006ec0 <== NOT EXECUTED 30006e74: 30006ec8 .word 0x30006ec8 <== NOT EXECUTED 30006e78: 30006ed0 .word 0x30006ed0 <== NOT EXECUTED 30006e7c: 30006ed8 .word 0x30006ed8 <== NOT EXECUTED
case _PC_LINK_MAX:
return_value = the_limits->link_max;
30006e80: e5930038 ldr r0, [r3, #56] ; 0x38 <== NOT EXECUTED
break;
30006e84: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
30006e88: e593003c ldr r0, [r3, #60] ; 0x3c <== NOT EXECUTED
break;
30006e8c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
30006e90: e5930040 ldr r0, [r3, #64] ; 0x40 <== NOT EXECUTED
break;
30006e94: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_NAME_MAX:
return_value = the_limits->name_max;
30006e98: e5930044 ldr r0, [r3, #68] ; 0x44 <== NOT EXECUTED
break;
30006e9c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_PATH_MAX:
return_value = the_limits->path_max;
30006ea0: e5930048 ldr r0, [r3, #72] ; 0x48 <== NOT EXECUTED
break;
30006ea4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
30006ea8: e593004c ldr r0, [r3, #76] ; 0x4c <== NOT EXECUTED
break;
30006eac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
30006eb0: e5930054 ldr r0, [r3, #84] ; 0x54 <== NOT EXECUTED
break;
30006eb4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
30006eb8: e5930058 ldr r0, [r3, #88] ; 0x58 <== NOT EXECUTED
break;
30006ebc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
30006ec0: e5930064 ldr r0, [r3, #100] ; 0x64 <== NOT EXECUTED
break;
30006ec4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
30006ec8: e5930050 ldr r0, [r3, #80] ; 0x50 <== NOT EXECUTED
break;
30006ecc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
30006ed0: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED
break;
30006ed4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
30006ed8: e5930060 ldr r0, [r3, #96] ; 0x60 <== NOT EXECUTED
break;
30006edc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30006ee0: eb0028b8 bl 300111c8 <__errno> <== NOT EXECUTED 30006ee4: e3a03016 mov r3, #22 <== NOT EXECUTED 30006ee8: e5803000 str r3, [r0] <== NOT EXECUTED 30006eec: e3e00000 mvn r0, #0 <== NOT EXECUTED
break;
}
return return_value;
}
30006ef0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300062a4 <free>:
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
300062a4: e59f3088 ldr r3, [pc, #136] ; 30006334 <free+0x90>
#include <stdlib.h>
void free(
void *ptr
)
{
300062a8: e92d4030 push {r4, r5, lr}
MSBUMP(free_calls, 1);
300062ac: e593200c ldr r2, [r3, #12]
if ( !ptr )
300062b0: e2504000 subs r4, r0, #0
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
300062b4: e2822001 add r2, r2, #1 300062b8: e583200c str r2, [r3, #12]
if ( !ptr )
300062bc: 08bd8030 popeq {r4, r5, pc}
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
300062c0: e59f3070 ldr r3, [pc, #112] ; 30006338 <free+0x94> 300062c4: e5933000 ldr r3, [r3] 300062c8: e3530003 cmp r3, #3
300062cc: 1a000005 bne 300062e8 <free+0x44>
!malloc_is_system_state_OK() ) {
300062d0: eb000068 bl 30006478 <malloc_is_system_state_OK>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
300062d4: e3500000 cmp r0, #0
300062d8: 1a000002 bne 300062e8 <free+0x44>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
300062dc: e1a00004 mov r0, r4 <== NOT EXECUTED
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
300062e0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
300062e4: ea000080 b 300064ec <malloc_deferred_free> <== NOT EXECUTED
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
300062e8: e59f304c ldr r3, [pc, #76] ; 3000633c <free+0x98> 300062ec: e5933000 ldr r3, [r3] 300062f0: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_free)(ptr);
300062f4: 11a00004 movne r0, r4 300062f8: 11a0e00f movne lr, pc 300062fc: 1593f008 ldrne pc, [r3, #8]
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
30006300: e59f5038 ldr r5, [pc, #56] ; 30006340 <free+0x9c>
30006304: e1a01004 mov r1, r4
30006308: e5950000 ldr r0, [r5]
3000630c: eb0012c5 bl 3000ae28 <_Protected_heap_Free>
30006310: e3500000 cmp r0, #0
30006314: 18bd8030 popne {r4, r5, pc}
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
30006318: e5953000 ldr r3, [r5]
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
3000631c: e59f0020 ldr r0, [pc, #32] ; 30006344 <free+0xa0> 30006320: e5932018 ldr r2, [r3, #24] 30006324: e593301c ldr r3, [r3, #28] 30006328: e1a01004 mov r1, r4
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
3000632c: e8bd4030 pop {r4, r5, lr}
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
30006330: ea000340 b 30007038 <printk>
300077f0 <free_user_env>:
static void
free_user_env(void *venv)
{
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
300077f0: e59f3028 ldr r3, [pc, #40] ; 30007820 <free_user_env+0x30> <== NOT EXECUTED
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
300077f4: e92d4010 push {r4, lr} <== NOT EXECUTED
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
300077f8: e1500003 cmp r0, r3 <== NOT EXECUTED
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
300077fc: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
30007800: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
30007804: e2800004 add r0, r0, #4 <== NOT EXECUTED 30007808: ebfffbe6 bl 300067a8 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &env->root_directory);
3000780c: e2840018 add r0, r4, #24 <== NOT EXECUTED 30007810: ebfffbe4 bl 300067a8 <rtems_filesystem_freenode> <== NOT EXECUTED
free(env);
30007814: e1a00004 mov r0, r4 <== NOT EXECUTED
} }
30007818: e8bd4010 pop {r4, lr} <== NOT EXECUTED
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
3000781c: eafffbe6 b 300067bc <free> <== NOT EXECUTED
30015964 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
30015964: e92d4030 push {r4, r5, lr}
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
30015968: e2515000 subs r5, r1, #0
3001596c: 1a000002 bne 3001597c <fstat+0x18>
rtems_set_errno_and_return_minus_one( EFAULT );
30015970: ebffea31 bl 3001023c <__errno> <== NOT EXECUTED 30015974: e3a0300e mov r3, #14 <== NOT EXECUTED 30015978: ea00000c b 300159b0 <fstat+0x4c> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
3001597c: e59f3060 ldr r3, [pc, #96] ; 300159e4 <fstat+0x80> 30015980: e5933000 ldr r3, [r3] 30015984: e1500003 cmp r0, r3
30015988: 2a000006 bcs 300159a8 <fstat+0x44>
3001598c: e59f3054 ldr r3, [pc, #84] ; 300159e8 <fstat+0x84> 30015990: e3a04038 mov r4, #56 ; 0x38 30015994: e5933000 ldr r3, [r3] 30015998: e0243490 mla r4, r0, r4, r3
rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop);
3001599c: e5943014 ldr r3, [r4, #20] 300159a0: e3130c01 tst r3, #256 ; 0x100
300159a4: 1a000004 bne 300159bc <fstat+0x58>
300159a8: ebffea23 bl 3001023c <__errno> <== NOT EXECUTED
300159ac: e3a03009 mov r3, #9 <== NOT EXECUTED
300159b0: e5803000 str r3, [r0] <== NOT EXECUTED
300159b4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300159b8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
300159bc: e1a00005 mov r0, r5 300159c0: e3a01000 mov r1, #0 300159c4: e3a02048 mov r2, #72 ; 0x48 300159c8: ebffec80 bl 30010bd0 <memset>
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
300159cc: e5943020 ldr r3, [r4, #32] 300159d0: e2840018 add r0, r4, #24 300159d4: e1a01005 mov r1, r5 300159d8: e1a0e00f mov lr, pc 300159dc: e593f018 ldr pc, [r3, #24]
}
300159e0: e8bd8030 pop {r4, r5, pc}
30007048 <fsync>:
int fd
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007048: e59f3060 ldr r3, [pc, #96] ; 300070b0 <fsync+0x68> <== NOT EXECUTED
#include <rtems/seterr.h>
int fsync(
int fd
)
{
3000704c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007050: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007054: e1500003 cmp r0, r3 <== NOT EXECUTED 30007058: 2a000006 bcs 30007078 <fsync+0x30> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
3000705c: e59f3050 ldr r3, [pc, #80] ; 300070b4 <fsync+0x6c> <== NOT EXECUTED 30007060: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 30007064: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007068: e0203092 mla r0, r2, r0, r3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
3000706c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 30007070: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007074: 1a000002 bne 30007084 <fsync+0x3c> <== NOT EXECUTED 30007078: eb002852 bl 300111c8 <__errno> <== NOT EXECUTED 3000707c: e3a03009 mov r3, #9 <== NOT EXECUTED 30007080: ea000003 b 30007094 <fsync+0x4c> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007084: e3130004 tst r3, #4 <== NOT EXECUTED
30007088: 1a000004 bne 300070a0 <fsync+0x58> <== NOT EXECUTED
3000708c: eb00284d bl 300111c8 <__errno> <== NOT EXECUTED
30007090: e3a03016 mov r3, #22 <== NOT EXECUTED
30007094: e5803000 str r3, [r0] <== NOT EXECUTED
30007098: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000709c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
300070a0: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 300070a4: e1a0e00f mov lr, pc <== NOT EXECUTED 300070a8: e593f028 ldr pc, [r3, #40] ; 0x28 <== NOT EXECUTED
}
300070ac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000da04 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
3000da04: e92d4070 push {r4, r5, r6, lr}
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000da08: e59f30b8 ldr r3, [pc, #184] ; 3000dac8 <ftruncate+0xc4>
int ftruncate(
int fd,
off_t length
)
{
3000da0c: e24dd014 sub sp, sp, #20
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000da10: e5933000 ldr r3, [r3]
int ftruncate(
int fd,
off_t length
)
{
3000da14: e1a05001 mov r5, r1
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000da18: e1500003 cmp r0, r3
int ftruncate(
int fd,
off_t length
)
{
3000da1c: e1a06002 mov r6, r2
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000da20: 2a000006 bcs 3000da40 <ftruncate+0x3c>
iop = rtems_libio_iop( fd );
3000da24: e59f30a0 ldr r3, [pc, #160] ; 3000dacc <ftruncate+0xc8> 3000da28: e3a04038 mov r4, #56 ; 0x38 3000da2c: e5933000 ldr r3, [r3] 3000da30: e0243490 mla r4, r0, r4, r3
rtems_libio_check_is_open(iop);
3000da34: e5943014 ldr r3, [r4, #20] 3000da38: e3130c01 tst r3, #256 ; 0x100
3000da3c: 1a000002 bne 3000da4c <ftruncate+0x48>
3000da40: eb0009fd bl 3001023c <__errno> <== NOT EXECUTED 3000da44: e3a03009 mov r3, #9 <== NOT EXECUTED 3000da48: ea000013 b 3000da9c <ftruncate+0x98> <== NOT EXECUTED
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
3000da4c: e1a0c00d mov ip, sp
3000da50: e284e018 add lr, r4, #24
3000da54: e8be000f ldm lr!, {r0, r1, r2, r3}
3000da58: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000da5c: e59e3000 ldr r3, [lr]
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
3000da60: e1a0000d mov r0, sp
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
3000da64: e58c3000 str r3, [ip]
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
3000da68: e59d300c ldr r3, [sp, #12] 3000da6c: e1a0e00f mov lr, pc 3000da70: e593f010 ldr pc, [r3, #16] 3000da74: e3500001 cmp r0, #1
3000da78: 1a000002 bne 3000da88 <ftruncate+0x84>
rtems_set_errno_and_return_minus_one( EISDIR );
3000da7c: eb0009ee bl 3001023c <__errno> <== NOT EXECUTED 3000da80: e3a03015 mov r3, #21 <== NOT EXECUTED 3000da84: ea000004 b 3000da9c <ftruncate+0x98> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000da88: e5943014 ldr r3, [r4, #20] 3000da8c: e3130004 tst r3, #4
3000da90: 1a000004 bne 3000daa8 <ftruncate+0xa4>
3000da94: eb0009e8 bl 3001023c <__errno> <== NOT EXECUTED 3000da98: e3a03016 mov r3, #22 <== NOT EXECUTED 3000da9c: e5803000 str r3, [r0] <== NOT EXECUTED 3000daa0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000daa4: ea000005 b 3000dac0 <ftruncate+0xbc> <== NOT EXECUTED
return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
3000daa8: e5943020 ldr r3, [r4, #32] 3000daac: e1a00004 mov r0, r4 3000dab0: e1a01005 mov r1, r5 3000dab4: e1a02006 mov r2, r6 3000dab8: e1a0e00f mov lr, pc 3000dabc: e593f020 ldr pc, [r3, #32]
}
3000dac0: e28dd014 add sp, sp, #20
3000dac4: e8bd8070 pop {r4, r5, r6, pc}
30006420 <ftrylockfile>:
#include <rtems/seterr.h>
#include <errno.h>
/* This is a non-functional stub */
int ftrylockfile(FILE* file)
{
30006420: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
30006424: eb002787 bl 30010248 <__errno> <== NOT EXECUTED 30006428: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 3000642c: e5803000 str r3, [r0] <== NOT EXECUTED
}
30006430: e3e00000 mvn r0, #0 <== NOT EXECUTED
30006434: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006438 <funlockfile>:
#include <stdio.h>
/* This is a non-functional stub */
void funlockfile(FILE* file)
{
}
30006438: e12fff1e bx lr <== NOT EXECUTED
300068bc <getegid>:
* P1003.1b-1993, p. 84
*/
gid_t getegid( void )
{
return _POSIX_types_Egid;
300068bc: e59f3008 ldr r3, [pc, #8] ; 300068cc <getegid+0x10> <== NOT EXECUTED 300068c0: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
300068c4: e1d303b8 ldrh r0, [r3, #56] ; 0x38 <== NOT EXECUTED 300068c8: e12fff1e bx lr <== NOT EXECUTED
300068d0 <geteuid>:
* P1003.1b-1993, p. 84
*/
uid_t geteuid( void )
{
return _POSIX_types_Euid;
300068d0: e59f3008 ldr r3, [pc, #8] ; 300068e0 <geteuid+0x10> <== NOT EXECUTED 300068d4: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
300068d8: e1d303b6 ldrh r0, [r3, #54] ; 0x36 <== NOT EXECUTED 300068dc: e12fff1e bx lr <== NOT EXECUTED
300068e4 <getgid>:
* 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs,
* P1003.1b-1993, p. 84
*/
gid_t getgid( void )
{
return _POSIX_types_Gid;
300068e4: e59f3008 ldr r3, [pc, #8] ; 300068f4 <getgid+0x10> <== NOT EXECUTED 300068e8: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
300068ec: e1d303b4 ldrh r0, [r3, #52] ; 0x34 <== NOT EXECUTED 300068f0: e12fff1e bx lr <== NOT EXECUTED
30006e8c <getgr_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
30006e8c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
30006e90: e59da01c ldr sl, [sp, #28] <== NOT EXECUTED
30006e94: e1a06000 mov r6, r0 <== NOT EXECUTED
30006e98: e1a07001 mov r7, r1 <== NOT EXECUTED
30006e9c: e1a04002 mov r4, r2 <== NOT EXECUTED
30006ea0: e1a08003 mov r8, r3 <== NOT EXECUTED
FILE *fp;
int match;
init_etc_passwd_group();
30006ea4: ebffffc6 bl 30006dc4 <init_etc_passwd_group> <== NOT EXECUTED
if ((fp = fopen("/etc/group", "r")) == NULL)
30006ea8: e59f00a8 ldr r0, [pc, #168] ; 30006f58 <getgr_r+0xcc> <== NOT EXECUTED 30006eac: e59f10a8 ldr r1, [pc, #168] ; 30006f5c <getgr_r+0xd0> <== NOT EXECUTED 30006eb0: eb002ace bl 300119f0 <fopen> <== NOT EXECUTED 30006eb4: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30006eb8: 1a000004 bne 30006ed0 <getgr_r+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30006ebc: eb0028a6 bl 3001115c <__errno> <== NOT EXECUTED
30006ec0: e3a03016 mov r3, #22 <== NOT EXECUTED
30006ec4: e5803000 str r3, [r0] <== NOT EXECUTED
30006ec8: e3e00000 mvn r0, #0 <== NOT EXECUTED
30006ecc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
30006ed0: e1a00005 mov r0, r5 <== NOT EXECUTED 30006ed4: e1a01004 mov r1, r4 <== NOT EXECUTED 30006ed8: e1a02008 mov r2, r8 <== NOT EXECUTED 30006edc: e1a0300a mov r3, sl <== NOT EXECUTED 30006ee0: ebffff26 bl 30006b80 <scangr> <== NOT EXECUTED 30006ee4: e3500000 cmp r0, #0 <== NOT EXECUTED 30006ee8: 0a000013 beq 30006f3c <getgr_r+0xb0> <== NOT EXECUTED
goto error_einval;
if (name) {
30006eec: e3560000 cmp r6, #0 <== NOT EXECUTED 30006ef0: 0a000005 beq 30006f0c <getgr_r+0x80> <== NOT EXECUTED
match = (strcmp(grp->gr_name, name) == 0);
30006ef4: e5940000 ldr r0, [r4] <== NOT EXECUTED 30006ef8: e1a01006 mov r1, r6 <== NOT EXECUTED 30006efc: eb00300c bl 30012f34 <strcmp> <== NOT EXECUTED 30006f00: e2700001 rsbs r0, r0, #1 <== NOT EXECUTED 30006f04: 33a00000 movcc r0, #0 <== NOT EXECUTED 30006f08: ea000003 b 30006f1c <getgr_r+0x90> <== NOT EXECUTED
} else {
match = (grp->gr_gid == gid);
30006f0c: e1d400b8 ldrh r0, [r4, #8] <== NOT EXECUTED 30006f10: e1500007 cmp r0, r7 <== NOT EXECUTED 30006f14: 13a00000 movne r0, #0 <== NOT EXECUTED 30006f18: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
if (match) {
30006f1c: e3500000 cmp r0, #0 <== NOT EXECUTED 30006f20: 0affffea beq 30006ed0 <getgr_r+0x44> <== NOT EXECUTED
fclose(fp);
30006f24: e1a00005 mov r0, r5 <== NOT EXECUTED 30006f28: eb0028d9 bl 30011294 <fclose> <== NOT EXECUTED
*result = grp;
30006f2c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
return 0;
30006f30: e3a00000 mov r0, #0 <== NOT EXECUTED
match = (grp->gr_gid == gid);
}
if (match) {
fclose(fp);
*result = grp;
30006f34: e5834000 str r4, [r3] <== NOT EXECUTED
return 0;
30006f38: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
}
error_einval:
fclose(fp);
30006f3c: e1a00005 mov r0, r5 <== NOT EXECUTED 30006f40: eb0028d3 bl 30011294 <fclose> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30006f44: eb002884 bl 3001115c <__errno> <== NOT EXECUTED 30006f48: e3a03016 mov r3, #22 <== NOT EXECUTED 30006f4c: e5803000 str r3, [r0] <== NOT EXECUTED 30006f50: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
30006f54: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000724c <getgrent>:
struct group *getgrent(void)
{
3000724c: e92d4010 push {r4, lr} <== NOT EXECUTED
if (group_fp == NULL)
30007250: e59f4024 ldr r4, [pc, #36] ; 3000727c <getgrent+0x30> <== NOT EXECUTED
30007254: e59401c4 ldr r0, [r4, #452] ; 0x1c4 <== NOT EXECUTED
30007258: e3500000 cmp r0, #0 <== NOT EXECUTED
3000725c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return NULL;
if (!scangr(group_fp, &grent, grbuf, sizeof grbuf))
30007260: e28410ec add r1, r4, #236 ; 0xec <== NOT EXECUTED 30007264: e28420fc add r2, r4, #252 ; 0xfc <== NOT EXECUTED 30007268: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 3000726c: ebfffe43 bl 30006b80 <scangr> <== NOT EXECUTED
return NULL;
30007270: e3500000 cmp r0, #0 <== NOT EXECUTED 30007274: 128400ec addne r0, r4, #236 ; 0xec <== NOT EXECUTED
return &grent; }
30007278: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30007214 <getgrgid>:
struct group *getgrgid(
gid_t gid
)
{
30007214: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
30007218: e59f1028 ldr r1, [pc, #40] ; 30007248 <getgrgid+0x34> <== NOT EXECUTED 3000721c: e28d3004 add r3, sp, #4 <== NOT EXECUTED
}
struct group *getgrgid(
gid_t gid
)
{
30007220: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
30007224: e58d3000 str r3, [sp] <== NOT EXECUTED 30007228: e2812010 add r2, r1, #16 <== NOT EXECUTED 3000722c: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 30007230: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 30007234: ebffffe9 bl 300071e0 <getgrgid_r> <== NOT EXECUTED 30007238: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
3000723c: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
return NULL;
30007240: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
30007244: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
300071e0 <getgrgid_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
300071e0: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
return getgr_r(NULL, gid, grp, buffer, bufsize, result);
300071e4: e58d3000 str r3, [sp] <== NOT EXECUTED 300071e8: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
300071ec: e1a0e001 mov lr, r1 <== NOT EXECUTED 300071f0: e1a0c002 mov ip, r2 <== NOT EXECUTED 300071f4: e1a01800 lsl r1, r0, #16 <== NOT EXECUTED
return getgr_r(NULL, gid, grp, buffer, bufsize, result);
300071f8: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 300071fc: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 30007200: e1a0200e mov r2, lr <== NOT EXECUTED 30007204: e1a0300c mov r3, ip <== NOT EXECUTED 30007208: e3a00000 mov r0, #0 <== NOT EXECUTED 3000720c: ebffff1e bl 30006e8c <getgr_r> <== NOT EXECUTED
}
30007210: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
300071b0 <getgrnam>:
struct group *getgrnam(
const char *name
)
{
300071b0: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
300071b4: e59f1020 ldr r1, [pc, #32] ; 300071dc <getgrnam+0x2c> <== NOT EXECUTED 300071b8: e28d3004 add r3, sp, #4 <== NOT EXECUTED 300071bc: e58d3000 str r3, [sp] <== NOT EXECUTED 300071c0: e2812010 add r2, r1, #16 <== NOT EXECUTED 300071c4: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 300071c8: ebffffed bl 30007184 <getgrnam_r> <== NOT EXECUTED 300071cc: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
300071d0: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
return NULL;
300071d4: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
300071d8: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
30007184 <getgrnam_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
30007184: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
return getgr_r(name, 0, grp, buffer, bufsize, result);
30007188: e58d3000 str r3, [sp] <== NOT EXECUTED 3000718c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
30007190: e1a0e001 mov lr, r1 <== NOT EXECUTED 30007194: e1a0c002 mov ip, r2 <== NOT EXECUTED
return getgr_r(name, 0, grp, buffer, bufsize, result);
30007198: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000719c: e3a01000 mov r1, #0 <== NOT EXECUTED 300071a0: e1a0200e mov r2, lr <== NOT EXECUTED 300071a4: e1a0300c mov r3, ip <== NOT EXECUTED 300071a8: ebffff37 bl 30006e8c <getgr_r> <== NOT EXECUTED
}
300071ac: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
300068f8 <getgroups>:
int gidsetsize __attribute__((unused)),
gid_t grouplist[] __attribute__((unused))
)
{
return 0; /* no supplemental group ids */
}
300068f8: e3a00000 mov r0, #0 <== NOT EXECUTED 300068fc: e12fff1e bx lr <== NOT EXECUTED
3000694c <getlogin>:
* 4.2.4 Get User Name, P1003.1b-1993, p. 87
*
* NOTE: P1003.1c/D10, p. 49 adds getlogin_r().
*/
char *getlogin( void )
{
3000694c: e92d4010 push {r4, lr} <== NOT EXECUTED
(void) getlogin_r( _POSIX_types_Getlogin_buffer, LOGIN_NAME_MAX );
30006950: e59f4018 ldr r4, [pc, #24] ; 30006970 <getlogin+0x24> <== NOT EXECUTED 30006954: e3a01009 mov r1, #9 <== NOT EXECUTED 30006958: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000695c: e280003a add r0, r0, #58 ; 0x3a <== NOT EXECUTED 30006960: ebffffe6 bl 30006900 <getlogin_r> <== NOT EXECUTED
return _POSIX_types_Getlogin_buffer;
30006964: e5940000 ldr r0, [r4] <== NOT EXECUTED
}
30006968: e280003a add r0, r0, #58 ; 0x3a <== NOT EXECUTED
3000696c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30006900 <getlogin_r>:
*/
int getlogin_r(
char *name,
size_t namesize
)
{
30006900: e92d4010 push {r4, lr} <== NOT EXECUTED
struct passwd *pw;
char *pname;
if ( !name )
30006904: e2504000 subs r4, r0, #0 <== NOT EXECUTED
return EFAULT;
30006908: 03a0000e moveq r0, #14 <== NOT EXECUTED
)
{
struct passwd *pw;
char *pname;
if ( !name )
3000690c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EFAULT;
if ( namesize < LOGIN_NAME_MAX )
30006910: e3510008 cmp r1, #8 <== NOT EXECUTED 30006914: 9a000009 bls 30006940 <getlogin_r+0x40> <== NOT EXECUTED
return ERANGE;
/* Set the pointer to a default name */
pname = "";
pw = getpwuid(getuid());
30006918: eb000287 bl 3000733c <getuid> <== NOT EXECUTED 3000691c: eb0001e8 bl 300070c4 <getpwuid> <== NOT EXECUTED
if ( pw )
30006920: e3500000 cmp r0, #0 <== NOT EXECUTED
pname = pw->pw_name;
30006924: 15901000 ldrne r1, [r0] <== NOT EXECUTED
if ( namesize < LOGIN_NAME_MAX )
return ERANGE;
/* Set the pointer to a default name */
pname = "";
30006928: 059f1018 ldreq r1, [pc, #24] ; 30006948 <getlogin_r+0x48> <== NOT EXECUTED
pw = getpwuid(getuid());
if ( pw )
pname = pw->pw_name;
strncpy( name, pname, LOGIN_NAME_MAX );
3000692c: e1a00004 mov r0, r4 <== NOT EXECUTED 30006930: e3a02009 mov r2, #9 <== NOT EXECUTED 30006934: eb003272 bl 30013304 <strncpy> <== NOT EXECUTED
return 0;
30006938: e3a00000 mov r0, #0 <== NOT EXECUTED
3000693c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( !name )
return EFAULT;
if ( namesize < LOGIN_NAME_MAX )
return ERANGE;
30006940: e3a00022 mov r0, #34 ; 0x22 <== NOT EXECUTED
if ( pw )
pname = pw->pw_name;
strncpy( name, pname, LOGIN_NAME_MAX );
return 0;
}
30006944: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30006974 <getpgrp>:
* This always succeeds and returns the process group id. For rtems,
* this will always be the local node;
*/
return _Objects_Local_node;
}
30006974: e3a00001 mov r0, #1 <== NOT EXECUTED 30006978: e12fff1e bx lr <== NOT EXECUTED
30006990 <getppid>:
*/
pid_t getppid( void )
{
return _POSIX_types_Ppid;
}
30006990: e59f3004 ldr r3, [pc, #4] ; 3000699c <getppid+0xc> <== NOT EXECUTED 30006994: e5930000 ldr r0, [r3] <== NOT EXECUTED 30006998: e12fff1e bx lr <== NOT EXECUTED
30006f60 <getpw_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
30006f60: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
30006f64: e59da01c ldr sl, [sp, #28] <== NOT EXECUTED
30006f68: e1a06000 mov r6, r0 <== NOT EXECUTED
30006f6c: e1a07001 mov r7, r1 <== NOT EXECUTED
30006f70: e1a04002 mov r4, r2 <== NOT EXECUTED
30006f74: e1a08003 mov r8, r3 <== NOT EXECUTED
FILE *fp;
int match;
init_etc_passwd_group();
30006f78: ebffff91 bl 30006dc4 <init_etc_passwd_group> <== NOT EXECUTED
if ((fp = fopen("/etc/passwd", "r")) == NULL)
30006f7c: e59f00a8 ldr r0, [pc, #168] ; 3000702c <getpw_r+0xcc> <== NOT EXECUTED 30006f80: e59f10a8 ldr r1, [pc, #168] ; 30007030 <getpw_r+0xd0> <== NOT EXECUTED 30006f84: eb002a99 bl 300119f0 <fopen> <== NOT EXECUTED 30006f88: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30006f8c: 1a000004 bne 30006fa4 <getpw_r+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30006f90: eb002871 bl 3001115c <__errno> <== NOT EXECUTED
30006f94: e3a03016 mov r3, #22 <== NOT EXECUTED
30006f98: e5803000 str r3, [r0] <== NOT EXECUTED
30006f9c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30006fa0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize))
30006fa4: e1a00005 mov r0, r5 <== NOT EXECUTED 30006fa8: e1a01004 mov r1, r4 <== NOT EXECUTED 30006fac: e1a02008 mov r2, r8 <== NOT EXECUTED 30006fb0: e1a0300a mov r3, sl <== NOT EXECUTED 30006fb4: ebffff3a bl 30006ca4 <scanpw> <== NOT EXECUTED 30006fb8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006fbc: 0a000013 beq 30007010 <getpw_r+0xb0> <== NOT EXECUTED
goto error_einval;
if (name) {
30006fc0: e3560000 cmp r6, #0 <== NOT EXECUTED 30006fc4: 0a000005 beq 30006fe0 <getpw_r+0x80> <== NOT EXECUTED
match = (strcmp(pwd->pw_name, name) == 0);
30006fc8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30006fcc: e1a01006 mov r1, r6 <== NOT EXECUTED 30006fd0: eb002fd7 bl 30012f34 <strcmp> <== NOT EXECUTED 30006fd4: e2700001 rsbs r0, r0, #1 <== NOT EXECUTED 30006fd8: 33a00000 movcc r0, #0 <== NOT EXECUTED 30006fdc: ea000003 b 30006ff0 <getpw_r+0x90> <== NOT EXECUTED
} else {
match = (pwd->pw_uid == uid);
30006fe0: e1d400b8 ldrh r0, [r4, #8] <== NOT EXECUTED 30006fe4: e1500007 cmp r0, r7 <== NOT EXECUTED 30006fe8: 13a00000 movne r0, #0 <== NOT EXECUTED 30006fec: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
if (match) {
30006ff0: e3500000 cmp r0, #0 <== NOT EXECUTED 30006ff4: 0affffea beq 30006fa4 <getpw_r+0x44> <== NOT EXECUTED
fclose(fp);
30006ff8: e1a00005 mov r0, r5 <== NOT EXECUTED 30006ffc: eb0028a4 bl 30011294 <fclose> <== NOT EXECUTED
*result = pwd;
30007000: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
return 0;
30007004: e3a00000 mov r0, #0 <== NOT EXECUTED
match = (pwd->pw_uid == uid);
}
if (match) {
fclose(fp);
*result = pwd;
30007008: e5834000 str r4, [r3] <== NOT EXECUTED
return 0;
3000700c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
}
error_einval:
fclose(fp);
30007010: e1a00005 mov r0, r5 <== NOT EXECUTED 30007014: eb00289e bl 30011294 <fclose> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30007018: eb00284f bl 3001115c <__errno> <== NOT EXECUTED 3000701c: e3a03016 mov r3, #22 <== NOT EXECUTED 30007020: e5803000 str r3, [r0] <== NOT EXECUTED 30007024: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
30007028: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
300070fc <getpwent>:
struct passwd *getpwent(void)
{
300070fc: e92d4010 push {r4, lr} <== NOT EXECUTED
if (passwd_fp == NULL)
30007100: e59f4024 ldr r4, [pc, #36] ; 3000712c <getpwent+0x30> <== NOT EXECUTED
30007104: e59400e8 ldr r0, [r4, #232] ; 0xe8 <== NOT EXECUTED
30007108: e3500000 cmp r0, #0 <== NOT EXECUTED
3000710c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return NULL;
if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf))
30007110: e2841004 add r1, r4, #4 <== NOT EXECUTED 30007114: e2842020 add r2, r4, #32 <== NOT EXECUTED 30007118: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 3000711c: ebfffee0 bl 30006ca4 <scanpw> <== NOT EXECUTED
return NULL;
30007120: e3500000 cmp r0, #0 <== NOT EXECUTED 30007124: 12840004 addne r0, r4, #4 <== NOT EXECUTED
return &pwent; }
30007128: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30007060 <getpwnam>:
struct passwd *getpwnam(
const char *name
)
{
30007060: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
30007064: e59f1020 ldr r1, [pc, #32] ; 3000708c <getpwnam+0x2c> <== NOT EXECUTED 30007068: e28d3004 add r3, sp, #4 <== NOT EXECUTED 3000706c: e58d3000 str r3, [sp] <== NOT EXECUTED 30007070: e281201c add r2, r1, #28 <== NOT EXECUTED 30007074: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 30007078: ebffffed bl 30007034 <getpwnam_r> <== NOT EXECUTED 3000707c: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
30007080: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
return NULL;
30007084: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
30007088: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
30007034 <getpwnam_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
30007034: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
return getpw_r(name, 0, pwd, buffer, bufsize, result);
30007038: e58d3000 str r3, [sp] <== NOT EXECUTED 3000703c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
30007040: e1a0e001 mov lr, r1 <== NOT EXECUTED 30007044: e1a0c002 mov ip, r2 <== NOT EXECUTED
return getpw_r(name, 0, pwd, buffer, bufsize, result);
30007048: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000704c: e3a01000 mov r1, #0 <== NOT EXECUTED 30007050: e1a0200e mov r2, lr <== NOT EXECUTED 30007054: e1a0300c mov r3, ip <== NOT EXECUTED 30007058: ebffffc0 bl 30006f60 <getpw_r> <== NOT EXECUTED
}
3000705c: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
300070c4 <getpwuid>:
struct passwd *getpwuid(
uid_t uid
)
{
300070c4: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
300070c8: e59f1028 ldr r1, [pc, #40] ; 300070f8 <getpwuid+0x34> <== NOT EXECUTED 300070cc: e28d3004 add r3, sp, #4 <== NOT EXECUTED
}
struct passwd *getpwuid(
uid_t uid
)
{
300070d0: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
300070d4: e58d3000 str r3, [sp] <== NOT EXECUTED 300070d8: e281201c add r2, r1, #28 <== NOT EXECUTED 300070dc: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 300070e0: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 300070e4: ebffffe9 bl 30007090 <getpwuid_r> <== NOT EXECUTED 300070e8: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
300070ec: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
return NULL;
300070f0: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
300070f4: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
30007090 <getpwuid_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
30007090: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
return getpw_r(NULL, uid, pwd, buffer, bufsize, result);
30007094: e58d3000 str r3, [sp] <== NOT EXECUTED 30007098: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
3000709c: e1a0e001 mov lr, r1 <== NOT EXECUTED 300070a0: e1a0c002 mov ip, r2 <== NOT EXECUTED 300070a4: e1a01800 lsl r1, r0, #16 <== NOT EXECUTED
return getpw_r(NULL, uid, pwd, buffer, bufsize, result);
300070a8: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 300070ac: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 300070b0: e1a0200e mov r2, lr <== NOT EXECUTED 300070b4: e1a0300c mov r3, ip <== NOT EXECUTED 300070b8: e3a00000 mov r0, #0 <== NOT EXECUTED 300070bc: ebffffa7 bl 30006f60 <getpw_r> <== NOT EXECUTED
}
300070c0: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
300065f0 <getrusage>:
#include <rtems.h>
#include <rtems/seterr.h>
int getrusage(int who, struct rusage *usage)
{
300065f0: e92d4073 push {r0, r1, r4, r5, r6, lr} <== NOT EXECUTED
struct timespec uptime;
struct timeval rtime;
if ( !usage )
300065f4: e2515000 subs r5, r1, #0 <== NOT EXECUTED
#include <rtems.h>
#include <rtems/seterr.h>
int getrusage(int who, struct rusage *usage)
{
300065f8: e1a04000 mov r4, r0 <== NOT EXECUTED
struct timespec uptime;
struct timeval rtime;
if ( !usage )
300065fc: 1a000002 bne 3000660c <getrusage+0x1c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
30006600: eb0027ac bl 300104b8 <__errno> <== NOT EXECUTED 30006604: e3a0300e mov r3, #14 <== NOT EXECUTED 30006608: ea000015 b 30006664 <getrusage+0x74> <== NOT EXECUTED
* RTEMS only has a single process so there are no children.
* The single process has been running since the system
* was booted and since there is no distinction between system
* and user time, we will just report the uptime.
*/
if (who == RUSAGE_SELF) {
3000660c: e3500000 cmp r0, #0 <== NOT EXECUTED 30006610: 1a00000a bne 30006640 <getrusage+0x50> <== NOT EXECUTED
rtems_clock_get_uptime( &uptime );
30006614: e1a0000d mov r0, sp <== NOT EXECUTED 30006618: eb000ae3 bl 300091ac <rtems_clock_get_uptime> <== NOT EXECUTED
rtime.tv_sec = uptime.tv_sec;
rtime.tv_usec = uptime.tv_nsec / 1000;
3000661c: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 30006620: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30006624: eb003581 bl 30013c30 <__aeabi_idiv> <== NOT EXECUTED
* and user time, we will just report the uptime.
*/
if (who == RUSAGE_SELF) {
rtems_clock_get_uptime( &uptime );
rtime.tv_sec = uptime.tv_sec;
30006628: e59d6000 ldr r6, [sp] <== NOT EXECUTED
rtime.tv_usec = uptime.tv_nsec / 1000;
3000662c: e5850004 str r0, [r5, #4] <== NOT EXECUTED 30006630: e5856000 str r6, [r5] <== NOT EXECUTED 30006634: e5856008 str r6, [r5, #8] <== NOT EXECUTED 30006638: e585000c str r0, [r5, #12] <== NOT EXECUTED 3000663c: ea000004 b 30006654 <getrusage+0x64> <== NOT EXECUTED
usage->ru_stime = rtime;
return 0;
}
if (who == RUSAGE_CHILDREN) {
30006640: e3700001 cmn r0, #1 <== NOT EXECUTED 30006644: 1a000004 bne 3000665c <getrusage+0x6c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30006648: eb00279a bl 300104b8 <__errno> <== NOT EXECUTED 3000664c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30006650: e5803000 str r3, [r0] <== NOT EXECUTED 30006654: e1a00004 mov r0, r4 <== NOT EXECUTED 30006658: ea000003 b 3000666c <getrusage+0x7c> <== NOT EXECUTED
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000665c: eb002795 bl 300104b8 <__errno> <== NOT EXECUTED 30006660: e3a03016 mov r3, #22 <== NOT EXECUTED 30006664: e5803000 str r3, [r0] <== NOT EXECUTED 30006668: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000666c: e8bd807c pop {r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
30006348 <gettimeofday>:
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
30006348: e92d4033 push {r0, r1, r4, r5, lr}
/* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp )
3000634c: e2504000 subs r4, r0, #0
30006350: 1a000004 bne 30006368 <gettimeofday+0x20>
rtems_set_errno_and_return_minus_one( EFAULT );
30006354: eb0027b8 bl 3001023c <__errno> <== NOT EXECUTED 30006358: e3a0300e mov r3, #14 <== NOT EXECUTED 3000635c: e5803000 str r3, [r0] <== NOT EXECUTED 30006360: e3e00000 mvn r0, #0 <== NOT EXECUTED 30006364: ea00000c b 3000639c <gettimeofday+0x54> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30006368: e10f5000 mrs r5, CPSR 3000636c: e3853080 orr r3, r5, #128 ; 0x80 30006370: e129f003 msr CPSR_fc, r3
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
_TOD_Get( &now );
30006374: e1a0000d mov r0, sp 30006378: eb000f8c bl 3000a1b0 <_TOD_Get>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000637c: e129f005 msr CPSR_fc, r5
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
30006380: e59d3000 ldr r3, [sp]
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
30006384: e59d0004 ldr r0, [sp, #4]
time->tv_sec = now.tv_sec;
30006388: e5843000 str r3, [r4]
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
3000638c: e3a01ffa mov r1, #1000 ; 0x3e8 30006390: eb0035b2 bl 30013a60 <__aeabi_idiv>
time->tv_sec = now.tv_sec;
time->tv_usec = useconds;
30006394: 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;
30006398: e3a00000 mov r0, #0
}
3000639c: e8bd803c pop {r2, r3, r4, r5, pc}
3000733c <getuid>:
* 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs,
* P1003.1b-1993, p. 84
*/
uid_t getuid( void )
{
return _POSIX_types_Uid;
3000733c: e59f3008 ldr r3, [pc, #8] ; 3000734c <getuid+0x10> <== NOT EXECUTED 30007340: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
30007344: e1d303b2 ldrh r0, [r3, #50] ; 0x32 <== NOT EXECUTED 30007348: e12fff1e bx lr <== NOT EXECUTED
3000fa30 <imfs_dir_open>:
IMFS_jnode_t *the_jnode;
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
3000fa30: e5903018 ldr r3, [r0, #24]
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
3000fa34: e92d4010 push {r4, lr}
IMFS_jnode_t *the_jnode;
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
3000fa38: e593304c ldr r3, [r3, #76] ; 0x4c 3000fa3c: e3530001 cmp r3, #1
3000fa40: 1a000005 bne 3000fa5c <imfs_dir_open+0x2c>
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
3000fa44: e3a03000 mov r3, #0 3000fa48: e3a04000 mov r4, #0 3000fa4c: e580300c str r3, [r0, #12] 3000fa50: e5804010 str r4, [r0, #16]
return 0;
3000fa54: e3a00000 mov r0, #0
3000fa58: e8bd8010 pop {r4, pc}
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
return -1; /* It wasn't a directory --> return error */
3000fa5c: e3e00000 mvn r0, #0 <== NOT EXECUTED
iop->offset = 0;
return 0;
}
3000fa60: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000fc8c <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
3000fc8c: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
3000fc90: e5914000 ldr r4, [r1]
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
3000fc94: e5942050 ldr r2, [r4, #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 );
3000fc98: e2843054 add r3, r4, #84 ; 0x54 3000fc9c: e1520003 cmp r2, r3
3000fca0: 0a000002 beq 3000fcb0 <imfs_dir_rmnod+0x24>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
3000fca4: eb000164 bl 3001023c <__errno> <== NOT EXECUTED 3000fca8: e3a0305a mov r3, #90 ; 0x5a <== NOT EXECUTED 3000fcac: ea000008 b 3000fcd4 <imfs_dir_rmnod+0x48> <== NOT EXECUTED
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
3000fcb0: e5913010 ldr r3, [r1, #16] 3000fcb4: e593301c ldr r3, [r3, #28] 3000fcb8: e1530004 cmp r3, r4
3000fcbc: 0a000002 beq 3000fccc <imfs_dir_rmnod+0x40>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
3000fcc0: e594505c ldr r5, [r4, #92] ; 0x5c 3000fcc4: e3550000 cmp r5, #0
3000fcc8: 0a000004 beq 3000fce0 <imfs_dir_rmnod+0x54>
rtems_set_errno_and_return_minus_one( EBUSY );
3000fccc: eb00015a bl 3001023c <__errno> <== NOT EXECUTED
3000fcd0: e3a03010 mov r3, #16 <== NOT EXECUTED
3000fcd4: e5803000 str r3, [r0] <== NOT EXECUTED
3000fcd8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000fcdc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
IMFS_create_orphan( the_jnode );
3000fce0: e1a00004 mov r0, r4 3000fce4: ebfff6bb bl 3000d7d8 <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
3000fce8: e1a00004 mov r0, r4 3000fcec: ebfff6ca bl 3000d81c <IMFS_check_node_remove>
return 0;
3000fcf0: e1a00005 mov r0, r5
}
3000fcf4: e8bd8030 pop {r4, r5, pc}
30006dc4 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
30006dc4: e92d4010 push {r4, lr} <== NOT EXECUTED
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
30006dc8: e59f3098 ldr r3, [pc, #152] ; 30006e68 <init_etc_passwd_group+0xa4><== NOT EXECUTED
30006dcc: e5d32000 ldrb r2, [r3] <== NOT EXECUTED
30006dd0: e3520000 cmp r2, #0 <== NOT EXECUTED
30006dd4: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return;
etc_passwd_initted = 1;
30006dd8: e2822001 add r2, r2, #1 <== NOT EXECUTED 30006ddc: e5c32000 strb r2, [r3] <== NOT EXECUTED
mkdir("/etc", 0777);
30006de0: e59f1084 ldr r1, [pc, #132] ; 30006e6c <init_etc_passwd_group+0xa8><== NOT EXECUTED 30006de4: e59f0084 ldr r0, [pc, #132] ; 30006e70 <init_etc_passwd_group+0xac><== NOT EXECUTED 30006de8: eb000222 bl 30007678 <mkdir> <== NOT EXECUTED
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
30006dec: e59f0080 ldr r0, [pc, #128] ; 30006e74 <init_etc_passwd_group+0xb0><== NOT EXECUTED 30006df0: e59f1080 ldr r1, [pc, #128] ; 30006e78 <init_etc_passwd_group+0xb4><== NOT EXECUTED 30006df4: eb002afd bl 300119f0 <fopen> <== NOT EXECUTED 30006df8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006dfc: 1a000008 bne 30006e24 <init_etc_passwd_group+0x60> <== NOT EXECUTED
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
30006e00: e59f006c ldr r0, [pc, #108] ; 30006e74 <init_etc_passwd_group+0xb0><== NOT EXECUTED 30006e04: e59f1070 ldr r1, [pc, #112] ; 30006e7c <init_etc_passwd_group+0xb8><== NOT EXECUTED 30006e08: eb002af8 bl 300119f0 <fopen> <== NOT EXECUTED 30006e0c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30006e10: 0a000004 beq 30006e28 <init_etc_passwd_group+0x64> <== NOT EXECUTED
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
30006e14: e59f0064 ldr r0, [pc, #100] ; 30006e80 <init_etc_passwd_group+0xbc><== NOT EXECUTED 30006e18: e1a01004 mov r1, r4 <== NOT EXECUTED 30006e1c: eb002b1c bl 30011a94 <fputs> <== NOT EXECUTED
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
30006e20: e1a00004 mov r0, r4 <== NOT EXECUTED 30006e24: eb00291a bl 30011294 <fclose> <== NOT EXECUTED
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
30006e28: e59f0054 ldr r0, [pc, #84] ; 30006e84 <init_etc_passwd_group+0xc0><== NOT EXECUTED 30006e2c: e59f1044 ldr r1, [pc, #68] ; 30006e78 <init_etc_passwd_group+0xb4><== NOT EXECUTED 30006e30: eb002aee bl 300119f0 <fopen> <== NOT EXECUTED 30006e34: e3500000 cmp r0, #0 <== NOT EXECUTED 30006e38: 1a000008 bne 30006e60 <init_etc_passwd_group+0x9c> <== NOT EXECUTED
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
30006e3c: e59f0040 ldr r0, [pc, #64] ; 30006e84 <init_etc_passwd_group+0xc0><== NOT EXECUTED
30006e40: e59f1034 ldr r1, [pc, #52] ; 30006e7c <init_etc_passwd_group+0xb8><== NOT EXECUTED
30006e44: eb002ae9 bl 300119f0 <fopen> <== NOT EXECUTED
30006e48: e2504000 subs r4, r0, #0 <== NOT EXECUTED
30006e4c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
fprintf( fp, "root:x:0:root\n"
30006e50: e59f0030 ldr r0, [pc, #48] ; 30006e88 <init_etc_passwd_group+0xc4><== NOT EXECUTED 30006e54: e1a01004 mov r1, r4 <== NOT EXECUTED 30006e58: eb002b0d bl 30011a94 <fputs> <== NOT EXECUTED
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
30006e5c: e1a00004 mov r0, r4 <== NOT EXECUTED
} }
30006e60: e8bd4010 pop {r4, lr} <== NOT EXECUTED
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
30006e64: ea00290a b 30011294 <fclose> <== NOT EXECUTED
30007fd8 <iproc>:
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
30007fd8: e5913030 ldr r3, [r1, #48] ; 0x30 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30007fdc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
30007fe0: e3130020 tst r3, #32 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30007fe4: e20050ff and r5, r0, #255 ; 0xff <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
30007fe8: 1200507f andne r5, r0, #127 ; 0x7f <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
30007fec: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30007ff0: e1a04001 mov r4, r1 <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
30007ff4: 0a000007 beq 30008018 <iproc+0x40> <== NOT EXECUTED
c = tolower (c);
30007ff8: e59f2164 ldr r2, [pc, #356] ; 30008164 <iproc+0x18c> <== NOT EXECUTED 30007ffc: e5922000 ldr r2, [r2] <== NOT EXECUTED 30008000: e0822005 add r2, r2, r5 <== NOT EXECUTED 30008004: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED 30008008: e2022003 and r2, r2, #3 <== NOT EXECUTED 3000800c: e3520001 cmp r2, #1 <== NOT EXECUTED 30008010: 02855020 addeq r5, r5, #32 <== NOT EXECUTED 30008014: e20550ff and r5, r5, #255 ; 0xff <== NOT EXECUTED
if (c == '\r') {
30008018: e355000d cmp r5, #13 <== NOT EXECUTED 3000801c: 1a000005 bne 30008038 <iproc+0x60> <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
30008020: e3130080 tst r3, #128 ; 0x80 <== NOT EXECUTED 30008024: 1a000048 bne 3000814c <iproc+0x174> <== NOT EXECUTED
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
30008028: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3000802c: 03a0500d moveq r5, #13 <== NOT EXECUTED 30008030: 13a0500a movne r5, #10 <== NOT EXECUTED 30008034: ea000007 b 30008058 <iproc+0x80> <== NOT EXECUTED
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
30008038: e355000a cmp r5, #10 <== NOT EXECUTED 3000803c: 1a000003 bne 30008050 <iproc+0x78> <== NOT EXECUTED
c = '\r';
30008040: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED 30008044: 03a0500a moveq r5, #10 <== NOT EXECUTED 30008048: 13a0500d movne r5, #13 <== NOT EXECUTED 3000804c: ea000001 b 30008058 <iproc+0x80> <== NOT EXECUTED
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
30008050: e3550000 cmp r5, #0 <== NOT EXECUTED 30008054: 0a00002c beq 3000810c <iproc+0x134> <== NOT EXECUTED 30008058: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 3000805c: e3130002 tst r3, #2 <== NOT EXECUTED 30008060: 0a000029 beq 3000810c <iproc+0x134> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
30008064: e5d42043 ldrb r2, [r4, #67] ; 0x43 <== NOT EXECUTED 30008068: e1520005 cmp r2, r5 <== NOT EXECUTED
erase (tty, 0);
3000806c: 01a00004 moveq r0, r4 <== NOT EXECUTED 30008070: 03a01000 moveq r1, #0 <== NOT EXECUTED
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
30008074: 0a000004 beq 3000808c <iproc+0xb4> <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
30008078: e5d42044 ldrb r2, [r4, #68] ; 0x44 <== NOT EXECUTED 3000807c: e1520005 cmp r2, r5 <== NOT EXECUTED 30008080: 1a000003 bne 30008094 <iproc+0xbc> <== NOT EXECUTED
erase (tty, 1);
30008084: e1a00004 mov r0, r4 <== NOT EXECUTED 30008088: e3a01001 mov r1, #1 <== NOT EXECUTED 3000808c: ebffff60 bl 30007e14 <erase> <== NOT EXECUTED 30008090: ea00002d b 3000814c <iproc+0x174> <== NOT EXECUTED
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
30008094: e5d42045 ldrb r2, [r4, #69] ; 0x45 <== NOT EXECUTED 30008098: e1520005 cmp r2, r5 <== NOT EXECUTED 3000809c: 0a00002c beq 30008154 <iproc+0x17c> <== NOT EXECUTED
return 1;
} else if (c == '\n') {
300080a0: e355000a cmp r5, #10 <== NOT EXECUTED 300080a4: 1a000008 bne 300080cc <iproc+0xf4> <== NOT EXECUTED
if (tty->termios.c_lflag & (ECHO | ECHONL))
300080a8: e3130048 tst r3, #72 ; 0x48 <== NOT EXECUTED
echo (c, tty);
300080ac: 11a00005 movne r0, r5 <== NOT EXECUTED 300080b0: 11a01004 movne r1, r4 <== NOT EXECUTED 300080b4: 1bffff33 blne 30007d88 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
300080b8: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 300080bc: e594201c ldr r2, [r4, #28] <== NOT EXECUTED 300080c0: e3a0100a mov r1, #10 <== NOT EXECUTED 300080c4: e7c21003 strb r1, [r2, r3] <== NOT EXECUTED 300080c8: ea00000c b 30008100 <iproc+0x128> <== NOT EXECUTED
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
300080cc: e5d4204c ldrb r2, [r4, #76] ; 0x4c <== NOT EXECUTED 300080d0: e1520005 cmp r2, r5 <== NOT EXECUTED 300080d4: 0a000002 beq 300080e4 <iproc+0x10c> <== NOT EXECUTED 300080d8: e5d42051 ldrb r2, [r4, #81] ; 0x51 <== NOT EXECUTED 300080dc: e1520005 cmp r2, r5 <== NOT EXECUTED 300080e0: 1a000009 bne 3000810c <iproc+0x134> <== NOT EXECUTED
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
300080e4: e3130008 tst r3, #8 <== NOT EXECUTED
echo (c, tty);
300080e8: 11a00005 movne r0, r5 <== NOT EXECUTED 300080ec: 11a01004 movne r1, r4 <== NOT EXECUTED 300080f0: 1bffff24 blne 30007d88 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
300080f4: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 300080f8: e594201c ldr r2, [r4, #28] <== NOT EXECUTED 300080fc: e7c25003 strb r5, [r2, r3] <== NOT EXECUTED 30008100: e2833001 add r3, r3, #1 <== NOT EXECUTED 30008104: e5843020 str r3, [r4, #32] <== NOT EXECUTED 30008108: ea000011 b 30008154 <iproc+0x17c> <== NOT EXECUTED
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
3000810c: e59f3054 ldr r3, [pc, #84] ; 30008168 <iproc+0x190> <== NOT EXECUTED 30008110: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED 30008114: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30008118: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000811c: e1520003 cmp r2, r3 <== NOT EXECUTED 30008120: aa00000d bge 3000815c <iproc+0x184> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
30008124: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 30008128: e3130008 tst r3, #8 <== NOT EXECUTED
echo (c, tty);
3000812c: 11a00005 movne r0, r5 <== NOT EXECUTED 30008130: 11a01004 movne r1, r4 <== NOT EXECUTED 30008134: 1bffff13 blne 30007d88 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
30008138: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000813c: e594201c ldr r2, [r4, #28] <== NOT EXECUTED 30008140: e7c25003 strb r5, [r2, r3] <== NOT EXECUTED 30008144: e2833001 add r3, r3, #1 <== NOT EXECUTED 30008148: e5843020 str r3, [r4, #32] <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
3000814c: e3a00000 mov r0, #0 <== NOT EXECUTED
30008150: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
30008154: e3a00001 mov r0, #1 <== NOT EXECUTED
30008158: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
3000815c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30008160: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30007350 <issetugid>:
#if defined(RTEMS_NEWLIB) && !defined(HAVE_ISSETUGID)
int issetugid (void)
{
return 0;
}
30007350: e3a00000 mov r0, #0 <== NOT EXECUTED 30007354: e12fff1e bx lr <== NOT EXECUTED
300246c8 <kill>:
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
return 0;
}
300246c8: e3a00000 mov r0, #0 <== NOT EXECUTED 300246cc: e12fff1e bx lr <== NOT EXECUTED
30008880 <lchown>:
int lchown(
const char *path,
uid_t owner,
gid_t group
)
{
30008880: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 30008884: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
return _chown_helper( path, owner, group, false );
30008888: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3000888c: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED 30008890: e3a03000 mov r3, #0 <== NOT EXECUTED 30008894: eaffff11 b 300084e0 <_chown_helper> <== NOT EXECUTED
300097fc <link>:
int link(
const char *existing,
const char *new
)
{
300097fc: e92d4070 push {r4, r5, r6, lr}
30009800: e24dd034 sub sp, sp, #52 ; 0x34
30009804: e1a06000 mov r6, r0
30009808: e1a05001 mov r5, r1
/*
* Get the node we are linking to.
*/
result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
3000980c: eb00364f bl 30017150 <strlen> 30009810: e28d4018 add r4, sp, #24 30009814: e3a03001 mov r3, #1 30009818: e1a01000 mov r1, r0 3000981c: e58d3000 str r3, [sp] 30009820: e1a00006 mov r0, r6 30009824: e3a02000 mov r2, #0 30009828: e1a03004 mov r3, r4 3000982c: ebfffe3c bl 30009124 <rtems_filesystem_evaluate_path>
0, &existing_loc, true );
if ( result != 0 )
30009830: e3500000 cmp r0, #0
30009834: 1a000028 bne 300098dc <link+0xe0>
/*
* Get the parent of the node we are creating.
*/
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
30009838: e28d6004 add r6, sp, #4 3000983c: e1a00005 mov r0, r5 30009840: e28d1030 add r1, sp, #48 ; 0x30 30009844: e1a02006 mov r2, r6 30009848: eb00047f bl 3000aa4c <rtems_filesystem_get_start_loc>
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
3000984c: e59d0030 ldr r0, [sp, #48] ; 0x30 30009850: e1a01006 mov r1, r6 30009854: e0850000 add r0, r5, r0 30009858: e28d202c add r2, sp, #44 ; 0x2c 3000985c: e59d3010 ldr r3, [sp, #16] 30009860: e1a0e00f mov lr, pc 30009864: e593f004 ldr pc, [r3, #4]
if ( result != 0 ) {
30009868: e3500000 cmp r0, #0
3000986c: 0a000002 beq 3000987c <link+0x80>
rtems_filesystem_freenode( &existing_loc );
30009870: e1a00004 mov r0, r4 <== NOT EXECUTED 30009874: ebfffecf bl 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED 30009878: ea000017 b 300098dc <link+0xe0> <== NOT EXECUTED
/*
* Check to see if the caller is trying to link across file system
* boundaries.
*/
if ( parent_loc.mt_entry != existing_loc.mt_entry ) {
3000987c: e59d3028 ldr r3, [sp, #40] ; 0x28 30009880: e59d2014 ldr r2, [sp, #20] 30009884: e1520003 cmp r2, r3
30009888: 0a000007 beq 300098ac <link+0xb0>
rtems_filesystem_freenode( &existing_loc );
3000988c: e1a00004 mov r0, r4 30009890: ebfffec8 bl 300093b8 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &parent_loc );
30009894: e1a00006 mov r0, r6 30009898: ebfffec6 bl 300093b8 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
3000989c: eb002960 bl 30013e24 <__errno> 300098a0: e3a03012 mov r3, #18 300098a4: e5803000 str r3, [r0] 300098a8: ea00000b b 300098dc <link+0xe0>
}
result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
300098ac: e1a01006 mov r1, r6 <== NOT EXECUTED 300098b0: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED 300098b4: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 300098b8: e1a00004 mov r0, r4 <== NOT EXECUTED 300098bc: e1a0e00f mov lr, pc <== NOT EXECUTED 300098c0: e593f008 ldr pc, [r3, #8] <== NOT EXECUTED 300098c4: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &existing_loc );
300098c8: e1a00004 mov r0, r4 <== NOT EXECUTED 300098cc: ebfffeb9 bl 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &parent_loc );
300098d0: e1a00006 mov r0, r6 <== NOT EXECUTED 300098d4: ebfffeb7 bl 300093b8 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
300098d8: ea000000 b 300098e0 <link+0xe4> <== NOT EXECUTED
*/
result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
0, &existing_loc, true );
if ( result != 0 )
return -1;
300098dc: e3e05000 mvn r5, #0
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
return result;
}
300098e0: e1a00005 mov r0, r5
300098e4: e28dd034 add sp, sp, #52 ; 0x34
300098e8: e8bd8070 pop {r4, r5, r6, pc}
30015a00 <lseek>:
{
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
30015a00: e59fc0d4 ldr ip, [pc, #212] ; 30015adc <lseek+0xdc>
off_t lseek(
int fd,
off_t offset,
int whence
)
{
30015a04: e92d4870 push {r4, r5, r6, fp, lr}
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
30015a08: e59cc000 ldr ip, [ip] 30015a0c: e150000c cmp r0, ip
30015a10: 2a000006 bcs 30015a30 <lseek+0x30> iop = rtems_libio_iop( fd );
30015a14: e59fc0c4 ldr ip, [pc, #196] ; 30015ae0 <lseek+0xe0> 30015a18: e3a04038 mov r4, #56 ; 0x38 30015a1c: e59cc000 ldr ip, [ip] 30015a20: e024c490 mla r4, r0, r4, ip
rtems_libio_check_is_open(iop);
30015a24: e5940014 ldr r0, [r4, #20] 30015a28: e3100c01 tst r0, #256 ; 0x100
30015a2c: 1a000002 bne 30015a3c <lseek+0x3c>
30015a30: ebffea01 bl 3001023c <__errno> <== NOT EXECUTED 30015a34: e3a03009 mov r3, #9 <== NOT EXECUTED 30015a38: ea000015 b 30015a94 <lseek+0x94> <== NOT EXECUTED
/*
* Now process the lseek().
*/
old_offset = iop->offset;
switch ( whence ) {
30015a3c: e3530001 cmp r3, #1
/*
* Now process the lseek().
*/
old_offset = iop->offset;
30015a40: e284600c add r6, r4, #12
30015a44: e8960060 ldm r6, {r5, r6}
switch ( whence ) {
30015a48: 0a000006 beq 30015a68 <lseek+0x68>
30015a4c: e3530002 cmp r3, #2
30015a50: 0a000007 beq 30015a74 <lseek+0x74>
30015a54: e3530000 cmp r3, #0
30015a58: 1a00000b bne 30015a8c <lseek+0x8c>
case SEEK_SET:
iop->offset = offset;
30015a5c: e584100c str r1, [r4, #12] 30015a60: e5842010 str r2, [r4, #16]
break;
30015a64: ea00000e b 30015aa4 <lseek+0xa4>
case SEEK_CUR:
iop->offset += offset;
30015a68: e091b005 adds fp, r1, r5 30015a6c: e0a2c006 adc ip, r2, r6 30015a70: ea000002 b 30015a80 <lseek+0x80>
break;
case SEEK_END:
iop->offset = iop->size + offset;
30015a74: e9941800 ldmib r4, {fp, ip}
30015a78: e09bb001 adds fp, fp, r1
30015a7c: e0acc002 adc ip, ip, r2
30015a80: e584b00c str fp, [r4, #12]
30015a84: e584c010 str ip, [r4, #16]
break;
30015a88: ea000005 b 30015aa4 <lseek+0xa4>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30015a8c: ebffe9ea bl 3001023c <__errno> 30015a90: e3a03016 mov r3, #22 30015a94: e5803000 str r3, [r0] 30015a98: e3e02000 mvn r2, #0 30015a9c: e3e03000 mvn r3, #0 30015aa0: ea00000a b 30015ad0 <lseek+0xd0>
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
30015aa4: e594c020 ldr ip, [r4, #32] 30015aa8: e1a00004 mov r0, r4 30015aac: e1a0e00f mov lr, pc 30015ab0: e59cf014 ldr pc, [ip, #20]
if ( status == (off_t) -1 )
30015ab4: e3700001 cmn r0, #1
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
30015ab8: e1a02000 mov r2, r0 30015abc: e1a03001 mov r3, r1
if ( status == (off_t) -1 ) 30015ac0: 1a000002 bne 30015ad0 <lseek+0xd0>
30015ac4: e3710001 cmn r1, #1
iop->offset = old_offset;
30015ac8: 0584500c streq r5, [r4, #12] 30015acc: 05846010 streq r6, [r4, #16]
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
30015ad0: e1a00002 mov r0, r2
30015ad4: e1a01003 mov r1, r3
30015ad8: e8bd8870 pop {r4, r5, r6, fp, pc}
300081a0 <lstat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
300081a0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
300081a4: e2515000 subs r5, r1, #0 <== NOT EXECUTED
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
300081a8: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 300081ac: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
300081b0: 1a000003 bne 300081c4 <lstat+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
300081b4: eb00271b bl 30011e28 <__errno> <== NOT EXECUTED 300081b8: e3a0300e mov r3, #14 <== NOT EXECUTED 300081bc: e5803000 str r3, [r0] <== NOT EXECUTED 300081c0: ea000015 b 3000821c <lstat+0x7c> <== NOT EXECUTED
status = rtems_filesystem_evaluate_path( path, strlen( path ),
300081c4: eb002da7 bl 30013868 <strlen> <== NOT EXECUTED 300081c8: e28d4004 add r4, sp, #4 <== NOT EXECUTED 300081cc: e1a01000 mov r1, r0 <== NOT EXECUTED 300081d0: e3a02000 mov r2, #0 <== NOT EXECUTED 300081d4: e1a00006 mov r0, r6 <== NOT EXECUTED 300081d8: e1a03004 mov r3, r4 <== NOT EXECUTED 300081dc: e58d2000 str r2, [sp] <== NOT EXECUTED 300081e0: ebfffe6e bl 30007ba0 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
300081e4: e2501000 subs r1, r0, #0 <== NOT EXECUTED 300081e8: 1a00000b bne 3000821c <lstat+0x7c> <== NOT EXECUTED
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
300081ec: e3a02048 mov r2, #72 ; 0x48 <== NOT EXECUTED 300081f0: e1a00005 mov r0, r5 <== NOT EXECUTED 300081f4: eb002b87 bl 30013018 <memset> <== NOT EXECUTED
status = (*loc.handlers->fstat_h)( &loc, buf );
300081f8: e1a01005 mov r1, r5 <== NOT EXECUTED 300081fc: e1a00004 mov r0, r4 <== NOT EXECUTED 30008200: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30008204: e1a0e00f mov lr, pc <== NOT EXECUTED 30008208: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED 3000820c: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30008210: e1a00004 mov r0, r4 <== NOT EXECUTED 30008214: ebfffe91 bl 30007c60 <rtems_filesystem_freenode> <== NOT EXECUTED
return status;
30008218: ea000000 b 30008220 <lstat+0x80> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
return -1;
3000821c: e3e05000 mvn r5, #0 <== NOT EXECUTED
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
30008220: e1a00005 mov r0, r5 <== NOT EXECUTED
30008224: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30008228: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300065e0 <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
300065e0: e59f30d0 ldr r3, [pc, #208] ; 300066b8 <malloc+0xd8>
#include "malloc_p.h"
void *malloc(
size_t size
)
{
300065e4: e92d4030 push {r4, r5, lr}
void *return_this;
MSBUMP(malloc_calls, 1);
300065e8: e5932004 ldr r2, [r3, #4]
#include "malloc_p.h"
void *malloc(
size_t size
)
{
300065ec: e1a04000 mov r4, r0
void *return_this;
MSBUMP(malloc_calls, 1);
300065f0: e2822001 add r2, r2, #1 300065f4: e5832004 str r2, [r3, #4]
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
300065f8: ebffffb2 bl 300064c8 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
300065fc: e3540000 cmp r4, #0
return (void *) 0;
30006600: 01a05004 moveq r5, r4
malloc_deferred_frees_process();
/*
* Validate the parameters
*/
if ( !size )
30006604: 0a000029 beq 300066b0 <malloc+0xd0>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30006608: e59f30ac ldr r3, [pc, #172] ; 300066bc <malloc+0xdc> 3000660c: e5933000 ldr r3, [r3] 30006610: e3530003 cmp r3, #3
30006614: 1a000002 bne 30006624 <malloc+0x44>
!malloc_is_system_state_OK() )
30006618: ebffff96 bl 30006478 <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()) &&
3000661c: e2505000 subs r5, r0, #0
30006620: 0a000022 beq 300066b0 <malloc+0xd0>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
30006624: e59f3094 ldr r3, [pc, #148] ; 300066c0 <malloc+0xe0> 30006628: e3a02000 mov r2, #0 3000662c: e5930000 ldr r0, [r3] 30006630: e1a01004 mov r1, r4 30006634: e1a03002 mov r3, r2 30006638: eb0011e7 bl 3000addc <_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 ) {
3000663c: e2505000 subs r5, r0, #0
30006640: 1a00000d bne 3000667c <malloc+0x9c>
if (rtems_malloc_sbrk_helpers)
30006644: e59f3078 ldr r3, [pc, #120] ; 300066c4 <malloc+0xe4> 30006648: e5933000 ldr r3, [r3] 3000664c: e3530000 cmp r3, #0
30006650: 0a000004 beq 30006668 <malloc+0x88>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
30006654: e1a00004 mov r0, r4 <== NOT EXECUTED 30006658: e1a0e00f mov lr, pc <== NOT EXECUTED 3000665c: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
if ( !return_this ) {
30006660: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30006664: 1a000004 bne 3000667c <malloc+0x9c> <== NOT EXECUTED
errno = ENOMEM;
30006668: eb0026f3 bl 3001023c <__errno> 3000666c: e3a0300c mov r3, #12 30006670: e5803000 str r3, [r0]
return (void *) 0;
30006674: e3a05000 mov r5, #0 30006678: ea00000c b 300066b0 <malloc+0xd0>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
3000667c: e59f3044 ldr r3, [pc, #68] ; 300066c8 <malloc+0xe8> 30006680: e5933000 ldr r3, [r3] 30006684: e3530000 cmp r3, #0
(*rtems_malloc_dirty_helper)( return_this, size );
30006688: 11a00005 movne r0, r5 3000668c: 11a01004 movne r1, r4 30006690: 11a0e00f movne lr, pc 30006694: 112fff13 bxne r3
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
30006698: e59f302c ldr r3, [pc, #44] ; 300066cc <malloc+0xec> 3000669c: e5933000 ldr r3, [r3] 300066a0: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
300066a4: 11a00005 movne r0, r5 300066a8: 11a0e00f movne lr, pc 300066ac: 1593f004 ldrne pc, [r3, #4]
return return_this;
}
300066b0: e1a00005 mov r0, r5
300066b4: e8bd8030 pop {r4, r5, pc}
300064ec <malloc_deferred_free>:
void malloc_deferred_free(
void *pointer
)
{
300064ec: e1a01000 mov r1, r0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
300064f0: e59f0000 ldr r0, [pc, #0] ; 300064f8 <malloc_deferred_free+0xc><== NOT EXECUTED 300064f4: ea000e2f b 30009db8 <_Chain_Append> <== NOT EXECUTED
300064c8 <malloc_deferred_frees_process>:
void malloc_deferred_frees_process(void)
{
300064c8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_chain_node *to_be_freed;
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
300064cc: ea000000 b 300064d4 <malloc_deferred_frees_process+0xc>
free(to_be_freed);
300064d0: ebffff73 bl 300062a4 <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
300064d4: e59f000c ldr r0, [pc, #12] ; 300064e8 <malloc_deferred_frees_process+0x20> 300064d8: eb000e49 bl 30009e04 <_Chain_Get>
rtems_chain_node *to_be_freed;
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
300064dc: e3500000 cmp r0, #0
300064e0: 1afffffa bne 300064d0 <malloc_deferred_frees_process+0x8>
free(to_be_freed);
}
300064e4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
300067a8 <malloc_get_heap_pointer>:
#include "malloc_p.h"
Heap_Control *malloc_get_heap_pointer( void )
{
return RTEMS_Malloc_Heap;
}
300067a8: e59f3004 ldr r3, [pc, #4] ; 300067b4 <malloc_get_heap_pointer+0xc><== NOT EXECUTED 300067ac: e5930000 ldr r0, [r3] <== NOT EXECUTED 300067b0: e12fff1e bx lr <== NOT EXECUTED
30006534 <malloc_get_statistics>:
#include "malloc_p.h"
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
30006534: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !stats )
30006538: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000653c: 0a00000e beq 3000657c <malloc_get_statistics+0x48> <== NOT EXECUTED
return -1;
_RTEMS_Lock_allocator();
30006540: e59f503c ldr r5, [pc, #60] ; 30006584 <malloc_get_statistics+0x50><== NOT EXECUTED 30006544: e5950000 ldr r0, [r5] <== NOT EXECUTED 30006548: eb000e00 bl 30009d50 <_API_Mutex_Lock> <== NOT EXECUTED
*stats = rtems_malloc_statistics;
3000654c: e59fe034 ldr lr, [pc, #52] ; 30006588 <malloc_get_statistics+0x54><== NOT EXECUTED
30006550: e1a0c004 mov ip, r4 <== NOT EXECUTED
30006554: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30006558: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000655c: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30006560: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30006564: e89e0007 ldm lr, {r0, r1, r2} <== NOT EXECUTED
30006568: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
_RTEMS_Unlock_allocator();
3000656c: e5950000 ldr r0, [r5] <== NOT EXECUTED 30006570: eb000e0f bl 30009db4 <_API_Mutex_Unlock> <== NOT EXECUTED
return 0;
30006574: e3a00000 mov r0, #0 <== NOT EXECUTED
30006578: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
if ( !stats )
return -1;
3000657c: e3e00000 mvn r0, #0 <== NOT EXECUTED
_RTEMS_Lock_allocator(); *stats = rtems_malloc_statistics; _RTEMS_Unlock_allocator(); return 0; }
30006580: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000a180 <malloc_info>:
int malloc_info(
Heap_Information_block *the_info
)
{
if ( !the_info )
3000a180: e2501000 subs r1, r0, #0 <== NOT EXECUTED
*/
int malloc_info(
Heap_Information_block *the_info
)
{
3000a184: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !the_info )
3000a188: 0a000004 beq 3000a1a0 <malloc_info+0x20> <== NOT EXECUTED
return -1;
_Protected_heap_Get_information( RTEMS_Malloc_Heap, the_info );
3000a18c: e59f3014 ldr r3, [pc, #20] ; 3000a1a8 <malloc_info+0x28> <== NOT EXECUTED 3000a190: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000a194: eb001761 bl 3000ff20 <_Protected_heap_Get_information> <== NOT EXECUTED
return 0;
3000a198: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a19c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int malloc_info(
Heap_Information_block *the_info
)
{
if ( !the_info )
return -1;
3000a1a0: e3e00000 mvn r0, #0 <== NOT EXECUTED
_Protected_heap_Get_information( RTEMS_Malloc_Heap, the_info );
return 0;
}
3000a1a4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006478 <malloc_is_system_state_OK>:
rtems_chain_control RTEMS_Malloc_GC_list;
bool malloc_is_system_state_OK(void)
{
if ( _Thread_Dispatch_disable_level > 0 )
30006478: e59f3024 ldr r3, [pc, #36] ; 300064a4 <malloc_is_system_state_OK+0x2c> 3000647c: e5933000 ldr r3, [r3] 30006480: e3530000 cmp r3, #0
30006484: 1a000004 bne 3000649c <malloc_is_system_state_OK+0x24>
return false;
if ( _ISR_Nest_level > 0 )
30006488: e59f3018 ldr r3, [pc, #24] ; 300064a8 <malloc_is_system_state_OK+0x30>
#include "malloc_p.h"
rtems_chain_control RTEMS_Malloc_GC_list;
bool malloc_is_system_state_OK(void)
3000648c: e5930000 ldr r0, [r3] 30006490: e2700001 rsbs r0, r0, #1 30006494: 33a00000 movcc r0, #0 30006498: e12fff1e bx lr
{
if ( _Thread_Dispatch_disable_level > 0 )
return false;
3000649c: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( _ISR_Nest_level > 0 )
return false;
return true;
}
300064a0: e12fff1e bx lr <== NOT EXECUTED
3000a380 <malloc_report_statistics>:
#ifdef RTEMS_NEWLIB
#include "malloc_p.h"
void malloc_report_statistics(void)
{
malloc_report_statistics_with_plugin( NULL, printk_plugin );
3000a380: e59f1004 ldr r1, [pc, #4] ; 3000a38c <malloc_report_statistics+0xc><== NOT EXECUTED 3000a384: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a388: ea000000 b 3000a390 <malloc_report_statistics_with_plugin> <== NOT EXECUTED
3000a390 <malloc_report_statistics_with_plugin>:
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a390: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_malloc_statistics_t *s;
uintmax_t allocated;
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
3000a394: e59f40f0 ldr r4, [pc, #240] ; 3000a48c <malloc_report_statistics_with_plugin+0xfc><== NOT EXECUTED
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a398: e1a08000 mov r8, r0 <== NOT EXECUTED
"max:%"PRIu32"k (%"PRIu32"%%)"
" lifetime:%"PRIu32"k freed:%"PRIu32"k\n",
s->space_available / 1024,
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
3000a39c: e3a07064 mov r7, #100 ; 0x64 <== NOT EXECUTED
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a3a0: e1a0a001 mov sl, r1 <== NOT EXECUTED
rtems_malloc_statistics_t *s;
uintmax_t allocated;
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
3000a3a4: e284301c add r3, r4, #28 <== NOT EXECUTED
3000a3a8: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000a3ac: e2841024 add r1, r4, #36 ; 0x24 <== NOT EXECUTED
3000a3b0: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3000a3b4: e0522000 subs r2, r2, r0 <== NOT EXECUTED
3000a3b8: e0c33001 sbc r3, r3, r1 <== NOT EXECUTED
"max:%"PRIu32"k (%"PRIu32"%%)"
" lifetime:%"PRIu32"k freed:%"PRIu32"k\n",
s->space_available / 1024,
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
3000a3bc: e0810792 umull r0, r1, r2, r7 <== NOT EXECUTED
context,
"Malloc statistics\n"
" avail:%"PRIu32"k allocated:%"PRIu32"k (%"PRId32"%%) "
"max:%"PRIu32"k (%"PRIu32"%%)"
" lifetime:%"PRIu32"k freed:%"PRIu32"k\n",
s->space_available / 1024,
3000a3c0: e5946000 ldr r6, [r4] <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a3c4: e1a05522 lsr r5, r2, #10 <== NOT EXECUTED
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a3c8: e24dd020 sub sp, sp, #32 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a3cc: e1a0c526 lsr ip, r6, #10 <== NOT EXECUTED 3000a3d0: e1a02006 mov r2, r6 <== NOT EXECUTED 3000a3d4: e1855b03 orr r5, r5, r3, lsl #22 <== NOT EXECUTED 3000a3d8: e1a0b523 lsr fp, r3, #10 <== NOT EXECUTED
"max:%"PRIu32"k (%"PRIu32"%%)"
" lifetime:%"PRIu32"k freed:%"PRIu32"k\n",
s->space_available / 1024,
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
3000a3dc: e0211397 mla r1, r7, r3, r1 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a3e0: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a3e4: e58dc01c str ip, [sp, #28] <== NOT EXECUTED 3000a3e8: eb0055f1 bl 3001fbb4 <__udivdi3> <== NOT EXECUTED
" lifetime:%"PRIu32"k freed:%"PRIu32"k\n",
s->space_available / 1024,
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
3000a3ec: e5949018 ldr r9, [r4, #24] <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a3f0: e98d0003 stmib sp, {r0, r1} <== NOT EXECUTED
3000a3f4: e1a03529 lsr r3, r9, #10 <== NOT EXECUTED
3000a3f8: e1a01006 mov r1, r6 <== NOT EXECUTED
3000a3fc: e0000997 mul r0, r7, r9 <== NOT EXECUTED
3000a400: e58d300c str r3, [sp, #12] <== NOT EXECUTED
3000a404: ebfff48d bl 30007640 <__aeabi_uidiv> <== NOT EXECUTED
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
(uint32_t) (s->lifetime_allocated / 1024),
3000a408: e594101c ldr r1, [r4, #28] <== NOT EXECUTED 3000a40c: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a410: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
(uint32_t) (s->lifetime_allocated / 1024),
3000a414: e1a03521 lsr r3, r1, #10 <== NOT EXECUTED
(uint32_t) (s->lifetime_freed / 1024)
3000a418: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED 3000a41c: e5941028 ldr r1, [r4, #40] ; 0x28 <== NOT EXECUTED
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
(uint32_t) (s->lifetime_allocated / 1024),
3000a420: e1833b02 orr r3, r3, r2, lsl #22 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a424: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 3000a428: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
(uint32_t) (s->lifetime_allocated / 1024),
(uint32_t) (s->lifetime_freed / 1024)
3000a42c: e1a03520 lsr r3, r0, #10 <== NOT EXECUTED 3000a430: e1833b01 orr r3, r3, r1, lsl #22 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a434: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000a438: e1a0200c mov r2, ip <== NOT EXECUTED 3000a43c: e1a03005 mov r3, r5 <== NOT EXECUTED 3000a440: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a444: e59f1044 ldr r1, [pc, #68] ; 3000a490 <malloc_report_statistics_with_plugin+0x100><== NOT EXECUTED 3000a448: e58db000 str fp, [sp] <== NOT EXECUTED 3000a44c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a450: e12fff1a bx sl <== NOT EXECUTED
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
(uint32_t) (s->lifetime_allocated / 1024),
(uint32_t) (s->lifetime_freed / 1024)
);
(*print)(
3000a454: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3000a458: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a45c: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a460: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 3000a464: e59f1028 ldr r1, [pc, #40] ; 3000a494 <malloc_report_statistics_with_plugin+0x104><== NOT EXECUTED 3000a468: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000a46c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000a470: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000a474: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000a478: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000a47c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a480: e12fff1a bx sl <== NOT EXECUTED
s->memalign_calls,
s->free_calls,
s->realloc_calls,
s->calloc_calls
);
}
3000a484: e28dd020 add sp, sp, #32 <== NOT EXECUTED
3000a488: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000698c <malloc_sbrk_extend_and_allocate>:
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
3000698c: e59f309c ldr r3, [pc, #156] ; 30006a30 <malloc_sbrk_extend_and_allocate+0xa4><== NOT EXECUTED
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
30006990: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
30006994: e5934000 ldr r4, [r3] <== NOT EXECUTED
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
30006998: e1a05000 mov r5, r0 <== NOT EXECUTED
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
3000699c: e3540000 cmp r4, #0 <== NOT EXECUTED
return (void *) 0;
300069a0: 01a00004 moveq r0, r4 <== NOT EXECUTED
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
300069a4: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
300069a8: e1a01004 mov r1, r4 <== NOT EXECUTED 300069ac: e0850004 add r0, r5, r4 <== NOT EXECUTED 300069b0: eb003539 bl 30013e9c <__aeabi_uidiv> <== NOT EXECUTED 300069b4: e0040490 mul r4, r0, r4 <== NOT EXECUTED
starting_address = (void *) sbrk(the_size);
300069b8: e1a00004 mov r0, r4 <== NOT EXECUTED 300069bc: ebfff865 bl 30004b58 <sbrk> <== NOT EXECUTED
if ( starting_address == (void*) -1 )
300069c0: e3700001 cmn r0, #1 <== NOT EXECUTED
if ( sbrk_amount == 0 )
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
starting_address = (void *) sbrk(the_size);
300069c4: e1a01000 mov r1, r0 <== NOT EXECUTED
if ( starting_address == (void*) -1 )
300069c8: 0a000016 beq 30006a28 <malloc_sbrk_extend_and_allocate+0x9c><== NOT EXECUTED
return (void *) 0;
if ( !_Protected_heap_Extend(
300069cc: e59f6060 ldr r6, [pc, #96] ; 30006a34 <malloc_sbrk_extend_and_allocate+0xa8><== NOT EXECUTED 300069d0: e1a02004 mov r2, r4 <== NOT EXECUTED 300069d4: e5960000 ldr r0, [r6] <== NOT EXECUTED 300069d8: eb0011c6 bl 3000b0f8 <_Protected_heap_Extend> <== NOT EXECUTED 300069dc: e2507000 subs r7, r0, #0 <== NOT EXECUTED 300069e0: 1a000006 bne 30006a00 <malloc_sbrk_extend_and_allocate+0x74><== NOT EXECUTED
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
300069e4: e2640000 rsb r0, r4, #0 <== NOT EXECUTED 300069e8: ebfff85a bl 30004b58 <sbrk> <== NOT EXECUTED
errno = ENOMEM;
300069ec: eb002792 bl 3001083c <__errno> <== NOT EXECUTED 300069f0: e3a0300c mov r3, #12 <== NOT EXECUTED 300069f4: e5803000 str r3, [r0] <== NOT EXECUTED
return (void *) 0;
300069f8: e1a00007 mov r0, r7 <== NOT EXECUTED
300069fc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
}
MSBUMP(space_available, the_size);
30006a00: e59f3030 ldr r3, [pc, #48] ; 30006a38 <malloc_sbrk_extend_and_allocate+0xac><== NOT EXECUTED 30006a04: e5960000 ldr r0, [r6] <== NOT EXECUTED 30006a08: e5932000 ldr r2, [r3] <== NOT EXECUTED 30006a0c: e1a01005 mov r1, r5 <== NOT EXECUTED 30006a10: e0844002 add r4, r4, r2 <== NOT EXECUTED 30006a14: e3a02000 mov r2, #0 <== NOT EXECUTED 30006a18: e5834000 str r4, [r3] <== NOT EXECUTED 30006a1c: e1a03002 mov r3, r2 <== NOT EXECUTED
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
30006a20: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
30006a24: ea0011a0 b 3000b0ac <_Protected_heap_Allocate_aligned_with_boundary><== NOT EXECUTED
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
starting_address = (void *) sbrk(the_size);
if ( starting_address == (void*) -1 )
return (void *) 0;
30006a28: e3a00000 mov r0, #0 <== NOT EXECUTED
MSBUMP(space_available, the_size);
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
30006a2c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30006a3c <malloc_sbrk_initialize>:
)
{
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
30006a3c: e59f3030 ldr r3, [pc, #48] ; 30006a74 <malloc_sbrk_initialize+0x38><== NOT EXECUTED
* If the starting address is 0 then we are to attempt to
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
30006a40: e3500000 cmp r0, #0 <== NOT EXECUTED
void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
30006a44: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
30006a48: e5831000 str r1, [r3] <== NOT EXECUTED
* If the starting address is 0 then we are to attempt to
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
30006a4c: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
uaddress = (uintptr_t)sbrk(length);
30006a50: e1a00001 mov r0, r1 <== NOT EXECUTED 30006a54: ebfff83f bl 30004b58 <sbrk> <== NOT EXECUTED
if (uaddress == (uintptr_t) -1) {
30006a58: e3700001 cmn r0, #1 <== NOT EXECUTED
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
30006a5c: 0280001b addeq r0, r0, #27 <== NOT EXECUTED 30006a60: 0b000cfe bleq 30009e60 <rtems_fatal_error_occurred> <== NOT EXECUTED
/* DOES NOT RETURN!!! */
}
if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {
30006a64: e3100007 tst r0, #7 <== NOT EXECUTED
old_address = uaddress;
uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
30006a68: 12800008 addne r0, r0, #8 <== NOT EXECUTED 30006a6c: 13c00007 bicne r0, r0, #7 <== NOT EXECUTED
}
starting_address = (void *)uaddress;
}
return starting_address;
}
30006a70: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006a78 <malloc_set_heap_pointer>:
void malloc_set_heap_pointer(
Heap_Control *new_heap
)
{
RTEMS_Malloc_Heap = new_heap;
30006a78: e59f3004 ldr r3, [pc, #4] ; 30006a84 <malloc_set_heap_pointer+0xc><== NOT EXECUTED 30006a7c: e5830000 str r0, [r3] <== NOT EXECUTED
}
30006a80: e12fff1e bx lr <== NOT EXECUTED
3000a55c <malloc_walk>:
#include <stdlib.h>
void malloc_walk(size_t source, size_t printf_enabled)
{
_Protected_heap_Walk( RTEMS_Malloc_Heap, (int) source, printf_enabled );
3000a55c: e2512000 subs r2, r1, #0 <== NOT EXECUTED 3000a560: 13a02001 movne r2, #1 <== NOT EXECUTED 3000a564: e59f100c ldr r1, [pc, #12] ; 3000a578 <malloc_walk+0x1c> <== NOT EXECUTED
#include "malloc_p.h"
#include <stdlib.h>
void malloc_walk(size_t source, size_t printf_enabled)
{
3000a568: e1a03000 mov r3, r0 <== NOT EXECUTED
_Protected_heap_Walk( RTEMS_Malloc_Heap, (int) source, printf_enabled );
3000a56c: e5910000 ldr r0, [r1] <== NOT EXECUTED 3000a570: e1a01003 mov r1, r3 <== NOT EXECUTED 3000a574: ea001694 b 3000ffcc <_Protected_heap_Walk> <== NOT EXECUTED
3000f20c <memfile_free_block>:
* Free a block from an in-memory file.
*/
void memfile_free_block(
void *memory
)
{
3000f20c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
free(memory);
3000f210: ebffdc23 bl 300062a4 <free> <== NOT EXECUTED
memfile_blocks_allocated--;
3000f214: e59f300c ldr r3, [pc, #12] ; 3000f228 <memfile_free_block+0x1c><== NOT EXECUTED 3000f218: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000f21c: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000f220: e5832000 str r2, [r3] <== NOT EXECUTED
}
3000f224: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000f22c <memfile_free_blocks_in_table>:
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
3000f22c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
3000f230: e3a05000 mov r5, #0 <== NOT EXECUTED
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
3000f234: e1a04000 mov r4, r0 <== NOT EXECUTED 3000f238: e1a08001 mov r8, r1 <== NOT EXECUTED
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
3000f23c: e5906000 ldr r6, [r0] <== NOT EXECUTED
if ( b[i] ) {
memfile_free_block( b[i] );
b[i] = 0;
3000f240: e1a07005 mov r7, r5 <== NOT EXECUTED
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
3000f244: ea000005 b 3000f260 <memfile_free_blocks_in_table+0x34> <== NOT EXECUTED
if ( b[i] ) {
3000f248: e4960004 ldr r0, [r6], #4 <== NOT EXECUTED 3000f24c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f250: 0a000001 beq 3000f25c <memfile_free_blocks_in_table+0x30> <== NOT EXECUTED
memfile_free_block( b[i] );
3000f254: ebffffec bl 3000f20c <memfile_free_block> <== NOT EXECUTED
b[i] = 0;
3000f258: e5067004 str r7, [r6, #-4] <== NOT EXECUTED
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
3000f25c: e2855001 add r5, r5, #1 <== NOT EXECUTED 3000f260: e1550008 cmp r5, r8 <== NOT EXECUTED 3000f264: bafffff7 blt 3000f248 <memfile_free_blocks_in_table+0x1c> <== NOT EXECUTED
/*
* Now that all the blocks in the block table are free, we can
* free the block table itself.
*/
memfile_free_block( *block_table );
3000f268: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000f26c: ebffffe6 bl 3000f20c <memfile_free_block> <== NOT EXECUTED
*block_table = 0;
3000f270: e3a03000 mov r3, #0 <== NOT EXECUTED 3000f274: e5843000 str r3, [r4] <== NOT EXECUTED
}
3000f278: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000f748 <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
3000f748: e92d4013 push {r0, r1, r4, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
3000f74c: e5904018 ldr r4, [r0, #24]
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
3000f750: e5943054 ldr r3, [r4, #84] ; 0x54 3000f754: e1530002 cmp r3, r2
3000f758: ba000003 blt 3000f76c <memfile_ftruncate+0x24> 3000f75c: 1a000005 bne 3000f778 <memfile_ftruncate+0x30>
3000f760: e5943050 ldr r3, [r4, #80] ; 0x50 3000f764: e1530001 cmp r3, r1
3000f768: 2a000002 bcs 3000f778 <memfile_ftruncate+0x30>
return IMFS_memfile_extend( the_jnode, length );
3000f76c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f770: ebffff0e bl 3000f3b0 <IMFS_memfile_extend> <== NOT EXECUTED 3000f774: ea000008 b 3000f79c <memfile_ftruncate+0x54> <== NOT EXECUTED
/* * The in-memory files do not currently reclaim memory until the file is * deleted. So we leave the previously allocated blocks in place for * future use and just set the length. */ the_jnode->info.file.size = length;
3000f778: e5841050 str r1, [r4, #80] ; 0x50 3000f77c: e5842054 str r2, [r4, #84] ; 0x54
iop->size = the_jnode->info.file.size;
3000f780: e9800006 stmib r0, {r1, r2}
IMFS_update_atime( the_jnode );
3000f784: e3a01000 mov r1, #0 3000f788: e1a0000d mov r0, sp 3000f78c: ebffdaed bl 30006348 <gettimeofday> 3000f790: e59d3000 ldr r3, [sp]
return 0;
3000f794: e3a00000 mov r0, #0
* future use and just set the length.
*/
the_jnode->info.file.size = length;
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
3000f798: e5843040 str r3, [r4, #64] ; 0x40
return 0;
}
3000f79c: e8bd801c pop {r2, r3, r4, pc}
3000eda8 <memfile_ioctl>:
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
return 0;
}
3000eda8: e3a00000 mov r0, #0 <== NOT EXECUTED 3000edac: e12fff1e bx lr <== NOT EXECUTED
3000f7a0 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
3000f7a0: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
3000f7a4: e5905018 ldr r5, [r0, #24]
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
3000f7a8: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
3000f7ac: e595304c ldr r3, [r5, #76] ; 0x4c 3000f7b0: e3530006 cmp r3, #6
3000f7b4: 1a00000b bne 3000f7e8 <memfile_lseek+0x48>
if (iop->offset > the_jnode->info.linearfile.size)
3000f7b8: e5953054 ldr r3, [r5, #84] ; 0x54 3000f7bc: e5901010 ldr r1, [r0, #16] 3000f7c0: e5952050 ldr r2, [r5, #80] ; 0x50 3000f7c4: e1510003 cmp r1, r3
3000f7c8: ca000003 bgt 3000f7dc <memfile_lseek+0x3c> 3000f7cc: 1a000014 bne 3000f824 <memfile_lseek+0x84>
3000f7d0: e590100c ldr r1, [r0, #12] 3000f7d4: e1510002 cmp r1, r2
3000f7d8: 9a000011 bls 3000f824 <memfile_lseek+0x84>
iop->offset = the_jnode->info.linearfile.size;
3000f7dc: e584200c str r2, [r4, #12] <== NOT EXECUTED 3000f7e0: e5843010 str r3, [r4, #16] <== NOT EXECUTED 3000f7e4: ea00000e b 3000f824 <memfile_lseek+0x84> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
3000f7e8: e1a00005 mov r0, r5
3000f7ec: e284200c add r2, r4, #12
3000f7f0: e8920006 ldm r2, {r1, r2}
3000f7f4: ebfffeed bl 3000f3b0 <IMFS_memfile_extend>
3000f7f8: e3500000 cmp r0, #0
3000f7fc: 0a000005 beq 3000f818 <memfile_lseek+0x78>
rtems_set_errno_and_return_minus_one( ENOSPC );
3000f800: eb00028d bl 3001023c <__errno> <== NOT EXECUTED 3000f804: e3a0301c mov r3, #28 <== NOT EXECUTED 3000f808: e5803000 str r3, [r0] <== NOT EXECUTED 3000f80c: e3e04000 mvn r4, #0 <== NOT EXECUTED 3000f810: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000f814: ea000004 b 3000f82c <memfile_lseek+0x8c> <== NOT EXECUTED
iop->size = the_jnode->info.file.size;
3000f818: e2853050 add r3, r5, #80 ; 0x50
3000f81c: e893000c ldm r3, {r2, r3}
3000f820: e984000c stmib r4, {r2, r3}
} return iop->offset;
3000f824: e284400c add r4, r4, #12
3000f828: e8940018 ldm r4, {r3, r4}
}
3000f82c: e1a00003 mov r0, r3
3000f830: e1a01004 mov r1, r4
3000f834: e8bd8030 pop {r4, r5, pc}
3000f6ac <memfile_open>:
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
3000f6ac: e5903014 ldr r3, [r0, #20]
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
3000f6b0: e92d4031 push {r0, r4, r5, lr}
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
3000f6b4: e3130f81 tst r3, #516 ; 0x204
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
3000f6b8: e1a05000 mov r5, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
3000f6bc: e5904018 ldr r4, [r0, #24]
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
3000f6c0: 0a000015 beq 3000f71c <memfile_open+0x70>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
3000f6c4: e594304c ldr r3, [r4, #76] ; 0x4c 3000f6c8: e3530006 cmp r3, #6
3000f6cc: 1a000012 bne 3000f71c <memfile_open+0x70>
uint32_t count = the_jnode->info.linearfile.size;
3000f6d0: e594c050 ldr ip, [r4, #80] ; 0x50 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
3000f6d4: e3a00000 mov r0, #0 <== NOT EXECUTED
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
3000f6d8: e3a02005 mov r2, #5 <== NOT EXECUTED 3000f6dc: e584204c str r2, [r4, #76] ; 0x4c <== NOT EXECUTED
the_jnode->info.file.size = 0;
3000f6e0: e3a01000 mov r1, #0 <== NOT EXECUTED 3000f6e4: e3a02000 mov r2, #0 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
3000f6e8: e15c0000 cmp ip, r0 <== NOT EXECUTED
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
3000f6ec: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
3000f6f0: e5841050 str r1, [r4, #80] ; 0x50 <== NOT EXECUTED 3000f6f4: e5842054 str r2, [r4, #84] ; 0x54 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
3000f6f8: e5840058 str r0, [r4, #88] ; 0x58 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
3000f6fc: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
3000f700: e5840060 str r0, [r4, #96] ; 0x60 <== NOT EXECUTED
if ((count != 0)
3000f704: 0a000004 beq 3000f71c <memfile_open+0x70> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
3000f708: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f70c: e58dc000 str ip, [sp] <== NOT EXECUTED 3000f710: ebffff6d bl 3000f4cc <IMFS_memfile_write> <== NOT EXECUTED 3000f714: e3700001 cmn r0, #1 <== NOT EXECUTED 3000f718: 0a000009 beq 3000f744 <memfile_open+0x98> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
3000f71c: e5953014 ldr r3, [r5, #20] 3000f720: e3130c02 tst r3, #512 ; 0x200
iop->offset = the_jnode->info.file.size;
3000f724: 12843050 addne r3, r4, #80 ; 0x50
3000f728: 1893000c ldmne r3, {r2, r3}
3000f72c: 1585200c strne r2, [r5, #12]
3000f730: 15853010 strne r3, [r5, #16]
iop->size = the_jnode->info.file.size;
3000f734: e2844050 add r4, r4, #80 ; 0x50
3000f738: e8940018 ldm r4, {r3, r4}
3000f73c: e9850018 stmib r5, {r3, r4}
return 0;
3000f740: e3a00000 mov r0, #0
}
3000f744: e8bd8038 pop {r3, r4, r5, pc}
300066e0 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
300066e0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
300066e4: e1a08003 mov r8, r3
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
300066e8: e2013a0f and r3, r1, #61440 ; 0xf000 300066ec: e3530901 cmp r3, #16384 ; 0x4000
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
300066f0: e24dd020 sub sp, sp, #32 300066f4: e1a06000 mov r6, r0 300066f8: e1a05001 mov r5, r1 300066fc: e1a07002 mov r7, r2
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
30006700: 0a00000c beq 30006738 <mknod+0x58>
30006704: 8a000003 bhi 30006718 <mknod+0x38>
30006708: e3530a01 cmp r3, #4096 ; 0x1000
3000670c: 0a000009 beq 30006738 <mknod+0x58>
30006710: e3530a02 cmp r3, #8192 ; 0x2000 30006714: ea000002 b 30006724 <mknod+0x44> 30006718: e3530a06 cmp r3, #24576 ; 0x6000
3000671c: 0a000005 beq 30006738 <mknod+0x58>
30006720: e3530902 cmp r3, #32768 ; 0x8000
30006724: 0a000003 beq 30006738 <mknod+0x58>
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30006728: eb0026c3 bl 3001023c <__errno> <== NOT EXECUTED 3000672c: e3a03016 mov r3, #22 <== NOT EXECUTED 30006730: e5803000 str r3, [r0] <== NOT EXECUTED 30006734: ea000019 b 300067a0 <mknod+0xc0> <== NOT EXECUTED
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
30006738: e28d4004 add r4, sp, #4 3000673c: e1a00006 mov r0, r6 30006740: e28d101c add r1, sp, #28 30006744: e1a02004 mov r2, r4 30006748: eb000243 bl 3000705c <rtems_filesystem_get_start_loc>
result = (*temp_loc.ops->evalformake_h)(
3000674c: e59d001c ldr r0, [sp, #28] 30006750: e1a01004 mov r1, r4 30006754: e0860000 add r0, r6, r0 30006758: e28d2018 add r2, sp, #24 3000675c: e59d3010 ldr r3, [sp, #16] 30006760: e1a0e00f mov lr, pc 30006764: e593f004 ldr pc, [r3, #4]
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
30006768: e3500000 cmp r0, #0
3000676c: 1a00000b bne 300067a0 <mknod+0xc0>
return -1;
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
30006770: e1a01005 mov r1, r5 30006774: e58d4000 str r4, [sp] 30006778: e59d0018 ldr r0, [sp, #24] 3000677c: e1a02007 mov r2, r7 30006780: e1a03008 mov r3, r8 30006784: e59dc010 ldr ip, [sp, #16] 30006788: e1a0e00f mov lr, pc 3000678c: e59cf014 ldr pc, [ip, #20] 30006790: e1a05000 mov r5, r0
rtems_filesystem_freenode( &temp_loc );
30006794: e1a00004 mov r0, r4 30006798: ebfffebc bl 30006290 <rtems_filesystem_freenode>
return result;
3000679c: ea000000 b 300067a4 <mknod+0xc4>
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
return -1;
300067a0: e3e05000 mvn r5, #0
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
rtems_filesystem_freenode( &temp_loc );
return result;
}
300067a4: e1a00005 mov r0, r5
300067a8: e28dd020 add sp, sp, #32
300067ac: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
30006844 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
30006844: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
30006848: e3530001 cmp r3, #1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
3000684c: e24dd02c sub sp, sp, #44 ; 0x2c 30006850: e1a06000 mov r6, r0 30006854: e1a0b001 mov fp, r1 30006858: e1a0a002 mov sl, r2 3000685c: e58d300c str r3, [sp, #12]
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
30006860: 8a000004 bhi 30006878 <mount+0x34>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
30006864: e1a00002 mov r0, r2 30006868: eb001d6b bl 3000de1c <rtems_filesystem_get_mount_handler>
if ( !mount_h )
3000686c: e3500000 cmp r0, #0 30006870: e58d0014 str r0, [sp, #20]
30006874: 1a000002 bne 30006884 <mount+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
30006878: eb00266f bl 3001023c <__errno> 3000687c: e3a03016 mov r3, #22 30006880: ea00003b b 30006974 <mount+0x130>
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
bool has_target = target != NULL;
30006884: e25b5000 subs r5, fp, #0 30006888: 13a05001 movne r5, #1
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
3000688c: e59f3258 ldr r3, [pc, #600] ; 30006aec <mount+0x2a8> 30006890: e3550000 cmp r5, #0 30006894: 11a0300b movne r3, fp
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
30006898: e1a0000a mov r0, sl
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
3000689c: e58d3004 str r3, [sp, #4]
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
300068a0: eb002a4f bl 300111e4 <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
300068a4: e3560000 cmp r6, #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;
300068a8: e2809001 add r9, r0, #1
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
300068ac: 01a07006 moveq r7, r6
300068b0: 0a000002 beq 300068c0 <mount+0x7c>
300068b4: e1a00006 mov r0, r6 300068b8: eb002a49 bl 300111e4 <strlen> 300068bc: e2807001 add r7, r0, #1
size_t target_size = strlen( target ) + 1;
300068c0: e59d0004 ldr r0, [sp, #4] 300068c4: eb002a46 bl 300111e4 <strlen>
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
300068c8: e2891074 add r1, r9, #116 ; 0x74
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
300068cc: e2803001 add r3, r0, #1
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
300068d0: e0811007 add r1, r1, r7
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
300068d4: e58d0010 str r0, [sp, #16]
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
300068d8: e0811003 add r1, r1, r3 300068dc: e3a00001 mov r0, #1
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
300068e0: e58d3008 str r3, [sp, #8]
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
300068e4: ebfffe0a bl 30006114 <calloc>
if ( mt_entry != NULL ) {
300068e8: e2504000 subs r4, r0, #0
300068ec: 0a00001e beq 3000696c <mount+0x128>
char *str = (char *) mt_entry + sizeof( *mt_entry );
300068f0: e2848074 add r8, r4, #116 ; 0x74
memcpy( str, filesystemtype, filesystemtype_size );
300068f4: e1a00008 mov r0, r8 300068f8: e1a0100a mov r1, sl 300068fc: e1a02009 mov r2, r9 30006900: eb00287b bl 30010af4 <memcpy>
mt_entry->type = str;
30006904: e584806c str r8, [r4, #108] ; 0x6c
str += filesystemtype_size;
30006908: e0888009 add r8, r8, r9
memcpy( str, source_or_null, source_size );
3000690c: e1a00008 mov r0, r8 30006910: e1a01006 mov r1, r6 30006914: e1a02007 mov r2, r7 30006918: eb002875 bl 30010af4 <memcpy>
mt_entry->dev = str;
3000691c: e5848070 str r8, [r4, #112] ; 0x70
str += source_size;
30006920: e0888007 add r8, r8, r7
memcpy( str, target, target_size );
30006924: e99d0006 ldmib sp, {r1, r2}
30006928: e1a00008 mov r0, r8
3000692c: eb002870 bl 30010af4 <memcpy>
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
30006930: e59d300c ldr r3, [sp, #12]
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
30006934: e59fe1b4 ldr lr, [pc, #436] ; 30006af0 <mount+0x2ac> 30006938: e284c038 add ip, r4, #56 ; 0x38
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
3000693c: e5843030 str r3, [r4, #48] ; 0x30
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
30006940: e8be000f ldm lr!, {r0, r1, r2, r3}
30006944: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006948: e8be000f ldm lr!, {r0, r1, r2, r3}
3000694c: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006950: e89e000f ldm lr, {r0, r1, r2, r3}
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
30006954: e3550000 cmp r5, #0
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
memcpy( str, target, target_size );
mt_entry->target = str;
30006958: e5848068 str r8, [r4, #104] ; 0x68
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
3000695c: e584402c str r4, [r4, #44] ; 0x2c
mt_entry->options = options; mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
30006960: e88c000f stm ip, {r0, r1, r2, r3}
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
30006964: 0a00002e beq 30006a24 <mount+0x1e0>
30006968: ea000003 b 3000697c <mount+0x138>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
3000696c: eb002632 bl 3001023c <__errno> <== NOT EXECUTED 30006970: e3a0300c mov r3, #12 <== NOT EXECUTED
30006974: e5803000 str r3, [r0] 30006978: ea000058 b 30006ae0 <mount+0x29c>
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
3000697c: e3a03001 mov r3, #1 30006980: e28d6018 add r6, sp, #24 30006984: e58d3000 str r3, [sp] 30006988: e1a0000b mov r0, fp 3000698c: e59d1010 ldr r1, [sp, #16] 30006990: e3a02007 mov r2, #7 30006994: e1a03006 mov r3, r6 30006998: ebfffe0c bl 300061d0 <rtems_filesystem_evaluate_path> 3000699c: e3700001 cmn r0, #1
300069a0: 0a000048 beq 30006ac8 <mount+0x284>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
300069a4: e1a00006 mov r0, r6 300069a8: e59d3024 ldr r3, [sp, #36] ; 0x24 300069ac: e1a0e00f mov lr, pc 300069b0: e593f010 ldr pc, [r3, #16] 300069b4: e3500001 cmp r0, #1
300069b8: 0a000002 beq 300069c8 <mount+0x184>
errno = ENOTDIR;
300069bc: eb00261e bl 3001023c <__errno> 300069c0: e3a03014 mov r3, #20 300069c4: ea000006 b 300069e4 <mount+0x1a0>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
300069c8: e59f0124 ldr r0, [pc, #292] ; 30006af4 <mount+0x2b0> 300069cc: e59d1018 ldr r1, [sp, #24] 300069d0: ebffff85 bl 300067ec <rtems_filesystem_mount_iterate> 300069d4: e3500000 cmp r0, #0
300069d8: 0a000003 beq 300069ec <mount+0x1a8>
errno = EBUSY;
300069dc: eb002616 bl 3001023c <__errno> 300069e0: e3a03010 mov r3, #16 300069e4: e5803000 str r3, [r0]
goto cleanup_and_bail;
300069e8: ea000037 b 30006acc <mount+0x288>
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
300069ec: e59d3018 ldr r3, [sp, #24]
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
300069f0: e59d2028 ldr r2, [sp, #40] ; 0x28
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
300069f4: e5843008 str r3, [r4, #8]
mt_entry->mt_point_node.handlers = loc.handlers;
300069f8: e59d3020 ldr r3, [sp, #32]
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
300069fc: e5842018 str r2, [r4, #24]
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
30006a00: e5843010 str r3, [r4, #16]
mt_entry->mt_point_node.ops = loc.ops;
30006a04: e59d3024 ldr r3, [sp, #36] ; 0x24
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( loc.ops->mount_h( mt_entry ) ) {
30006a08: e1a00004 mov r0, r4
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
30006a0c: e5843014 str r3, [r4, #20]
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( loc.ops->mount_h( mt_entry ) ) {
30006a10: e1a0e00f mov lr, pc 30006a14: e593f020 ldr pc, [r3, #32] 30006a18: e3500000 cmp r0, #0
30006a1c: 0a00000b beq 30006a50 <mount+0x20c>
30006a20: ea000029 b 30006acc <mount+0x288> <== NOT EXECUTED
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
30006a24: e59f30cc ldr r3, [pc, #204] ; 30006af8 <mount+0x2b4>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
30006a28: e2832004 add r2, r3, #4
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
30006a2c: e5933000 ldr r3, [r3] 30006a30: e1530002 cmp r3, r2
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
30006a34: 01a06005 moveq r6, r5
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
30006a38: 0a000004 beq 30006a50 <mount+0x20c>
errno = EINVAL;
30006a3c: eb0025fe bl 3001023c <__errno> <== NOT EXECUTED 30006a40: e3a03016 mov r3, #22 <== NOT EXECUTED 30006a44: e5803000 str r3, [r0] <== NOT EXECUTED
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
30006a48: e1a06005 mov r6, r5 <== NOT EXECUTED
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
errno = EINVAL;
goto cleanup_and_bail;
30006a4c: ea00001e b 30006acc <mount+0x288> <== NOT EXECUTED
* mt_point_node.node_access will be left to null to indicate that this
* is the root of the entire file system.
*/
}
if ( (*mount_h)( mt_entry, data ) ) {
30006a50: e1a00004 mov r0, r4 30006a54: e59d1050 ldr r1, [sp, #80] ; 0x50 30006a58: e59d3014 ldr r3, [sp, #20] 30006a5c: e1a0e00f mov lr, pc 30006a60: e12fff13 bx r3 30006a64: e2507000 subs r7, r0, #0
30006a68: 0a000004 beq 30006a80 <mount+0x23c>
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
30006a6c: e1a00004 mov r0, r4 <== NOT EXECUTED 30006a70: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 30006a74: e1a0e00f mov lr, pc <== NOT EXECUTED 30006a78: e593f028 ldr pc, [r3, #40] ; 0x28 <== NOT EXECUTED
goto cleanup_and_bail;
30006a7c: ea000012 b 30006acc <mount+0x288> <== NOT EXECUTED
}
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
30006a80: ebffff4f bl 300067c4 <rtems_libio_lock> 30006a84: e59f006c ldr r0, [pc, #108] ; 30006af8 <mount+0x2b4> 30006a88: e1a01004 mov r1, r4 30006a8c: eb000cc9 bl 30009db8 <_Chain_Append>
rtems_chain_append( &mount_chain, &mt_entry->Node ); rtems_libio_unlock();
30006a90: ebffff51 bl 300067dc <rtems_libio_unlock>
if ( !has_target )
30006a94: e3550000 cmp r5, #0
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
30006a98: 11a00007 movne r0, r7
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
30006a9c: 1a000010 bne 30006ae4 <mount+0x2a0>
rtems_filesystem_root = mt_entry->mt_fs_root;
30006aa0: e59f3054 ldr r3, [pc, #84] ; 30006afc <mount+0x2b8>
30006aa4: e284401c add r4, r4, #28
30006aa8: e593c000 ldr ip, [r3]
30006aac: e8b4000f ldm r4!, {r0, r1, r2, r3}
30006ab0: e28cc018 add ip, ip, #24
30006ab4: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006ab8: e5943000 ldr r3, [r4]
return 0;
30006abc: e1a00005 mov r0, r5
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
rtems_filesystem_root = mt_entry->mt_fs_root;
30006ac0: e58c3000 str r3, [ip] 30006ac4: ea000006 b 30006ae4 <mount+0x2a0>
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
30006ac8: e3a06000 mov r6, #0 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
30006acc: e1a00004 mov r0, r4 30006ad0: ebfffdf3 bl 300062a4 <free>
if ( loc_to_free )
30006ad4: e3560000 cmp r6, #0
rtems_filesystem_freenode( loc_to_free );
30006ad8: 11a00006 movne r0, r6 30006adc: 1bfffdeb blne 30006290 <rtems_filesystem_freenode>
return -1;
30006ae0: e3e00000 mvn r0, #0
}
30006ae4: e28dd02c add sp, sp, #44 ; 0x2c
30006ae8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
30006b04 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
30006b04: e92d4010 push {r4, lr}
30006b08: e1a04000 mov r4, r0
switch ( fileno(fp) ) {
30006b0c: eb0026cd bl 30010648 <fileno> 30006b10: e3500002 cmp r0, #2
30006b14: 8a00000b bhi 30006b48 <newlib_free_buffers+0x44>
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
30006b18: e1d430bc ldrh r3, [r4, #12] 30006b1c: e3130080 tst r3, #128 ; 0x80
30006b20: 0a00000a beq 30006b50 <newlib_free_buffers+0x4c>
free( fp->_bf._base );
30006b24: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30006b28: ebfffddd bl 300062a4 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
30006b2c: e1d430bc ldrh r3, [r4, #12] <== NOT EXECUTED 30006b30: e3c33080 bic r3, r3, #128 ; 0x80 <== NOT EXECUTED 30006b34: e1c430bc strh r3, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
30006b38: e3a03000 mov r3, #0 <== NOT EXECUTED 30006b3c: e5843000 str r3, [r4] <== NOT EXECUTED 30006b40: e5843010 str r3, [r4, #16] <== NOT EXECUTED 30006b44: ea000001 b 30006b50 <newlib_free_buffers+0x4c> <== NOT EXECUTED
}
break;
default:
fclose(fp);
30006b48: e1a00004 mov r0, r4 <== NOT EXECUTED 30006b4c: eb002608 bl 30010374 <fclose> <== NOT EXECUTED
} return 0; }
30006b50: e3a00000 mov r0, #0
30006b54: e8bd8010 pop {r4, pc}
30006de8 <open>:
int open(
const char *pathname,
int flags,
...
)
{
30006de8: e92d000e push {r1, r2, r3}
30006dec: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
30006df0: e24dd01c sub sp, sp, #28
30006df4: e59d503c ldr r5, [sp, #60] ; 0x3c
30006df8: e1a06000 mov r6, r0
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
30006dfc: e2853001 add r3, r5, #1
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
30006e00: e213a001 ands sl, r3, #1 30006e04: 13a0a004 movne sl, #4
if ( ( status & _FWRITE ) == _FWRITE )
30006e08: e3130002 tst r3, #2
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
va_start(ap, flags);
mode = va_arg( ap, int );
30006e0c: e28d3044 add r3, sp, #68 ; 0x44
eval_flags = 0;
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
30006e10: 138aa002 orrne sl, sl, #2
va_start(ap, flags);
mode = va_arg( ap, int );
30006e14: e58d3018 str r3, [sp, #24] 30006e18: e59d9040 ldr r9, [sp, #64] ; 0x40
* code does not require changes here since network file
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
30006e1c: eb001b54 bl 3000db74 <rtems_libio_allocate>
if ( iop == 0 ) {
30006e20: e2504000 subs r4, r0, #0
30006e24: 0a000063 beq 30006fb8 <open+0x1d0>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
30006e28: e1a00006 mov r0, r6 30006e2c: eb0028ec bl 300111e4 <strlen> 30006e30: e28d7004 add r7, sp, #4 30006e34: e1a01000 mov r1, r0 30006e38: e3a08001 mov r8, #1 30006e3c: e1a00006 mov r0, r6 30006e40: e1a0200a mov r2, sl 30006e44: e1a03007 mov r3, r7 30006e48: e58d8000 str r8, [sp] 30006e4c: ebfffcdf bl 300061d0 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
30006e50: e3700001 cmn r0, #1
30006e54: 1a00001f bne 30006ed8 <open+0xf0>
if ( errno != ENOENT ) {
30006e58: eb0024f7 bl 3001023c <__errno> 30006e5c: e5903000 ldr r3, [r0] 30006e60: e3530002 cmp r3, #2
30006e64: 1a00000a bne 30006e94 <open+0xac>
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
30006e68: e215ac02 ands sl, r5, #512 ; 0x200
int mode; int rc; rtems_libio_t *iop = 0; int status; rtems_filesystem_location_info_t loc; rtems_filesystem_location_info_t *loc_to_free = NULL;
30006e6c: 01a0700a moveq r7, sl
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
rc = ENOENT;
30006e70: 01a05003 moveq r5, r3
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
30006e74: 0a000055 beq 30006fd0 <open+0x1e8>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
30006e78: e1a00006 mov r0, r6 30006e7c: e3891902 orr r1, r9, #32768 ; 0x8000 30006e80: e3a02000 mov r2, #0 30006e84: e3a03000 mov r3, #0 30006e88: ebfffe14 bl 300066e0 <mknod>
if ( rc ) {
30006e8c: e250a000 subs sl, r0, #0
30006e90: 0a000003 beq 30006ea4 <open+0xbc>
rc = errno;
30006e94: eb0024e8 bl 3001023c <__errno> <== NOT EXECUTED
int mode; int rc; rtems_libio_t *iop = 0; int status; rtems_filesystem_location_info_t loc; rtems_filesystem_location_info_t *loc_to_free = NULL;
30006e98: e3a07000 mov r7, #0 <== NOT EXECUTED
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
30006e9c: e5905000 ldr r5, [r0] <== NOT EXECUTED
goto done;
30006ea0: ea000048 b 30006fc8 <open+0x1e0> <== NOT EXECUTED
/*
* After we do the mknod(), we have to evaluate the path to get the
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
30006ea4: e1a00006 mov r0, r6 30006ea8: eb0028cd bl 300111e4 <strlen> 30006eac: e1a03007 mov r3, r7 30006eb0: e1a01000 mov r1, r0 30006eb4: e1a0200a mov r2, sl 30006eb8: e1a00006 mov r0, r6 30006ebc: e58d8000 str r8, [sp] 30006ec0: ebfffcc2 bl 300061d0 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
30006ec4: e3500000 cmp r0, #0
int mode; int rc; rtems_libio_t *iop = 0; int status; rtems_filesystem_location_info_t loc; rtems_filesystem_location_info_t *loc_to_free = NULL;
30006ec8: 11a0700a movne r7, sl
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
30006ecc: 13a0500d movne r5, #13
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
30006ed0: 1a00003e bne 30006fd0 <open+0x1e8>
30006ed4: ea000002 b 30006ee4 <open+0xfc>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
30006ed8: e2053c0a and r3, r5, #2560 ; 0xa00 30006edc: e3530c0a cmp r3, #2560 ; 0xa00
30006ee0: 0a000036 beq 30006fc0 <open+0x1d8>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
30006ee4: e1a00005 mov r0, r5 30006ee8: e5947014 ldr r7, [r4, #20] 30006eec: eb001b01 bl 3000daf8 <rtems_libio_fcntl_flags>
iop->pathinfo = loc;
30006ef0: e284c018 add ip, r4, #24
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
30006ef4: e1800007 orr r0, r0, r7
iop->pathinfo = loc;
30006ef8: e28de004 add lr, sp, #4
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
30006efc: e5840014 str r0, [r4, #20]
iop->pathinfo = loc;
30006f00: e8be000f ldm lr!, {r0, r1, r2, r3}
30006f04: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006f08: e59e3000 ldr r3, [lr]
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
30006f0c: e1a00004 mov r0, r4
/* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->flags |= rtems_libio_fcntl_flags( flags ); iop->pathinfo = loc;
30006f10: e58c3000 str r3, [ip]
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
30006f14: e1a01006 mov r1, r6 30006f18: e594c020 ldr ip, [r4, #32] 30006f1c: e1a02005 mov r2, r5 30006f20: e1a03009 mov r3, r9 30006f24: e1a0e00f mov lr, pc 30006f28: e59cf000 ldr pc, [ip]
if ( rc ) {
30006f2c: e3500000 cmp r0, #0
30006f30: 0a000003 beq 30006f44 <open+0x15c>
rc = errno;
30006f34: eb0024c0 bl 3001023c <__errno> <== NOT EXECUTED
rc = EEXIST;
loc_to_free = &loc;
goto done;
}
loc_to_free = &loc;
30006f38: e28d7004 add r7, sp, #4 <== NOT EXECUTED
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
if ( rc ) {
rc = errno;
30006f3c: e5905000 ldr r5, [r0] <== NOT EXECUTED
goto done;
30006f40: ea000020 b 30006fc8 <open+0x1e0> <== NOT EXECUTED
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
30006f44: e3150b01 tst r5, #1024 ; 0x400
30006f48: 0a00002a beq 30006ff8 <open+0x210>
rc = ftruncate( iop - rtems_libio_iops, 0 );
30006f4c: e59f30cc ldr r3, [pc, #204] ; 30007020 <open+0x238> 30006f50: e59f00cc ldr r0, [pc, #204] ; 30007024 <open+0x23c> 30006f54: e5933000 ldr r3, [r3] 30006f58: e3a01000 mov r1, #0 30006f5c: e0633004 rsb r3, r3, r4 30006f60: e1a031c3 asr r3, r3, #3 30006f64: e0000093 mul r0, r3, r0 30006f68: e3a02000 mov r2, #0 30006f6c: eb001aa4 bl 3000da04 <ftruncate>
if ( rc ) {
30006f70: e2505000 subs r5, r0, #0
30006f74: 0a00001f beq 30006ff8 <open+0x210>
if(errno) rc = errno;
30006f78: eb0024af bl 3001023c <__errno> <== NOT EXECUTED 30006f7c: e5903000 ldr r3, [r0] <== NOT EXECUTED 30006f80: e3530000 cmp r3, #0 <== NOT EXECUTED 30006f84: 0a000001 beq 30006f90 <open+0x1a8> <== NOT EXECUTED 30006f88: eb0024ab bl 3001023c <__errno> <== NOT EXECUTED 30006f8c: e5905000 ldr r5, [r0] <== NOT EXECUTED
close( iop - rtems_libio_iops );
30006f90: e59f3088 ldr r3, [pc, #136] ; 30007020 <open+0x238> <== NOT EXECUTED 30006f94: e59f0088 ldr r0, [pc, #136] ; 30007024 <open+0x23c> <== NOT EXECUTED 30006f98: e5933000 ldr r3, [r3] <== NOT EXECUTED 30006f9c: e0634004 rsb r4, r3, r4 <== NOT EXECUTED 30006fa0: e1a041c4 asr r4, r4, #3 <== NOT EXECUTED 30006fa4: e0000094 mul r0, r4, r0 <== NOT EXECUTED
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
30006fa8: e3a04000 mov r4, #0 <== NOT EXECUTED
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
close( iop - rtems_libio_iops );
30006fac: eb001a74 bl 3000d984 <close> <== NOT EXECUTED
/* those are released by close(): */
iop = 0;
30006fb0: e1a07004 mov r7, r4 <== NOT EXECUTED 30006fb4: ea000003 b 30006fc8 <open+0x1e0> <== NOT EXECUTED
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
30006fb8: e3a05017 mov r5, #23 30006fbc: ea000009 b 30006fe8 <open+0x200>
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
30006fc0: e3a05011 mov r5, #17 <== NOT EXECUTED 30006fc4: ea000001 b 30006fd0 <open+0x1e8> <== NOT EXECUTED
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
30006fc8: e3550000 cmp r5, #0 <== NOT EXECUTED 30006fcc: 0a000009 beq 30006ff8 <open+0x210> <== NOT EXECUTED
if ( iop )
30006fd0: e3540000 cmp r4, #0
rtems_libio_free( iop );
30006fd4: 11a00004 movne r0, r4 30006fd8: 1b001b0d blne 3000dc14 <rtems_libio_free>
if ( loc_to_free )
30006fdc: e3570000 cmp r7, #0
rtems_filesystem_freenode( loc_to_free );
30006fe0: 11a00007 movne r0, r7 30006fe4: 1bfffca9 blne 30006290 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( rc );
30006fe8: eb002493 bl 3001023c <__errno> 30006fec: e5805000 str r5, [r0] 30006ff0: e3e00000 mvn r0, #0 30006ff4: ea000005 b 30007010 <open+0x228>
}
return iop - rtems_libio_iops;
30006ff8: e59f3020 ldr r3, [pc, #32] ; 30007020 <open+0x238> 30006ffc: e5930000 ldr r0, [r3] 30007000: e0604004 rsb r4, r0, r4 30007004: e59f0018 ldr r0, [pc, #24] ; 30007024 <open+0x23c> 30007008: e1a041c4 asr r4, r4, #3 3000700c: e0000094 mul r0, r4, r0
}
30007010: e28dd01c add sp, sp, #28
30007014: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
30007018: e28dd00c add sp, sp, #12
3000701c: e12fff1e bx lr
30007c38 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30007c38: e92d4011 push {r0, r4, lr}
30007c3c: e5cd0000 strb r0, [sp]
int i;
if (tty->termios.c_oflag & OPOST) {
30007c40: e5913034 ldr r3, [r1, #52] ; 0x34
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30007c44: e1a04001 mov r4, r1
int i;
if (tty->termios.c_oflag & OPOST) {
30007c48: e3130001 tst r3, #1
30007c4c: 0a000045 beq 30007d68 <oproc+0x130>
switch (c) {
30007c50: e5dd2000 ldrb r2, [sp] 30007c54: e2421008 sub r1, r2, #8 30007c58: e3510005 cmp r1, #5 30007c5c: 979ff101 ldrls pc, [pc, r1, lsl #2] 30007c60: ea00002c b 30007d18 <oproc+0xe0> 30007c64: 30007d04 .word 0x30007d04 30007c68: 30007cdc .word 0x30007cdc 30007c6c: 30007c7c .word 0x30007c7c 30007c70: 30007d18 .word 0x30007d18 30007c74: 30007d18 .word 0x30007d18 30007c78: 30007ca4 .word 0x30007ca4
case '\n':
if (tty->termios.c_oflag & ONLRET)
30007c7c: e3130020 tst r3, #32
tty->column = 0;
30007c80: 13a02000 movne r2, #0 30007c84: 15842028 strne r2, [r4, #40] ; 0x28
if (tty->termios.c_oflag & ONLCR) {
30007c88: e3130004 tst r3, #4
30007c8c: 0a000035 beq 30007d68 <oproc+0x130>
rtems_termios_puts ("\r", 1, tty);
30007c90: e59f00e4 ldr r0, [pc, #228] ; 30007d7c <oproc+0x144> 30007c94: e3a01001 mov r1, #1 30007c98: e1a02004 mov r2, r4 30007c9c: ebffffa5 bl 30007b38 <rtems_termios_puts> 30007ca0: ea00000b b 30007cd4 <oproc+0x9c>
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
30007ca4: e3130010 tst r3, #16 <== NOT EXECUTED 30007ca8: 0a000002 beq 30007cb8 <oproc+0x80> <== NOT EXECUTED 30007cac: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED 30007cb0: e3520000 cmp r2, #0 <== NOT EXECUTED 30007cb4: 0a00002f beq 30007d78 <oproc+0x140> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
30007cb8: e2132008 ands r2, r3, #8 <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
30007cbc: 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) {
30007cc0: 0a000028 beq 30007d68 <oproc+0x130> <== NOT EXECUTED
c = '\n';
30007cc4: e3a0200a mov r2, #10 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
30007cc8: 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';
30007ccc: e5cd2000 strb r2, [sp] <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
30007cd0: 0a000024 beq 30007d68 <oproc+0x130> <== NOT EXECUTED
tty->column = 0;
30007cd4: e3a03000 mov r3, #0 30007cd8: ea000021 b 30007d64 <oproc+0x12c>
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
30007cdc: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
30007ce0: e2033b06 and r3, r3, #6144 ; 0x1800 <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
30007ce4: e2021007 and r1, r2, #7 <== NOT EXECUTED 30007ce8: e2611008 rsb r1, r1, #8 <== NOT EXECUTED
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
30007cec: e3530b06 cmp r3, #6144 ; 0x1800 <== NOT EXECUTED 30007cf0: e0813002 add r3, r1, r2 <== NOT EXECUTED
tty->column += i;
30007cf4: 05843028 streq r3, [r4, #40] ; 0x28 <== NOT EXECUTED
rtems_termios_puts ( " ", i, tty);
30007cf8: 059f0080 ldreq r0, [pc, #128] ; 30007d80 <oproc+0x148> <== NOT EXECUTED
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
30007cfc: 1a000018 bne 30007d64 <oproc+0x12c> <== NOT EXECUTED 30007d00: ea00001a b 30007d70 <oproc+0x138> <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
30007d04: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30007d08: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
30007d0c: c2433001 subgt r3, r3, #1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
30007d10: ca000013 bgt 30007d64 <oproc+0x12c> <== NOT EXECUTED 30007d14: ea000013 b 30007d68 <oproc+0x130> <== NOT EXECUTED
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
30007d18: e3130002 tst r3, #2
30007d1c: 0a000007 beq 30007d40 <oproc+0x108>
c = toupper(c);
30007d20: e59f305c ldr r3, [pc, #92] ; 30007d84 <oproc+0x14c> <== NOT EXECUTED 30007d24: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007d28: e0833002 add r3, r3, r2 <== NOT EXECUTED 30007d2c: e5d33001 ldrb r3, [r3, #1] <== NOT EXECUTED 30007d30: e2033003 and r3, r3, #3 <== NOT EXECUTED 30007d34: e3530002 cmp r3, #2 <== NOT EXECUTED 30007d38: 02422020 subeq r2, r2, #32 <== NOT EXECUTED 30007d3c: e5cd2000 strb r2, [sp] <== NOT EXECUTED
if (!iscntrl(c))
30007d40: e59f203c ldr r2, [pc, #60] ; 30007d84 <oproc+0x14c> 30007d44: e5dd3000 ldrb r3, [sp] 30007d48: e5922000 ldr r2, [r2] 30007d4c: e0823003 add r3, r2, r3 30007d50: e5d33001 ldrb r3, [r3, #1] 30007d54: e3130020 tst r3, #32
30007d58: 1a000002 bne 30007d68 <oproc+0x130>
tty->column++;
30007d5c: e5943028 ldr r3, [r4, #40] ; 0x28 30007d60: e2833001 add r3, r3, #1 30007d64: e5843028 str r3, [r4, #40] ; 0x28
break;
}
}
rtems_termios_puts (&c, 1, tty);
30007d68: e1a0000d mov r0, sp 30007d6c: e3a01001 mov r1, #1 30007d70: e1a02004 mov r2, r4 30007d74: ebffff6f bl 30007b38 <rtems_termios_puts>
}
30007d78: e8bd8018 pop {r3, r4, pc}
300080fc <pathconf>:
long pathconf(
const char *path,
int name
)
{
300080fc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30008100: e1a05001 mov r5, r1 <== NOT EXECUTED
int status;
int fd;
fd = open( path, O_RDONLY );
30008104: e3a01000 mov r1, #0 <== NOT EXECUTED 30008108: ebffff67 bl 30007eac <open> <== NOT EXECUTED
if ( fd == -1 )
3000810c: e3700001 cmn r0, #1 <== NOT EXECUTED
)
{
int status;
int fd;
fd = open( path, O_RDONLY );
30008110: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( fd == -1 )
30008114: 0a000006 beq 30008134 <pathconf+0x38> <== NOT EXECUTED
return -1;
status = fpathconf( fd, name );
30008118: e1a01005 mov r1, r5 <== NOT EXECUTED 3000811c: ebfffb31 bl 30006de8 <fpathconf> <== NOT EXECUTED 30008120: e1a05000 mov r5, r0 <== NOT EXECUTED
(void) close( fd );
30008124: e1a00004 mov r0, r4 <== NOT EXECUTED 30008128: ebfffa1b bl 3000699c <close> <== NOT EXECUTED
return status;
3000812c: e1a00005 mov r0, r5 <== NOT EXECUTED
30008130: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
30008134: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
300083a0 <pipe>:
int pipe(
int filsdes[2]
)
{
if (filsdes == NULL)
300083a0: e3500000 cmp r0, #0 <== NOT EXECUTED
extern int pipe_create(int filsdes[2]);
int pipe(
int filsdes[2]
)
{
300083a4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if (filsdes == NULL)
300083a8: 1a000004 bne 300083c0 <pipe+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
300083ac: eb0024f6 bl 3001178c <__errno> <== NOT EXECUTED 300083b0: e3a0300e mov r3, #14 <== NOT EXECUTED 300083b4: e5803000 str r3, [r0] <== NOT EXECUTED
return pipe_create(filsdes);
}
300083b8: e3e00000 mvn r0, #0 <== NOT EXECUTED
300083bc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300083c0: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
)
{
if (filsdes == NULL)
rtems_set_errno_and_return_minus_one( EFAULT );
return pipe_create(filsdes);
300083c4: ea0019e6 b 3000eb64 <pipe_create> <== NOT EXECUTED
3000eb64 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
3000eb64: e92d407f push {r0, r1, r2, r3, r4, r5, r6, lr} <== NOT EXECUTED
3000eb68: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
3000eb6c: e59f10f8 ldr r1, [pc, #248] ; 3000ec6c <pipe_create+0x108> <== NOT EXECUTED 3000eb70: e59f00f8 ldr r0, [pc, #248] ; 3000ec70 <pipe_create+0x10c> <== NOT EXECUTED 3000eb74: eb00051e bl 3000fff4 <rtems_mkdir> <== NOT EXECUTED 3000eb78: e3500000 cmp r0, #0 <== NOT EXECUTED 3000eb7c: 1a000037 bne 3000ec60 <pipe_create+0xfc> <== NOT EXECUTED
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
3000eb80: e59f10ec ldr r1, [pc, #236] ; 3000ec74 <pipe_create+0x110> <== NOT EXECUTED 3000eb84: e3a0200a mov r2, #10 <== NOT EXECUTED 3000eb88: e1a0000d mov r0, sp <== NOT EXECUTED 3000eb8c: eb000d2c bl 30012044 <memcpy> <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
3000eb90: e59f30e0 ldr r3, [pc, #224] ; 3000ec78 <pipe_create+0x114> <== NOT EXECUTED 3000eb94: e28d000a add r0, sp, #10 <== NOT EXECUTED 3000eb98: e1d320b0 ldrh r2, [r3] <== NOT EXECUTED
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
3000eb9c: e1a0400d mov r4, sp <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
3000eba0: e2821001 add r1, r2, #1 <== NOT EXECUTED 3000eba4: e1c310b0 strh r1, [r3] <== NOT EXECUTED 3000eba8: e59f10cc ldr r1, [pc, #204] ; 3000ec7c <pipe_create+0x118> <== NOT EXECUTED 3000ebac: eb000db5 bl 30012288 <sprintf> <== NOT EXECUTED
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
3000ebb0: e1a0000d mov r0, sp <== NOT EXECUTED 3000ebb4: e3a01d06 mov r1, #384 ; 0x180 <== NOT EXECUTED 3000ebb8: eb000478 bl 3000fda0 <mkfifo> <== NOT EXECUTED 3000ebbc: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000ebc0: 0a000001 beq 3000ebcc <pipe_create+0x68> <== NOT EXECUTED
if (errno != EEXIST){
3000ebc4: eb000af0 bl 3001178c <__errno> <== NOT EXECUTED 3000ebc8: ea000024 b 3000ec60 <pipe_create+0xfc> <== NOT EXECUTED
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
3000ebcc: e1a0000d mov r0, sp <== NOT EXECUTED 3000ebd0: e3a01901 mov r1, #16384 ; 0x4000 <== NOT EXECUTED 3000ebd4: ebffe55d bl 30008150 <open> <== NOT EXECUTED
if (filsdes[0] < 0) {
3000ebd8: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
3000ebdc: e5850000 str r0, [r5] <== NOT EXECUTED
if (filsdes[0] < 0) {
3000ebe0: aa000002 bge 3000ebf0 <pipe_create+0x8c> <== NOT EXECUTED
err = errno;
3000ebe4: eb000ae8 bl 3001178c <__errno> <== NOT EXECUTED 3000ebe8: e5906000 ldr r6, [r0] <== NOT EXECUTED 3000ebec: ea000014 b 3000ec44 <pipe_create+0xe0> <== NOT EXECUTED
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]);
3000ebf0: e59f3088 ldr r3, [pc, #136] ; 3000ec80 <pipe_create+0x11c> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
3000ebf4: e3a01001 mov r1, #1 <== NOT EXECUTED
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]);
3000ebf8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000ebfc: e1500003 cmp r0, r3 <== NOT EXECUTED 3000ec00: 359f307c ldrcc r3, [pc, #124] ; 3000ec84 <pipe_create+0x120><== NOT EXECUTED 3000ec04: 33a06038 movcc r6, #56 ; 0x38 <== NOT EXECUTED 3000ec08: 35933000 ldrcc r3, [r3] <== NOT EXECUTED 3000ec0c: 30263690 mlacc r6, r0, r6, r3 <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
3000ec10: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
filsdes[1] = open(fifopath, O_WRONLY);
3000ec14: e1a0000d mov r0, sp <== NOT EXECUTED
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
3000ec18: e3c33001 bic r3, r3, #1 <== NOT EXECUTED 3000ec1c: e5863014 str r3, [r6, #20] <== NOT EXECUTED
filsdes[1] = open(fifopath, O_WRONLY);
3000ec20: ebffe54a bl 30008150 <open> <== NOT EXECUTED
if (filsdes[1] < 0) {
3000ec24: e3500000 cmp r0, #0 <== NOT EXECUTED
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
3000ec28: e5850004 str r0, [r5, #4] <== NOT EXECUTED
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
3000ec2c: a3a06000 movge r6, #0 <== NOT EXECUTED
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
3000ec30: aa000003 bge 3000ec44 <pipe_create+0xe0> <== NOT EXECUTED
err = errno;
3000ec34: eb000ad4 bl 3001178c <__errno> <== NOT EXECUTED 3000ec38: e5906000 ldr r6, [r0] <== NOT EXECUTED
close(filsdes[0]);
3000ec3c: e5950000 ldr r0, [r5] <== NOT EXECUTED 3000ec40: ebffe161 bl 300071cc <close> <== NOT EXECUTED
}
unlink(fifopath);
3000ec44: e1a0000d mov r0, sp <== NOT EXECUTED 3000ec48: ebffecbf bl 30009f4c <unlink> <== NOT EXECUTED
} if(err != 0)
3000ec4c: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(err);
return 0;
3000ec50: 01a00006 moveq r0, r6 <== NOT EXECUTED
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
3000ec54: 0a000002 beq 3000ec64 <pipe_create+0x100> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(err);
3000ec58: eb000acb bl 3001178c <__errno> <== NOT EXECUTED 3000ec5c: e5806000 str r6, [r0] <== NOT EXECUTED 3000ec60: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0; }
3000ec64: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000ec68: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000ff28 <pipe_ioctl>:
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
3000ff28: e59f3058 ldr r3, [pc, #88] ; 3000ff88 <pipe_ioctl+0x60> <== NOT EXECUTED
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
3000ff2c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if (cmd == FIONREAD) {
3000ff30: e1510003 cmp r1, r3 <== NOT EXECUTED
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
3000ff34: e1a04000 mov r4, r0 <== NOT EXECUTED 3000ff38: e1a05002 mov r5, r2 <== NOT EXECUTED
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
3000ff3c: 13e00015 mvnne r0, #21 <== NOT EXECUTED
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
3000ff40: 18bd8070 popne {r4, r5, r6, pc} <== NOT EXECUTED
if (buffer == NULL)
3000ff44: e3520000 cmp r2, #0 <== NOT EXECUTED
return -EFAULT;
3000ff48: 03e0000d mvneq r0, #13 <== NOT EXECUTED
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
3000ff4c: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return -EFAULT;
if (! PIPE_LOCK(pipe))
3000ff50: e3a01000 mov r1, #0 <== NOT EXECUTED 3000ff54: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000ff58: e1a02001 mov r2, r1 <== NOT EXECUTED 3000ff5c: ebffed03 bl 3000b370 <rtems_semaphore_obtain> <== NOT EXECUTED 3000ff60: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000ff64: 1a000005 bne 3000ff80 <pipe_ioctl+0x58> <== NOT EXECUTED
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
3000ff68: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
3000ff6c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
3000ff70: e5853000 str r3, [r5] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
3000ff74: ebffed43 bl 3000b488 <rtems_semaphore_release> <== NOT EXECUTED
return 0;
3000ff78: e1a00006 mov r0, r6 <== NOT EXECUTED
3000ff7c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
return -EINTR;
3000ff80: e3e00003 mvn r0, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
3000ff84: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000ff8c <pipe_lseek>:
rtems_libio_t *iop
)
{
/* Seek on pipe is not supported */
return -ESPIPE;
}
3000ff8c: e3e0001c mvn r0, #28 <== NOT EXECUTED 3000ff90: e12fff1e bx lr <== NOT EXECUTED
3000fc10 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000fc10: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000fc14: e1a09001 mov r9, r1
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000fc18: e3a01000 mov r1, #0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000fc1c: e1a04000 mov r4, r0 3000fc20: e1a05002 mov r5, r2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000fc24: e5900028 ldr r0, [r0, #40] ; 0x28 3000fc28: e1a02001 mov r2, r1
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000fc2c: e1a0a003 mov sl, r3
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000fc30: ebffedce bl 3000b370 <rtems_semaphore_obtain> 3000fc34: e2506000 subs r6, r0, #0
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
3000fc38: 01a0b00d moveq fp, sp
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000fc3c: 0a000043 beq 3000fd50 <pipe_read+0x140>
3000fc40: ea00004f b 3000fd84 <pipe_read+0x174> <== NOT EXECUTED
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
3000fc44: e5947014 ldr r7, [r4, #20] 3000fc48: e3570000 cmp r7, #0
3000fc4c: 0a000044 beq 3000fd64 <pipe_read+0x154>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
3000fc50: e59a8014 ldr r8, [sl, #20] 3000fc54: e2188001 ands r8, r8, #1
3000fc58: 1a000040 bne 3000fd60 <pipe_read+0x150>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
3000fc5c: e5943018 ldr r3, [r4, #24]
PIPE_UNLOCK(pipe);
3000fc60: e5940028 ldr r0, [r4, #40] ; 0x28
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
3000fc64: e2833001 add r3, r3, #1 3000fc68: e5843018 str r3, [r4, #24]
PIPE_UNLOCK(pipe);
3000fc6c: ebffee05 bl 3000b488 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
3000fc70: e1a01008 mov r1, r8 3000fc74: e594002c ldr r0, [r4, #44] ; 0x2c 3000fc78: eb000385 bl 30010a94 <rtems_barrier_wait> 3000fc7c: e3500000 cmp r0, #0 3000fc80: 01a07000 moveq r7, r0 3000fc84: 13e07003 mvnne r7, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
3000fc88: e1a01008 mov r1, r8 3000fc8c: e5940028 ldr r0, [r4, #40] ; 0x28 3000fc90: e1a02008 mov r2, r8 3000fc94: ebffedb5 bl 3000b370 <rtems_semaphore_obtain> 3000fc98: e3500000 cmp r0, #0
3000fc9c: 1a000033 bne 3000fd70 <pipe_read+0x160>
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
3000fca0: e5943018 ldr r3, [r4, #24]
if (ret != 0)
3000fca4: e3570000 cmp r7, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
3000fca8: e2433001 sub r3, r3, #1 3000fcac: e5843018 str r3, [r4, #24]
if (ret != 0)
3000fcb0: 1a00002b bne 3000fd64 <pipe_read+0x154>
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
3000fcb4: e594300c ldr r3, [r4, #12] 3000fcb8: e3530000 cmp r3, #0
3000fcbc: 0affffe0 beq 3000fc44 <pipe_read+0x34>
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
3000fcc0: e0667005 rsb r7, r6, r5 3000fcc4: e1530007 cmp r3, r7 3000fcc8: 31a07003 movcc r7, r3
chunk1 = pipe->Size - pipe->Start;
3000fccc: e5948004 ldr r8, [r4, #4] 3000fcd0: e5943008 ldr r3, [r4, #8] 3000fcd4: e5941000 ldr r1, [r4] 3000fcd8: e0638008 rsb r8, r3, r8
if (chunk > chunk1) {
3000fcdc: e1570008 cmp r7, r8 3000fce0: e0890006 add r0, r9, r6
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);
3000fce4: d0811003 addle r1, r1, r3 3000fce8: d1a02007 movle r2, r7
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
3000fcec: da000006 ble 3000fd0c <pipe_read+0xfc>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
3000fcf0: e0811003 add r1, r1, r3 3000fcf4: e1a02008 mov r2, r8 3000fcf8: eb000c4a bl 30012e28 <memcpy>
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
3000fcfc: e0860008 add r0, r6, r8 3000fd00: e5941000 ldr r1, [r4] 3000fd04: e0890000 add r0, r9, r0 3000fd08: e0682007 rsb r2, r8, r7
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
3000fd0c: eb000c45 bl 30012e28 <memcpy>
pipe->Start += chunk;
3000fd10: e5940008 ldr r0, [r4, #8]
pipe->Start %= pipe->Size;
3000fd14: e5941004 ldr r1, [r4, #4] 3000fd18: e0870000 add r0, r7, r0 3000fd1c: eb003ba2 bl 3001ebac <__umodsi3>
pipe->Length -= chunk;
3000fd20: e594300c ldr r3, [r4, #12]
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
3000fd24: e5840008 str r0, [r4, #8]
pipe->Length -= chunk;
3000fd28: e0673003 rsb r3, r7, r3
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
3000fd2c: e3530000 cmp r3, #0
pipe->Start = 0;
3000fd30: 05843008 streq r3, [r4, #8]
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
pipe->Length -= chunk;
3000fd34: e584300c str r3, [r4, #12]
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
3000fd38: e594301c ldr r3, [r4, #28] 3000fd3c: e3530000 cmp r3, #0
PIPE_WAKEUPWRITERS(pipe);
3000fd40: 15940030 ldrne r0, [r4, #48] ; 0x30 3000fd44: 11a0100d movne r1, sp 3000fd48: 1b00033b blne 30010a3c <rtems_barrier_release>
read += chunk;
3000fd4c: e0866007 add r6, r6, r7
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
3000fd50: e1560005 cmp r6, r5
3000fd54: 3affffd6 bcc 3000fcb4 <pipe_read+0xa4>
3000fd58: e3a07000 mov r7, #0 3000fd5c: ea000000 b 3000fd64 <pipe_read+0x154>
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
3000fd60: e3e0700a mvn r7, #10
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
3000fd64: e5940028 ldr r0, [r4, #40] ; 0x28 3000fd68: ebffedc6 bl 3000b488 <rtems_semaphore_release> 3000fd6c: ea000000 b 3000fd74 <pipe_read+0x164>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
3000fd70: e3e07003 mvn r7, #3 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
3000fd74: e3560000 cmp r6, #0 3000fd78: c1a00006 movgt r0, r6 3000fd7c: d1a00007 movle r0, r7 3000fd80: ea000000 b 3000fd88 <pipe_read+0x178>
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
3000fd84: e3e00003 mvn r0, #3 <== NOT EXECUTED
out_nolock:
if (read > 0)
return read;
return ret;
}
3000fd88: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000f7c0 <pipe_release>:
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
3000f7c0: e5913014 ldr r3, [r1, #20]
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000f7c4: e92d40f1 push {r0, r4, r5, r6, r7, lr}
pipe_control_t *pipe = *pipep;
3000f7c8: e5904000 ldr r4, [r0]
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
3000f7cc: e3130002 tst r3, #2
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
3000f7d0: e2036006 and r6, r3, #6
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
3000f7d4: 15943010 ldrne r3, [r4, #16]
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000f7d8: e1a05000 mov r5, r0
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
3000f7dc: 12433001 subne r3, r3, #1 3000f7e0: 15843010 strne r3, [r4, #16]
if (mode & LIBIO_FLAGS_WRITE)
3000f7e4: e3160004 tst r6, #4
pipe->Writers --;
3000f7e8: 15943014 ldrne r3, [r4, #20]
PIPE_UNLOCK(pipe);
3000f7ec: e5940028 ldr r0, [r4, #40] ; 0x28
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
3000f7f0: 12433001 subne r3, r3, #1 3000f7f4: 15843014 strne r3, [r4, #20]
PIPE_UNLOCK(pipe);
3000f7f8: ebffef22 bl 3000b488 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
3000f7fc: e5943010 ldr r3, [r4, #16] 3000f800: e3530000 cmp r3, #0
3000f804: 1a000006 bne 3000f824 <pipe_release+0x64>
3000f808: e5947014 ldr r7, [r4, #20] 3000f80c: e3570000 cmp r7, #0
3000f810: 1a000003 bne 3000f824 <pipe_release+0x64>
#if 0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
3000f814: e1a00004 mov r0, r4 3000f818: ebffffdb bl 3000f78c <pipe_free>
*pipep = NULL;
3000f81c: e5857000 str r7, [r5] 3000f820: ea000010 b 3000f868 <pipe_release+0xa8>
} else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
3000f824: e2562004 subs r2, r6, #4 3000f828: 13a02001 movne r2, #1 3000f82c: e3530000 cmp r3, #0 3000f830: 13a02000 movne r2, #0 3000f834: e3520000 cmp r2, #0
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
3000f838: 15940030 ldrne r0, [r4, #48] ; 0x30
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
3000f83c: 1a000007 bne 3000f860 <pipe_release+0xa0>
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
3000f840: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000f844: e2566002 subs r6, r6, #2 <== NOT EXECUTED 3000f848: 13a06001 movne r6, #1 <== NOT EXECUTED 3000f84c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f850: 13a06000 movne r6, #0 <== NOT EXECUTED 3000f854: e3560000 cmp r6, #0 <== NOT EXECUTED 3000f858: 0a000002 beq 3000f868 <pipe_release+0xa8> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
3000f85c: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
3000f860: e1a0100d mov r1, sp 3000f864: eb000474 bl 30010a3c <rtems_barrier_release>
pipe_unlock();
3000f868: ebffffc3 bl 3000f77c <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
3000f86c: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
3000fd8c <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000fd8c: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
3000fd90: e2527000 subs r7, r2, #0
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000fd94: e1a04000 mov r4, r0 3000fd98: e1a0b001 mov fp, r1 3000fd9c: e1a08003 mov r8, r3
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
3000fda0: 01a00007 moveq r0, r7
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
3000fda4: 0a00005e beq 3000ff24 <pipe_write+0x198>
return 0;
if (! PIPE_LOCK(pipe))
3000fda8: e3a01000 mov r1, #0 3000fdac: e5940028 ldr r0, [r4, #40] ; 0x28 3000fdb0: e1a02001 mov r2, r1 3000fdb4: ebffed6d bl 3000b370 <rtems_semaphore_obtain> 3000fdb8: e3500000 cmp r0, #0
return -EINTR;
3000fdbc: 13e00003 mvnne r0, #3
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
3000fdc0: 1a000057 bne 3000ff24 <pipe_write+0x198>
return -EINTR;
if (pipe->Readers == 0) {
3000fdc4: e5945010 ldr r5, [r4, #16] 3000fdc8: e3550000 cmp r5, #0
3000fdcc: 0a00004c beq 3000ff04 <pipe_write+0x178>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
3000fdd0: e5949004 ldr r9, [r4, #4]
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
3000fdd4: e1a05000 mov r5, r0
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
3000fdd8: e1570009 cmp r7, r9 3000fddc: 91a09007 movls r9, r7 3000fde0: 83a09001 movhi r9, #1 3000fde4: ea000040 b 3000feec <pipe_write+0x160>
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
3000fde8: e598a014 ldr sl, [r8, #20] 3000fdec: e21aa001 ands sl, sl, #1
3000fdf0: 1a000041 bne 3000fefc <pipe_write+0x170>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
3000fdf4: e594301c ldr r3, [r4, #28]
PIPE_UNLOCK(pipe);
3000fdf8: e5940028 ldr r0, [r4, #40] ; 0x28
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
3000fdfc: e2833001 add r3, r3, #1 3000fe00: e584301c str r3, [r4, #28]
PIPE_UNLOCK(pipe);
3000fe04: ebffed9f bl 3000b488 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
3000fe08: e1a0100a mov r1, sl 3000fe0c: e5940030 ldr r0, [r4, #48] ; 0x30 3000fe10: eb00031f bl 30010a94 <rtems_barrier_wait> 3000fe14: e3500000 cmp r0, #0 3000fe18: 01a06000 moveq r6, r0 3000fe1c: 13e06003 mvnne r6, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
3000fe20: e1a0100a mov r1, sl 3000fe24: e5940028 ldr r0, [r4, #40] ; 0x28 3000fe28: e1a0200a mov r2, sl 3000fe2c: ebffed4f bl 3000b370 <rtems_semaphore_obtain> 3000fe30: e3500000 cmp r0, #0
3000fe34: 1a000036 bne 3000ff14 <pipe_write+0x188>
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
3000fe38: e594301c ldr r3, [r4, #28]
if (ret != 0)
3000fe3c: e3560000 cmp r6, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
3000fe40: e2433001 sub r3, r3, #1 3000fe44: e584301c str r3, [r4, #28]
if (ret != 0)
3000fe48: 1a00002e bne 3000ff08 <pipe_write+0x17c>
goto out_locked;
if (pipe->Readers == 0) {
3000fe4c: e5943010 ldr r3, [r4, #16] 3000fe50: e3530000 cmp r3, #0
3000fe54: 0a00002a beq 3000ff04 <pipe_write+0x178>
/* 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) {
3000fe58: e594a004 ldr sl, [r4, #4] 3000fe5c: e594300c ldr r3, [r4, #12] 3000fe60: e063200a rsb r2, r3, sl 3000fe64: e1520009 cmp r2, r9
3000fe68: 3affffde bcc 3000fde8 <pipe_write+0x5c>
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
3000fe6c: e5940008 ldr r0, [r4, #8] 3000fe70: e1a0100a mov r1, sl 3000fe74: e0830000 add r0, r3, r0
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
3000fe78: e0656007 rsb r6, r5, r7 3000fe7c: e1520006 cmp r2, r6 3000fe80: 31a06002 movcc r6, r2
chunk1 = pipe->Size - PIPE_WSTART(pipe);
3000fe84: eb003b48 bl 3001ebac <__umodsi3> 3000fe88: e5943000 ldr r3, [r4] 3000fe8c: e060a00a rsb sl, r0, sl
if (chunk > chunk1) {
3000fe90: e156000a cmp r6, sl 3000fe94: e08b1005 add r1, fp, r5
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);
3000fe98: d0830000 addle r0, r3, r0 3000fe9c: d1a02006 movle r2, r6
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
3000fea0: da000006 ble 3000fec0 <pipe_write+0x134>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
3000fea4: e1a0200a mov r2, sl 3000fea8: e0830000 add r0, r3, r0 3000feac: eb000bdd bl 30012e28 <memcpy>
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
3000feb0: e08a1005 add r1, sl, r5 3000feb4: e5940000 ldr r0, [r4] 3000feb8: e08b1001 add r1, fp, r1 3000febc: e06a2006 rsb r2, sl, r6
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
3000fec0: eb000bd8 bl 30012e28 <memcpy>
pipe->Length += chunk;
3000fec4: e594300c ldr r3, [r4, #12] 3000fec8: e0833006 add r3, r3, r6 3000fecc: e584300c str r3, [r4, #12]
if (pipe->waitingReaders > 0)
3000fed0: e5943018 ldr r3, [r4, #24] 3000fed4: e3530000 cmp r3, #0
PIPE_WAKEUPREADERS(pipe);
3000fed8: 1594002c ldrne r0, [r4, #44] ; 0x2c 3000fedc: 11a0100d movne r1, sp 3000fee0: 1b0002d5 blne 30010a3c <rtems_barrier_release>
written += chunk;
3000fee4: e0855006 add r5, r5, r6
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
3000fee8: e3a09001 mov r9, #1
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
3000feec: e1550007 cmp r5, r7
3000fef0: 3affffd8 bcc 3000fe58 <pipe_write+0xcc>
3000fef4: e3a06000 mov r6, #0 3000fef8: ea000002 b 3000ff08 <pipe_write+0x17c>
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
3000fefc: e3e0600a mvn r6, #10 3000ff00: ea000000 b 3000ff08 <pipe_write+0x17c>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
3000ff04: e3e0601f mvn r6, #31
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
3000ff08: e5940028 ldr r0, [r4, #40] ; 0x28 3000ff0c: ebffed5d bl 3000b488 <rtems_semaphore_release> 3000ff10: ea000000 b 3000ff18 <pipe_write+0x18c>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
3000ff14: e3e06003 mvn r6, #3 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
3000ff18: e3550000 cmp r5, #0 3000ff1c: c1a00005 movgt r0, r5 3000ff20: d1a00006 movle r0, r6
return written;
return ret;
}
3000ff24: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000af6c <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
3000af6c: e59fc040 ldr ip, [pc, #64] ; 3000afb4 <posix_memalign+0x48><== NOT EXECUTED
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
3000af70: e92d4010 push {r4, lr} <== NOT EXECUTED
/* * Update call statistics */ MSBUMP(memalign_calls, 1);
3000af74: e59c4008 ldr r4, [ip, #8] <== NOT EXECUTED 3000af78: e2844001 add r4, r4, #1 <== NOT EXECUTED 3000af7c: e58c4008 str r4, [ip, #8] <== NOT EXECUTED
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
3000af80: e241c001 sub ip, r1, #1 <== NOT EXECUTED 3000af84: e11c0001 tst ip, r1 <== NOT EXECUTED 3000af88: 03a0c000 moveq ip, #0 <== NOT EXECUTED 3000af8c: 13a0c001 movne ip, #1 <== NOT EXECUTED 3000af90: e3510003 cmp r1, #3 <== NOT EXECUTED 3000af94: 81a0300c movhi r3, ip <== NOT EXECUTED 3000af98: 938c3001 orrls r3, ip, #1 <== NOT EXECUTED 3000af9c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000afa0: 1a000001 bne 3000afac <posix_memalign+0x40> <== NOT EXECUTED
/* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); }
3000afa4: e8bd4010 pop {r4, lr} <== NOT EXECUTED
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
3000afa8: ea000077 b 3000b18c <rtems_memalign> <== NOT EXECUTED
}
3000afac: e3a00016 mov r0, #22 <== NOT EXECUTED
3000afb0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000840c <printk_plugin>:
int printk_plugin(
void *ignored __attribute__((unused)),
const char *format,
...
)
{
3000840c: e92d000e push {r1, r2, r3} <== NOT EXECUTED
30008410: e92d4001 push {r0, lr} <== NOT EXECUTED
va_list arg_pointer;
va_start (arg_pointer, format);
vprintk( format, arg_pointer );
30008414: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
...
)
{
va_list arg_pointer;
va_start (arg_pointer, format);
30008418: e28d100c add r1, sp, #12 <== NOT EXECUTED 3000841c: e58d1000 str r1, [sp] <== NOT EXECUTED
vprintk( format, arg_pointer );
30008420: eb0006c8 bl 30009f48 <vprintk> <== NOT EXECUTED
va_end(arg_pointer); /* clean up when done */
return 0;
}
30008424: e3a00000 mov r0, #0 <== NOT EXECUTED
30008428: e8bd4008 pop {r3, lr} <== NOT EXECUTED
3000842c: e28dd00c add sp, sp, #12 <== NOT EXECUTED
30008430: e12fff1e bx lr <== NOT EXECUTED
30015b88 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
30015b88: e92d4030 push {r4, r5, lr}
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30015b8c: e59f4098 ldr r4, [pc, #152] ; 30015c2c <read+0xa4> 30015b90: e5944000 ldr r4, [r4] 30015b94: e1500004 cmp r0, r4
30015b98: 2a000006 bcs 30015bb8 <read+0x30> iop = rtems_libio_iop( fd );
30015b9c: e59f408c ldr r4, [pc, #140] ; 30015c30 <read+0xa8> 30015ba0: e3a05038 mov r5, #56 ; 0x38 30015ba4: e5944000 ldr r4, [r4] 30015ba8: e0244095 mla r4, r5, r0, r4
rtems_libio_check_is_open( iop );
30015bac: e5940014 ldr r0, [r4, #20] 30015bb0: e3100c01 tst r0, #256 ; 0x100
30015bb4: 1a000002 bne 30015bc4 <read+0x3c>
30015bb8: ebffe99f bl 3001023c <__errno> <== NOT EXECUTED 30015bbc: e3a03009 mov r3, #9 <== NOT EXECUTED 30015bc0: ea000003 b 30015bd4 <read+0x4c> <== NOT EXECUTED
rtems_libio_check_buffer( buffer );
30015bc4: e3510000 cmp r1, #0
30015bc8: 1a000004 bne 30015be0 <read+0x58>
30015bcc: ebffe99a bl 3001023c <__errno> <== NOT EXECUTED
30015bd0: e3a03016 mov r3, #22 <== NOT EXECUTED
30015bd4: e5803000 str r3, [r0] <== NOT EXECUTED
30015bd8: e3e00000 mvn r0, #0 <== NOT EXECUTED
30015bdc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
rtems_libio_check_count( count );
30015be0: e3520000 cmp r2, #0
30015be4: 0a00000e beq 30015c24 <read+0x9c> rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30015be8: e3100002 tst r0, #2
30015bec: 0afffff6 beq 30015bcc <read+0x44>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
30015bf0: e5943020 ldr r3, [r4, #32] 30015bf4: e1a00004 mov r0, r4 30015bf8: e1a0e00f mov lr, pc 30015bfc: e593f008 ldr pc, [r3, #8]
if ( rc > 0 )
30015c00: e3500000 cmp r0, #0
30015c04: d8bd8030 pople {r4, r5, pc}
iop->offset += rc;
30015c08: e284300c add r3, r4, #12
30015c0c: e893000c ldm r3, {r2, r3}
30015c10: e0922000 adds r2, r2, r0
30015c14: e0a33fc0 adc r3, r3, r0, asr #31
30015c18: e584200c str r2, [r4, #12]
30015c1c: e5843010 str r3, [r4, #16]
30015c20: e8bd8030 pop {r4, r5, pc}
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
30015c24: e1a00002 mov r0, r2 <== NOT EXECUTED
if ( rc > 0 )
iop->offset += rc;
return rc;
}
30015c28: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
300096d8 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
300096d8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
300096dc: e2516000 subs r6, r1, #0 <== NOT EXECUTED
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
300096e0: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 300096e4: e1a07000 mov r7, r0 <== NOT EXECUTED 300096e8: e1a05002 mov r5, r2 <== NOT EXECUTED
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
300096ec: 1a000002 bne 300096fc <readlink+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
300096f0: eb0026ba bl 300131e0 <__errno> <== NOT EXECUTED 300096f4: e3a0300e mov r3, #14 <== NOT EXECUTED 300096f8: ea000013 b 3000974c <readlink+0x74> <== NOT EXECUTED
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
300096fc: eb002e2d bl 30014fb8 <strlen> <== NOT EXECUTED 30009700: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30009704: e1a01000 mov r1, r0 <== NOT EXECUTED 30009708: e3a02000 mov r2, #0 <== NOT EXECUTED 3000970c: e1a00007 mov r0, r7 <== NOT EXECUTED 30009710: e1a03004 mov r3, r4 <== NOT EXECUTED 30009714: e58d2000 str r2, [sp] <== NOT EXECUTED 30009718: ebfffbb1 bl 300085e4 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
0, &loc, false );
if ( result != 0 )
3000971c: e3500000 cmp r0, #0 <== NOT EXECUTED 30009720: 1a000016 bne 30009780 <readlink+0xa8> <== NOT EXECUTED
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
30009724: e1a00004 mov r0, r4 <== NOT EXECUTED 30009728: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000972c: e1a0e00f mov lr, pc <== NOT EXECUTED 30009730: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED 30009734: e3500004 cmp r0, #4 <== NOT EXECUTED 30009738: 0a000005 beq 30009754 <readlink+0x7c> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
3000973c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009740: ebfffbd7 bl 300086a4 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009744: eb0026a5 bl 300131e0 <__errno> <== NOT EXECUTED 30009748: e3a03016 mov r3, #22 <== NOT EXECUTED 3000974c: e5803000 str r3, [r0] <== NOT EXECUTED 30009750: ea00000a b 30009780 <readlink+0xa8> <== NOT EXECUTED
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
30009754: e1a02005 mov r2, r5 <== NOT EXECUTED 30009758: e1a01006 mov r1, r6 <== NOT EXECUTED 3000975c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30009760: e1a00004 mov r0, r4 <== NOT EXECUTED 30009764: e1a0e00f mov lr, pc <== NOT EXECUTED 30009768: e593f03c ldr pc, [r3, #60] ; 0x3c <== NOT EXECUTED 3000976c: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30009770: e1a00004 mov r0, r4 <== NOT EXECUTED 30009774: ebfffbca bl 300086a4 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
30009778: e1a00005 mov r0, r5 <== NOT EXECUTED 3000977c: ea000000 b 30009784 <readlink+0xac> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
return -1;
30009780: e3e00000 mvn r0, #0 <== NOT EXECUTED
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
rtems_filesystem_freenode( &loc );
return result;
}
30009784: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30009788: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30008130 <readv>:
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
30008130: e59f3130 ldr r3, [pc, #304] ; 30008268 <readv+0x138> <== NOT EXECUTED
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
30008134: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
30008138: e5933000 ldr r3, [r3] <== NOT EXECUTED
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
3000813c: e1a08002 mov r8, r2 <== NOT EXECUTED
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
30008140: e1500003 cmp r0, r3 <== NOT EXECUTED 30008144: 2a000006 bcs 30008164 <readv+0x34> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
30008148: e59f311c ldr r3, [pc, #284] ; 3000826c <readv+0x13c> <== NOT EXECUTED 3000814c: e3a06038 mov r6, #56 ; 0x38 <== NOT EXECUTED 30008150: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008154: e0263690 mla r6, r0, r6, r3 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
30008158: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 3000815c: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30008160: 1a000002 bne 30008170 <readv+0x40> <== NOT EXECUTED 30008164: eb002419 bl 300111d0 <__errno> <== NOT EXECUTED 30008168: e3a03009 mov r3, #9 <== NOT EXECUTED 3000816c: ea000017 b 300081d0 <readv+0xa0> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30008170: e3130002 tst r3, #2 <== NOT EXECUTED 30008174: 0a000013 beq 300081c8 <readv+0x98> <== NOT EXECUTED
/*
* Argument validation on IO vector
*/
if ( !iov )
30008178: e3510000 cmp r1, #0 <== NOT EXECUTED 3000817c: 0a000011 beq 300081c8 <readv+0x98> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
30008180: e3520000 cmp r2, #0 <== NOT EXECUTED 30008184: da00000f ble 300081c8 <readv+0x98> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
30008188: e3520b01 cmp r2, #1024 ; 0x400 <== NOT EXECUTED 3000818c: ca00000d bgt 300081c8 <readv+0x98> <== NOT EXECUTED 30008190: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30008194: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
30008198: e1a02001 mov r2, r1 <== NOT EXECUTED 3000819c: e3a07001 mov r7, #1 <== NOT EXECUTED 300081a0: e1a01003 mov r1, r3 <== NOT EXECUTED 300081a4: ea000000 b 300081ac <readv+0x7c> <== NOT EXECUTED
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
300081a8: e1a0100c mov r1, ip <== NOT EXECUTED
/*
* 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 )
300081ac: e5920000 ldr r0, [r2] <== NOT EXECUTED 300081b0: e3500000 cmp r0, #0 <== NOT EXECUTED 300081b4: 0a000003 beq 300081c8 <readv+0x98> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
300081b8: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED 300081bc: e081c000 add ip, r1, r0 <== NOT EXECUTED
if ( total < old )
300081c0: e15c0001 cmp ip, r1 <== NOT EXECUTED 300081c4: aa000003 bge 300081d8 <readv+0xa8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
300081c8: eb002400 bl 300111d0 <__errno> <== NOT EXECUTED 300081cc: e3a03016 mov r3, #22 <== NOT EXECUTED 300081d0: e5803000 str r3, [r0] <== NOT EXECUTED 300081d4: ea000020 b 3000825c <readv+0x12c> <== NOT EXECUTED
if ( iov[v].iov_len )
all_zeros = false;
300081d8: e3500000 cmp r0, #0 <== NOT EXECUTED
* 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++ ) {
300081dc: e2833001 add r3, r3, #1 <== NOT EXECUTED
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
300081e0: 13a07000 movne r7, #0 <== NOT EXECUTED
* 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++ ) {
300081e4: e1530008 cmp r3, r8 <== NOT EXECUTED 300081e8: e2822008 add r2, r2, #8 <== NOT EXECUTED 300081ec: baffffed blt 300081a8 <readv+0x78> <== NOT EXECUTED
/*
* 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 ) {
300081f0: e3570000 cmp r7, #0 <== NOT EXECUTED
return 0;
300081f4: 13a04000 movne r4, #0 <== NOT EXECUTED
/*
* 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 ) {
300081f8: 1a000018 bne 30008260 <readv+0x130> <== NOT EXECUTED 300081fc: e1a04007 mov r4, r7 <== NOT EXECUTED
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
30008200: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED
30008204: e1a00006 mov r0, r6 <== NOT EXECUTED
30008208: e8950006 ldm r5, {r1, r2} <== NOT EXECUTED
3000820c: e1a0e00f mov lr, pc <== NOT EXECUTED
30008210: e593f008 ldr pc, [r3, #8] <== NOT EXECUTED
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
30008214: e3500000 cmp r0, #0 <== NOT EXECUTED 30008218: ba00000f blt 3000825c <readv+0x12c> <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
3000821c: 0a000006 beq 3000823c <readv+0x10c> <== NOT EXECUTED
iop->offset += bytes;
30008220: e286300c add r3, r6, #12 <== NOT EXECUTED
30008224: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30008228: e0922000 adds r2, r2, r0 <== NOT EXECUTED
3000822c: e0a33fc0 adc r3, r3, r0, asr #31 <== NOT EXECUTED
30008230: e586200c str r2, [r6, #12] <== NOT EXECUTED
30008234: e5863010 str r3, [r6, #16] <== NOT EXECUTED
total += bytes;
30008238: e0844000 add r4, r4, r0 <== NOT EXECUTED
}
if (bytes != iov[ v ].iov_len)
3000823c: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 30008240: e1500003 cmp r0, r3 <== NOT EXECUTED 30008244: 1a000005 bne 30008260 <readv+0x130> <== NOT EXECUTED
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
30008248: e2877001 add r7, r7, #1 <== NOT EXECUTED 3000824c: e1570008 cmp r7, r8 <== NOT EXECUTED 30008250: e2855008 add r5, r5, #8 <== NOT EXECUTED 30008254: baffffe9 blt 30008200 <readv+0xd0> <== NOT EXECUTED 30008258: ea000000 b 30008260 <readv+0x130> <== NOT EXECUTED
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
3000825c: e3e04000 mvn r4, #0 <== NOT EXECUTED
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
30008260: e1a00004 mov r0, r4 <== NOT EXECUTED
30008264: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30015c98 <realloc>:
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30015c98: e59f310c ldr r3, [pc, #268] ; 30015dac <realloc+0x114>
void *realloc(
void *ptr,
size_t size
)
{
30015c9c: e92d40f1 push {r0, r4, r5, r6, r7, lr}
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30015ca0: e5932010 ldr r2, [r3, #16]
void *realloc(
void *ptr,
size_t size
)
{
30015ca4: e1a04000 mov r4, r0
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30015ca8: e2822001 add r2, r2, #1 30015cac: e5832010 str r2, [r3, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30015cb0: e59f30f8 ldr r3, [pc, #248] ; 30015db0 <realloc+0x118>
void *realloc(
void *ptr,
size_t size
)
{
30015cb4: e1a05001 mov r5, r1
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30015cb8: e5933000 ldr r3, [r3] 30015cbc: e3530003 cmp r3, #3
30015cc0: 1a000009 bne 30015cec <realloc+0x54>
if (_Thread_Dispatch_disable_level > 0)
30015cc4: e59f30e8 ldr r3, [pc, #232] ; 30015db4 <realloc+0x11c> 30015cc8: e5933000 ldr r3, [r3] 30015ccc: e3530000 cmp r3, #0
return (void *) 0;
30015cd0: 13a04000 movne r4, #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_disable_level > 0)
30015cd4: 1a000032 bne 30015da4 <realloc+0x10c>
return (void *) 0;
if (_ISR_Nest_level > 0)
30015cd8: e59f20d8 ldr r2, [pc, #216] ; 30015db8 <realloc+0x120> 30015cdc: e5922000 ldr r2, [r2] 30015ce0: e3520000 cmp r2, #0
return (void *) 0;
30015ce4: 11a04003 movne r4, r3
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
return (void *) 0;
if (_ISR_Nest_level > 0)
30015ce8: 1a00002d bne 30015da4 <realloc+0x10c>
}
/*
* Continue with realloc().
*/
if ( !ptr )
30015cec: e3540000 cmp r4, #0
30015cf0: 1a000003 bne 30015d04 <realloc+0x6c>
return malloc( size );
30015cf4: e1a00005 mov r0, r5 30015cf8: ebffc238 bl 300065e0 <malloc> 30015cfc: e1a04000 mov r4, r0 30015d00: ea000027 b 30015da4 <realloc+0x10c>
if ( !size ) {
30015d04: e3550000 cmp r5, #0
30015d08: 1a000003 bne 30015d1c <realloc+0x84>
free( ptr );
30015d0c: e1a00004 mov r0, r4 <== NOT EXECUTED 30015d10: ebffc163 bl 300062a4 <free> <== NOT EXECUTED
return (void *) 0;
30015d14: e1a04005 mov r4, r5 <== NOT EXECUTED 30015d18: ea000021 b 30015da4 <realloc+0x10c> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
30015d1c: e59f6098 ldr r6, [pc, #152] ; 30015dbc <realloc+0x124> 30015d20: e1a01004 mov r1, r4 30015d24: e5960000 ldr r0, [r6] 30015d28: e1a0200d mov r2, sp 30015d2c: eb00004e bl 30015e6c <_Protected_heap_Get_block_size> 30015d30: e2507000 subs r7, r0, #0
30015d34: 1a000004 bne 30015d4c <realloc+0xb4>
errno = EINVAL;
30015d38: ebffe93f bl 3001023c <__errno> <== NOT EXECUTED 30015d3c: e3a03016 mov r3, #22 <== NOT EXECUTED 30015d40: e5803000 str r3, [r0] <== NOT EXECUTED
return (void *) 0;
30015d44: e1a04007 mov r4, r7 <== NOT EXECUTED 30015d48: ea000015 b 30015da4 <realloc+0x10c> <== NOT EXECUTED
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
30015d4c: e5960000 ldr r0, [r6] 30015d50: e1a01004 mov r1, r4 30015d54: e1a02005 mov r2, r5 30015d58: eb000054 bl 30015eb0 <_Protected_heap_Resize_block> 30015d5c: e3500000 cmp r0, #0
30015d60: 1a00000f bne 30015da4 <realloc+0x10c>
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
30015d64: e1a00005 mov r0, r5 30015d68: ebffc21c bl 300065e0 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
30015d6c: e59f3038 ldr r3, [pc, #56] ; 30015dac <realloc+0x114>
if ( !new_area ) {
30015d70: e2506000 subs r6, r0, #0
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
30015d74: e5932004 ldr r2, [r3, #4] 30015d78: e2422001 sub r2, r2, #1 30015d7c: e5832004 str r2, [r3, #4]
if ( !new_area ) {
30015d80: 0a000006 beq 30015da0 <realloc+0x108>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
30015d84: e59d2000 ldr r2, [sp] <== NOT EXECUTED 30015d88: e1a01004 mov r1, r4 <== NOT EXECUTED 30015d8c: e1550002 cmp r5, r2 <== NOT EXECUTED 30015d90: 31a02005 movcc r2, r5 <== NOT EXECUTED 30015d94: ebffeb56 bl 30010af4 <memcpy> <== NOT EXECUTED
free( ptr );
30015d98: e1a00004 mov r0, r4 <== NOT EXECUTED 30015d9c: ebffc140 bl 300062a4 <free> <== NOT EXECUTED
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
30015da0: e1a04006 mov r4, r6
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
30015da4: e1a00004 mov r0, r4
30015da8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
300074b8 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
300074b8: e92d40f0 push {r4, r5, r6, r7, lr}
300074bc: e24dd030 sub sp, sp, #48 ; 0x30
300074c0: e1a06000 mov r6, r0
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
300074c4: ebfffc6b bl 30006678 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
300074c8: e2504000 subs r4, r0, #0 300074cc: e28d3018 add r3, sp, #24
300074d0: 1a000005 bne 300074ec <rmdir+0x34>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
300074d4: e1a00006 mov r0, r6 <== NOT EXECUTED 300074d8: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 300074dc: e1a02003 mov r2, r3 <== NOT EXECUTED 300074e0: eb000048 bl 30007608 <rtems_filesystem_get_start_loc> <== NOT EXECUTED
const char *name; rtems_filesystem_location_info_t parentloc; rtems_filesystem_location_info_t loc; int i; int result; bool free_parentloc = false;
300074e4: e1a05004 mov r5, r4 <== NOT EXECUTED 300074e8: ea000008 b 30007510 <rmdir+0x58> <== NOT EXECUTED
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
300074ec: e3a02000 mov r2, #0 300074f0: e58d2000 str r2, [sp] 300074f4: e1a00006 mov r0, r6 300074f8: e1a01004 mov r1, r4 300074fc: e2822002 add r2, r2, #2 30007500: ebfffc49 bl 3000662c <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
30007504: e3500000 cmp r0, #0
30007508: 1a00003a bne 300075f8 <rmdir+0x140>
return -1;
free_parentloc = true;
3000750c: e3a05001 mov r5, #1
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30007510: e28dc004 add ip, sp, #4
30007514: e28de018 add lr, sp, #24
30007518: e8be000f ldm lr!, {r0, r1, r2, r3}
3000751c: e8ac000f stmia ip!, {r0, r1, r2, r3}
name = pathname + parentpathlen;
30007520: e0864004 add r4, r6, r4
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30007524: e59e3000 ldr r3, [lr]
name = pathname + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
30007528: e1a00004 mov r0, r4
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
3000752c: e58c3000 str r3, [ip]
name = pathname + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
30007530: eb0028f7 bl 30011914 <strlen> 30007534: e1a01000 mov r1, r0 30007538: e1a00004 mov r0, r4 3000753c: ebfffc5b bl 300066b0 <rtems_filesystem_prefix_separators> 30007540: e0846000 add r6, r4, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
30007544: e1a00006 mov r0, r6 30007548: eb0028f1 bl 30011914 <strlen> 3000754c: e28d4004 add r4, sp, #4 30007550: e1a01000 mov r1, r0 30007554: e3a02000 mov r2, #0 30007558: e1a00006 mov r0, r6 3000755c: e1a03004 mov r3, r4 30007560: e58d2000 str r2, [sp] 30007564: ebfffc14 bl 300065bc <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
30007568: e3500000 cmp r0, #0
3000756c: 0a000004 beq 30007584 <rmdir+0xcc>
if ( free_parentloc )
30007570: e3550000 cmp r5, #0 <== NOT EXECUTED 30007574: 0a00001f beq 300075f8 <rmdir+0x140> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
30007578: e28d0018 add r0, sp, #24 <== NOT EXECUTED 3000757c: ebfffc5a bl 300066ec <rtems_filesystem_freenode> <== NOT EXECUTED 30007580: ea00001c b 300075f8 <rmdir+0x140> <== NOT EXECUTED
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
30007584: e1a00004 mov r0, r4 30007588: e59d3010 ldr r3, [sp, #16] 3000758c: e1a0e00f mov lr, pc 30007590: e593f010 ldr pc, [r3, #16] 30007594: e3500001 cmp r0, #1
30007598: 0a000008 beq 300075c0 <rmdir+0x108>
rtems_filesystem_freenode( &loc );
3000759c: e1a00004 mov r0, r4 <== NOT EXECUTED 300075a0: ebfffc51 bl 300066ec <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_parentloc )
300075a4: e3550000 cmp r5, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
300075a8: 128d0018 addne r0, sp, #24 <== NOT EXECUTED 300075ac: 1bfffc4e blne 300066ec <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTDIR );
300075b0: eb002518 bl 30010a18 <__errno> <== NOT EXECUTED 300075b4: e3a03014 mov r3, #20 <== NOT EXECUTED 300075b8: e5803000 str r3, [r0] <== NOT EXECUTED 300075bc: ea00000d b 300075f8 <rmdir+0x140> <== NOT EXECUTED
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
300075c0: e28d6018 add r6, sp, #24 300075c4: e1a01004 mov r1, r4 300075c8: e59d300c ldr r3, [sp, #12] 300075cc: e1a00006 mov r0, r6 300075d0: e1a0e00f mov lr, pc 300075d4: e593f034 ldr pc, [r3, #52] ; 0x34 300075d8: e1a07000 mov r7, r0
rtems_filesystem_freenode( &loc );
300075dc: e1a00004 mov r0, r4 300075e0: ebfffc41 bl 300066ec <rtems_filesystem_freenode>
if ( free_parentloc )
300075e4: e3550000 cmp r5, #0
300075e8: 0a000003 beq 300075fc <rmdir+0x144>
rtems_filesystem_freenode( &parentloc );
300075ec: e1a00006 mov r0, r6 300075f0: ebfffc3d bl 300066ec <rtems_filesystem_freenode> 300075f4: ea000000 b 300075fc <rmdir+0x144>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
300075f8: e3e07000 mvn r7, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
300075fc: e1a00007 mov r0, r7
30007600: e28dd030 add sp, sp, #48 ; 0x30
30007604: e8bd80f0 pop {r4, r5, r6, r7, pc}
30006ba4 <rtems_assoc_local_by_name>:
uint32_t rtems_assoc_local_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30006ba4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_name(ap, name);
30006ba8: eb00007a bl 30006d98 <rtems_assoc_ptr_by_name> <== NOT EXECUTED
if (nap)
30006bac: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->local_value;
30006bb0: 15900004 ldrne r0, [r0, #4] <== NOT EXECUTED
return 0;
}
30006bb4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30015014 <rtems_assoc_name_bad>:
sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value);
#else
static char bad_buffer[40] = "<assocnamebad.c: : BAD NAME>";
#endif
return bad_buffer;
}
30015014: e59f0000 ldr r0, [pc, #0] ; 3001501c <rtems_assoc_name_bad+0x8><== NOT EXECUTED 30015018: e12fff1e bx lr <== NOT EXECUTED
300129b0 <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
300129b0: e92d4010 push {r4, lr} <== NOT EXECUTED
300129b4: e1a04001 mov r4, r1 <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
300129b8: eb000006 bl 300129d8 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if (nap)
300129bc: e3500000 cmp r0, #0 <== NOT EXECUTED 300129c0: 0a000001 beq 300129cc <rtems_assoc_name_by_local+0x1c> <== NOT EXECUTED
return nap->name;
return rtems_assoc_name_bad(local_value);
}
300129c4: e5900000 ldr r0, [r0] <== NOT EXECUTED
300129c8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
300129cc: e1a00004 mov r0, r4 <== NOT EXECUTED
}
300129d0: e8bd4010 pop {r4, lr} <== NOT EXECUTED
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
300129d4: ea00098e b 30015014 <rtems_assoc_name_bad> <== NOT EXECUTED
30006c10 <rtems_assoc_name_by_local_bitfield>:
char *buffer
)
{
uint32_t b;
*buffer = 0;
30006c10: e3a03000 mov r3, #0 <== NOT EXECUTED
char *rtems_assoc_name_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t value,
char *buffer
)
{
30006c14: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uint32_t b;
*buffer = 0;
30006c18: e5c23000 strb r3, [r2] <== NOT EXECUTED
char *rtems_assoc_name_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t value,
char *buffer
)
{
30006c1c: e1a05000 mov r5, r0 <== NOT EXECUTED 30006c20: e1a04001 mov r4, r1 <== NOT EXECUTED 30006c24: e1a06002 mov r6, r2 <== NOT EXECUTED
uint32_t b;
*buffer = 0;
30006c28: e3a08020 mov r8, #32 <== NOT EXECUTED
for (b = 1; b; b <<= 1) {
30006c2c: e3a07001 mov r7, #1 <== NOT EXECUTED
if (b & value) {
30006c30: e1170004 tst r7, r4 <== NOT EXECUTED 30006c34: 0a00000a beq 30006c64 <rtems_assoc_name_by_local_bitfield+0x54><== NOT EXECUTED
if (*buffer)
30006c38: e5d63000 ldrb r3, [r6] <== NOT EXECUTED 30006c3c: e3530000 cmp r3, #0 <== NOT EXECUTED
strcat(buffer, " ");
30006c40: 11a00006 movne r0, r6 <== NOT EXECUTED 30006c44: 159f102c ldrne r1, [pc, #44] ; 30006c78 <rtems_assoc_name_by_local_bitfield+0x68><== NOT EXECUTED 30006c48: 1b002bab blne 30011afc <strcat> <== NOT EXECUTED
strcat(buffer, rtems_assoc_name_by_local(ap, b));
30006c4c: e1a01007 mov r1, r7 <== NOT EXECUTED 30006c50: e1a00005 mov r0, r5 <== NOT EXECUTED 30006c54: eb000008 bl 30006c7c <rtems_assoc_name_by_local> <== NOT EXECUTED 30006c58: e1a01000 mov r1, r0 <== NOT EXECUTED 30006c5c: e1a00006 mov r0, r6 <== NOT EXECUTED 30006c60: eb002ba5 bl 30011afc <strcat> <== NOT EXECUTED
{
uint32_t b;
*buffer = 0;
for (b = 1; b; b <<= 1) {
30006c64: e2588001 subs r8, r8, #1 <== NOT EXECUTED 30006c68: e1a07087 lsl r7, r7, #1 <== NOT EXECUTED 30006c6c: 1affffef bne 30006c30 <rtems_assoc_name_by_local_bitfield+0x20><== NOT EXECUTED
strcat(buffer, rtems_assoc_name_by_local(ap, b));
}
}
return buffer;
}
30006c70: e1a00006 mov r0, r6 <== NOT EXECUTED
30006c74: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30006d10 <rtems_assoc_name_by_remote>:
const char *rtems_assoc_name_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
30006d10: e92d4010 push {r4, lr} <== NOT EXECUTED
30006d14: e1a04001 mov r4, r1 <== NOT EXECUTED
const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value);
30006d18: eb000038 bl 30006e00 <rtems_assoc_ptr_by_remote> <== NOT EXECUTED
if (nap)
30006d1c: e3500000 cmp r0, #0 <== NOT EXECUTED 30006d20: 0a000001 beq 30006d2c <rtems_assoc_name_by_remote+0x1c> <== NOT EXECUTED
return nap->name;
return rtems_assoc_name_bad(remote_value);
}
30006d24: e5900000 ldr r0, [r0] <== NOT EXECUTED
30006d28: e8bd8010 pop {r4, pc} <== NOT EXECUTED
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(remote_value);
30006d2c: e1a00004 mov r0, r4 <== NOT EXECUTED
}
30006d30: e8bd4010 pop {r4, lr} <== NOT EXECUTED
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(remote_value);
30006d34: ea001e8a b 3000e764 <rtems_assoc_name_bad> <== NOT EXECUTED
30006ca4 <rtems_assoc_name_by_remote_bitfield>:
char *buffer
)
{
uint32_t b;
*buffer = 0;
30006ca4: e3a03000 mov r3, #0 <== NOT EXECUTED
char *rtems_assoc_name_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t value,
char *buffer
)
{
30006ca8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uint32_t b;
*buffer = 0;
30006cac: e5c23000 strb r3, [r2] <== NOT EXECUTED
char *rtems_assoc_name_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t value,
char *buffer
)
{
30006cb0: e1a05000 mov r5, r0 <== NOT EXECUTED 30006cb4: e1a04001 mov r4, r1 <== NOT EXECUTED 30006cb8: e1a06002 mov r6, r2 <== NOT EXECUTED
uint32_t b;
*buffer = 0;
30006cbc: e3a08020 mov r8, #32 <== NOT EXECUTED
for (b = 1; b; b <<= 1) {
30006cc0: e3a07001 mov r7, #1 <== NOT EXECUTED
if (b & value) {
30006cc4: e1170004 tst r7, r4 <== NOT EXECUTED 30006cc8: 0a00000a beq 30006cf8 <rtems_assoc_name_by_remote_bitfield+0x54><== NOT EXECUTED
if (*buffer)
30006ccc: e5d63000 ldrb r3, [r6] <== NOT EXECUTED 30006cd0: e3530000 cmp r3, #0 <== NOT EXECUTED
strcat(buffer, " ");
30006cd4: 11a00006 movne r0, r6 <== NOT EXECUTED 30006cd8: 159f102c ldrne r1, [pc, #44] ; 30006d0c <rtems_assoc_name_by_remote_bitfield+0x68><== NOT EXECUTED 30006cdc: 1b002b86 blne 30011afc <strcat> <== NOT EXECUTED
strcat(buffer, rtems_assoc_name_by_remote(ap, b));
30006ce0: e1a01007 mov r1, r7 <== NOT EXECUTED 30006ce4: e1a00005 mov r0, r5 <== NOT EXECUTED 30006ce8: eb000008 bl 30006d10 <rtems_assoc_name_by_remote> <== NOT EXECUTED 30006cec: e1a01000 mov r1, r0 <== NOT EXECUTED 30006cf0: e1a00006 mov r0, r6 <== NOT EXECUTED 30006cf4: eb002b80 bl 30011afc <strcat> <== NOT EXECUTED
{
uint32_t b;
*buffer = 0;
for (b = 1; b; b <<= 1) {
30006cf8: e2588001 subs r8, r8, #1 <== NOT EXECUTED 30006cfc: e1a07087 lsl r7, r7, #1 <== NOT EXECUTED 30006d00: 1affffef bne 30006cc4 <rtems_assoc_name_by_remote_bitfield+0x20><== NOT EXECUTED
strcat(buffer, rtems_assoc_name_by_remote(ap, b));
}
}
return buffer;
}
30006d04: e1a00006 mov r0, r6 <== NOT EXECUTED
30006d08: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300129d8 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
300129d8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
300129dc: e1a04000 mov r4, r0 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
300129e0: e5900000 ldr r0, [r0] <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
300129e4: e1a05001 mov r5, r1 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
300129e8: e3500000 cmp r0, #0 <== NOT EXECUTED 300129ec: 0a00000a beq 30012a1c <rtems_assoc_ptr_by_local+0x44> <== NOT EXECUTED 300129f0: e59f103c ldr r1, [pc, #60] ; 30012a34 <rtems_assoc_ptr_by_local+0x5c><== NOT EXECUTED 300129f4: eb000e62 bl 30016384 <strcmp> <== NOT EXECUTED 300129f8: e3500000 cmp r0, #0 <== NOT EXECUTED
default_ap = ap++;
300129fc: 01a00004 moveq r0, r4 <== NOT EXECUTED
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;
30012a00: 13a00000 movne r0, #0 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
30012a04: 1a000004 bne 30012a1c <rtems_assoc_ptr_by_local+0x44> <== NOT EXECUTED 30012a08: ea000002 b 30012a18 <rtems_assoc_ptr_by_local+0x40> <== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
30012a0c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30012a10: e1530005 cmp r3, r5 <== NOT EXECUTED 30012a14: 0a000004 beq 30012a2c <rtems_assoc_ptr_by_local+0x54> <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30012a18: e284400c add r4, r4, #12 <== NOT EXECUTED 30012a1c: e5943000 ldr r3, [r4] <== NOT EXECUTED 30012a20: e3530000 cmp r3, #0 <== NOT EXECUTED 30012a24: 1afffff8 bne 30012a0c <rtems_assoc_ptr_by_local+0x34> <== NOT EXECUTED
if (ap->local_value == local_value)
return ap;
return default_ap;
30012a28: e1a04000 mov r4, r0 <== NOT EXECUTED
}
30012a2c: e1a00004 mov r0, r4 <== NOT EXECUTED
30012a30: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30006d98 <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30006d98: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30006d9c: e1a04000 mov r4, r0 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30006da0: e5900000 ldr r0, [r0] <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30006da4: e1a06001 mov r6, r1 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30006da8: e3500000 cmp r0, #0 <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
30006dac: 01a05000 moveq r5, r0 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
30006db0: 0a00000b beq 30006de4 <rtems_assoc_ptr_by_name+0x4c> <== NOT EXECUTED 30006db4: e59f1040 ldr r1, [pc, #64] ; 30006dfc <rtems_assoc_ptr_by_name+0x64><== NOT EXECUTED 30006db8: eb002b7a bl 30011ba8 <strcmp> <== NOT EXECUTED 30006dbc: e3500000 cmp r0, #0 <== NOT EXECUTED
default_ap = ap++;
30006dc0: 01a05004 moveq r5, r4 <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
30006dc4: 13a05000 movne r5, #0 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
30006dc8: 1a000005 bne 30006de4 <rtems_assoc_ptr_by_name+0x4c> <== NOT EXECUTED 30006dcc: ea000003 b 30006de0 <rtems_assoc_ptr_by_name+0x48> <== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (strcmp(ap->name, name) == 0)
30006dd0: e1a01006 mov r1, r6 <== NOT EXECUTED 30006dd4: eb002b73 bl 30011ba8 <strcmp> <== NOT EXECUTED 30006dd8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006ddc: 0a000004 beq 30006df4 <rtems_assoc_ptr_by_name+0x5c> <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30006de0: e284400c add r4, r4, #12 <== NOT EXECUTED 30006de4: e5940000 ldr r0, [r4] <== NOT EXECUTED 30006de8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006dec: 1afffff7 bne 30006dd0 <rtems_assoc_ptr_by_name+0x38> <== NOT EXECUTED
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
30006df0: e1a04005 mov r4, r5 <== NOT EXECUTED
}
30006df4: e1a00004 mov r0, r4 <== NOT EXECUTED
30006df8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000fd94 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
3000fd94: e92d4030 push {r4, r5, lr}
3000fd98: e1a04000 mov r4, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
3000fd9c: e5900000 ldr r0, [r0]
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
3000fda0: e1a05001 mov r5, r1
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
3000fda4: e3500000 cmp r0, #0
3000fda8: 0a00000a beq 3000fdd8 <rtems_assoc_ptr_by_remote+0x44>
3000fdac: e59f103c ldr r1, [pc, #60] ; 3000fdf0 <rtems_assoc_ptr_by_remote+0x5c> 3000fdb0: eb00042f bl 30010e74 <strcmp> 3000fdb4: e3500000 cmp r0, #0
default_ap = ap++;
3000fdb8: 01a00004 moveq r0, r4
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;
3000fdbc: 13a00000 movne r0, #0
if (rtems_assoc_is_default(ap))
3000fdc0: 1a000004 bne 3000fdd8 <rtems_assoc_ptr_by_remote+0x44>
3000fdc4: ea000002 b 3000fdd4 <rtems_assoc_ptr_by_remote+0x40> <== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
3000fdc8: e5943008 ldr r3, [r4, #8] 3000fdcc: e1530005 cmp r3, r5
3000fdd0: 0a000004 beq 3000fde8 <rtems_assoc_ptr_by_remote+0x54>
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
3000fdd4: e284400c add r4, r4, #12 3000fdd8: e5943000 ldr r3, [r4] 3000fddc: e3530000 cmp r3, #0
3000fde0: 1afffff8 bne 3000fdc8 <rtems_assoc_ptr_by_remote+0x34>
if (ap->remote_value == remote_value)
return ap;
return default_ap;
3000fde4: e1a04000 mov r4, r0
}
3000fde8: e1a00004 mov r0, r4
3000fdec: e8bd8030 pop {r4, r5, pc}
30006ea4 <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30006ea4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
30006ea8: ebffffa2 bl 30006d38 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if (nap)
30006eac: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->remote_value;
30006eb0: 15900008 ldrne r0, [r0, #8] <== NOT EXECUTED
return 0;
}
30006eb4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006e60 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30006e60: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006e64: e1a08000 mov r8, r0 <== NOT EXECUTED
30006e68: e1a07001 mov r7, r1 <== NOT EXECUTED
30006e6c: e3a06020 mov r6, #32 <== NOT EXECUTED
uint32_t b; uint32_t remote_value = 0;
30006e70: e3a05000 mov r5, #0 <== NOT EXECUTED
for (b = 1; b; b <<= 1)
30006e74: e3a04001 mov r4, #1 <== NOT EXECUTED
if (b & local_value)
30006e78: e1140007 tst r4, r7 <== NOT EXECUTED 30006e7c: 0a000003 beq 30006e90 <rtems_assoc_remote_by_local_bitfield+0x30><== NOT EXECUTED
remote_value |= rtems_assoc_remote_by_local(ap, b);
30006e80: e1a00008 mov r0, r8 <== NOT EXECUTED 30006e84: e1a01004 mov r1, r4 <== NOT EXECUTED 30006e88: eb000005 bl 30006ea4 <rtems_assoc_remote_by_local> <== NOT EXECUTED 30006e8c: e1855000 orr r5, r5, r0 <== NOT EXECUTED
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
30006e90: e2566001 subs r6, r6, #1 <== NOT EXECUTED 30006e94: e1a04084 lsl r4, r4, #1 <== NOT EXECUTED 30006e98: 1afffff6 bne 30006e78 <rtems_assoc_remote_by_local_bitfield+0x18><== NOT EXECUTED
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
return remote_value;
}
30006e9c: e1a00005 mov r0, r5 <== NOT EXECUTED
30006ea0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30006eb8 <rtems_assoc_remote_by_name>:
uint32_t rtems_assoc_remote_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30006eb8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_name(ap, name);
30006ebc: ebffffb5 bl 30006d98 <rtems_assoc_ptr_by_name> <== NOT EXECUTED
if (nap)
30006ec0: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->remote_value;
30006ec4: 15900008 ldrne r0, [r0, #8] <== NOT EXECUTED
return 0;
}
30006ec8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300108dc <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
300108dc: e92d41f3 push {r0, r1, r4, r5, r6, r7, r8, lr}
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
300108e0: e2508000 subs r8, r0, #0
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
300108e4: e1a04001 mov r4, r1 300108e8: e1a06003 mov r6, r3
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
300108ec: 03a00003 moveq r0, #3
)
{
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
300108f0: 0a000026 beq 30010990 <rtems_barrier_create+0xb4>
return RTEMS_INVALID_NAME;
if ( !id )
300108f4: e3530000 cmp r3, #0
return RTEMS_INVALID_ADDRESS;
300108f8: 03a00009 moveq r0, #9
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
300108fc: 0a000023 beq 30010990 <rtems_barrier_create+0xb4>
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
30010900: e3110010 tst r1, #16
30010904: 0a000004 beq 3001091c <rtems_barrier_create+0x40>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
30010908: e3a03000 mov r3, #0 <== NOT EXECUTED
if ( maximum_waiters == 0 )
3001090c: e1520003 cmp r2, r3 <== NOT EXECUTED
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
30010910: e58d3000 str r3, [sp] <== NOT EXECUTED
if ( maximum_waiters == 0 )
30010914: 1a000002 bne 30010924 <rtems_barrier_create+0x48> <== NOT EXECUTED 30010918: ea00001b b 3001098c <rtems_barrier_create+0xb0> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
3001091c: e3a03001 mov r3, #1 30010920: e58d3000 str r3, [sp] 30010924: e59f3068 ldr r3, [pc, #104] ; 30010994 <rtems_barrier_create+0xb8>
the_attributes.maximum_count = maximum_waiters;
30010928: e58d2004 str r2, [sp, #4] 3001092c: e5932000 ldr r2, [r3] 30010930: e2822001 add r2, r2, #1 30010934: e5832000 str r2, [r3]
* This function allocates a barrier control block from
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void )
{
return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information );
30010938: e59f7058 ldr r7, [pc, #88] ; 30010998 <rtems_barrier_create+0xbc> 3001093c: e1a00007 mov r0, r7 30010940: ebffef09 bl 3000c56c <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
30010944: e2505000 subs r5, r0, #0
30010948: 1a000002 bne 30010958 <rtems_barrier_create+0x7c>
_Thread_Enable_dispatch();
3001094c: ebfff328 bl 3000d5f4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30010950: e3a00005 mov r0, #5 <== NOT EXECUTED 30010954: ea00000d b 30010990 <rtems_barrier_create+0xb4> <== NOT EXECUTED
}
the_barrier->attribute_set = attribute_set;
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
30010958: e2850014 add r0, r5, #20 3001095c: e1a0100d mov r1, sp
if ( !the_barrier ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
30010960: e5854010 str r4, [r5, #16]
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
30010964: eb00021d bl 300111e0 <_CORE_barrier_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30010968: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3001096c: e5953008 ldr r3, [r5, #8] 30010970: e1d510b8 ldrh r1, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30010974: e7825101 str r5, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30010978: e585800c str r8, [r5, #12]
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
3001097c: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
30010980: ebfff31b bl 3000d5f4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30010984: e3a00000 mov r0, #0 30010988: ea000000 b 30010990 <rtems_barrier_create+0xb4>
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
3001098c: e3a0000a mov r0, #10 <== NOT EXECUTED
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
30010990: e8bd81fc pop {r2, r3, r4, r5, r6, r7, r8, pc}
3000b1fc <rtems_build_id>:
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000b1fc: e1a00c00 lsl r0, r0, #24 <== NOT EXECUTED 3000b200: e1800d81 orr r0, r0, r1, lsl #27 <== NOT EXECUTED
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000b204: e1800003 orr r0, r0, r3 <== NOT EXECUTED
uint32_t node,
uint32_t index
)
{
return _Objects_Build_id( api, class, node, index );
}
3000b208: e1800802 orr r0, r0, r2, lsl #16 <== NOT EXECUTED 3000b20c: e12fff1e bx lr <== NOT EXECUTED
3000b210 <rtems_build_name>:
char C1,
char C2,
char C3,
char C4
)
{
3000b210: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000b214: e20118ff and r1, r1, #16711680 ; 0xff0000 <== NOT EXECUTED
char C1,
char C2,
char C3,
char C4
)
{
3000b218: e1a02402 lsl r2, r2, #8 <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000b21c: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED 3000b220: e2022cff and r2, r2, #65280 ; 0xff00 <== NOT EXECUTED
char C1,
char C2,
char C3,
char C4
)
{
3000b224: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000b228: e1800002 orr r0, r0, r2 <== NOT EXECUTED
}
3000b22c: e1800003 orr r0, r0, r3 <== NOT EXECUTED 3000b230: e12fff1e bx lr <== NOT EXECUTED
3000a28c <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
3000a28c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000a290: e1a04002 mov r4, r2 <== NOT EXECUTED
3000a294: e1a05003 mov r5, r3 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Append_with_empty_check( chain, node );
3000a298: eb000124 bl 3000a730 <_Chain_Append_with_empty_check> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
3000a29c: e3500000 cmp r0, #0 <== NOT EXECUTED
3000a2a0: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000a2a4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a2a8: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000a2ac: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
3000a2b0: eafffda5 b 3000994c <rtems_event_send> <== NOT EXECUTED
3000a2b4 <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
3000a2b4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000a2b8: e1a04001 mov r4, r1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node **node
)
{
return _Chain_Get_with_empty_check( chain, node );
3000a2bc: e1a01003 mov r1, r3 <== NOT EXECUTED 3000a2c0: e1a05002 mov r5, r2 <== NOT EXECUTED 3000a2c4: eb00013d bl 3000a7c0 <_Chain_Get_with_empty_check> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
3000a2c8: e3500000 cmp r0, #0 <== NOT EXECUTED
3000a2cc: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000a2d0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a2d4: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000a2d8: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
3000a2dc: eafffd9a b 3000994c <rtems_event_send> <== NOT EXECUTED
3000a2e0 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
3000a2e0: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3000a2e4: e1a07000 mov r7, r0 <== NOT EXECUTED
3000a2e8: e1a06001 mov r6, r1 <== NOT EXECUTED
3000a2ec: e1a05002 mov r5, r2 <== NOT EXECUTED
3000a2f0: e1a0a003 mov sl, r3 <== NOT EXECUTED
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
3000a2f4: e1a0800d mov r8, sp <== NOT EXECUTED 3000a2f8: ea000006 b 3000a318 <rtems_chain_get_with_wait+0x38> <== NOT EXECUTED 3000a2fc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a300: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a304: e1a02005 mov r2, r5 <== NOT EXECUTED 3000a308: e1a0300d mov r3, sp <== NOT EXECUTED 3000a30c: ebfffd32 bl 300097dc <rtems_event_receive> <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
3000a310: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a314: 1a000004 bne 3000a32c <rtems_chain_get_with_wait+0x4c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
3000a318: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a31c: eb00013b bl 3000a810 <_Chain_Get> <== NOT EXECUTED
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000a320: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000a324: 0afffff4 beq 3000a2fc <rtems_chain_get_with_wait+0x1c> <== NOT EXECUTED 3000a328: e3a00000 mov r0, #0 <== NOT EXECUTED
timeout,
&out
);
}
*node_ptr = node;
3000a32c: e58a4000 str r4, [sl] <== NOT EXECUTED
return sc;
}
3000a330: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000a334 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
3000a334: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000a338: e1a04002 mov r4, r2 <== NOT EXECUTED
3000a33c: e1a05003 mov r5, r3 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Prepend_with_empty_check( chain, node );
3000a340: eb000149 bl 3000a86c <_Chain_Prepend_with_empty_check> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
3000a344: e3500000 cmp r0, #0 <== NOT EXECUTED
3000a348: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000a34c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a350: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000a354: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
3000a358: eafffd7b b 3000994c <rtems_event_send> <== NOT EXECUTED
300153cc <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
300153cc: e92d4010 push {r4, lr} <== NOT EXECUTED
if ( !time_buffer )
300153d0: e2514000 subs r4, r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
300153d4: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
300153d8: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
300153dc: e3500000 cmp r0, #0 <== NOT EXECUTED 300153e0: 1a000002 bne 300153f0 <rtems_clock_get+0x24> <== NOT EXECUTED
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
300153e4: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
300153e8: e8bd4010 pop {r4, lr} <== NOT EXECUTED
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
300153ec: ea00002f b 300154b0 <rtems_clock_get_tod> <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
300153f0: e3500001 cmp r0, #1 <== NOT EXECUTED 300153f4: 1a000002 bne 30015404 <rtems_clock_get+0x38> <== NOT EXECUTED
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
300153f8: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
300153fc: e8bd4010 pop {r4, lr} <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
30015400: ea000010 b 30015448 <rtems_clock_get_seconds_since_epoch> <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
30015404: e3500002 cmp r0, #2 <== NOT EXECUTED 30015408: 1a000001 bne 30015414 <rtems_clock_get+0x48> <== NOT EXECUTED
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
3001540c: eb000023 bl 300154a0 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED 30015410: ea000002 b 30015420 <rtems_clock_get+0x54> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
30015414: e3500003 cmp r0, #3 <== NOT EXECUTED 30015418: 1a000003 bne 3001542c <rtems_clock_get+0x60> <== NOT EXECUTED
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
3001541c: eb000017 bl 30015480 <rtems_clock_get_ticks_per_second> <== NOT EXECUTED 30015420: e5840000 str r0, [r4] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30015424: e3a00000 mov r0, #0 <== NOT EXECUTED
30015428: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
3001542c: e3500004 cmp r0, #4 <== NOT EXECUTED 30015430: 1a000002 bne 30015440 <rtems_clock_get+0x74> <== NOT EXECUTED
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
30015434: e1a00004 mov r0, r4 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
}
30015438: e8bd4010 pop {r4, lr} <== NOT EXECUTED
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
3001543c: ea00004d b 30015578 <rtems_clock_get_tod_timeval> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
30015440: e3a0000a mov r0, #10 <== NOT EXECUTED
}
30015444: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a22c <rtems_clock_get_seconds_since_epoch>:
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000a22c: e3500000 cmp r0, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000a230: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000a234: 012fff1e bxeq lr <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
3000a238: e59f301c ldr r3, [pc, #28] ; 3000a25c <rtems_clock_get_seconds_since_epoch+0x30><== NOT EXECUTED 3000a23c: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 3000a240: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch();
3000a244: 159f3014 ldrne r3, [pc, #20] ; 3000a260 <rtems_clock_get_seconds_since_epoch+0x34><== NOT EXECUTED
{
if ( !the_interval )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
3000a248: 03a0000b moveq r0, #11 <== NOT EXECUTED
*the_interval = _TOD_Seconds_since_epoch();
3000a24c: 15933000 ldrne r3, [r3] <== NOT EXECUTED 3000a250: 15803000 strne r3, [r0] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a254: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000a258: e12fff1e bx lr <== NOT EXECUTED
30008e54 <rtems_clock_get_ticks_per_second>:
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
rtems_interval rtems_clock_get_ticks_per_second(void)
{
return TOD_MICROSECONDS_PER_SECOND /
30008e54: e59f3010 ldr r3, [pc, #16] ; 30008e6c <rtems_clock_get_ticks_per_second+0x18><== NOT EXECUTED
#include <rtems/score/thread.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
rtems_interval rtems_clock_get_ticks_per_second(void)
{
30008e58: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return TOD_MICROSECONDS_PER_SECOND /
30008e5c: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 30008e60: e59f0008 ldr r0, [pc, #8] ; 30008e70 <rtems_clock_get_ticks_per_second+0x1c><== NOT EXECUTED 30008e64: eb002ab7 bl 30013948 <__aeabi_uidiv> <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick();
}
30008e68: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30008e74 <rtems_clock_get_ticks_since_boot>:
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
rtems_interval rtems_clock_get_ticks_since_boot(void)
{
return _Watchdog_Ticks_since_boot;
30008e74: e59f3004 ldr r3, [pc, #4] ; 30008e80 <rtems_clock_get_ticks_since_boot+0xc><== NOT EXECUTED 30008e78: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
30008e7c: e12fff1e bx lr <== NOT EXECUTED
30015578 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
30015578: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
if ( !time )
3001557c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30015580: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
30015584: 0a000011 beq 300155d0 <rtems_clock_get_tod_timeval+0x58> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
30015588: e59f3044 ldr r3, [pc, #68] ; 300155d4 <rtems_clock_get_tod_timeval+0x5c><== NOT EXECUTED 3001558c: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 30015590: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
30015594: 03a0000b moveq r0, #11 <== NOT EXECUTED
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
30015598: 0a00000c beq 300155d0 <rtems_clock_get_tod_timeval+0x58> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001559c: e10f5000 mrs r5, CPSR <== NOT EXECUTED 300155a0: e3853080 orr r3, r5, #128 ; 0x80 <== NOT EXECUTED 300155a4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
_TOD_Get( &now );
300155a8: e1a0000d mov r0, sp <== NOT EXECUTED 300155ac: eb0010c6 bl 300198cc <_TOD_Get> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300155b0: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
300155b4: e59d3000 ldr r3, [sp] <== NOT EXECUTED
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
300155b8: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
time->tv_sec = now.tv_sec;
300155bc: e5843000 str r3, [r4] <== NOT EXECUTED
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
300155c0: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 300155c4: eb0060f3 bl 3002d998 <__aeabi_idiv> <== NOT EXECUTED
time->tv_sec = now.tv_sec;
time->tv_usec = useconds;
300155c8: e5840004 str r0, [r4, #4] <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
300155cc: e3a00000 mov r0, #0 <== NOT EXECUTED
}
300155d0: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED
300090b8 <rtems_clock_get_uptime>:
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
300090b8: e3500000 cmp r0, #0 <== NOT EXECUTED
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
300090bc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !uptime )
300090c0: 0a000002 beq 300090d0 <rtems_clock_get_uptime+0x18> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
300090c4: eb00053e bl 3000a5c4 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300090c8: e3a00000 mov r0, #0 <== NOT EXECUTED
300090cc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
return RTEMS_INVALID_ADDRESS;
300090d0: e3a00009 mov r0, #9 <== NOT EXECUTED
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
300090d4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30008ea0 <rtems_clock_tick>:
*
* NOTE: This routine only works for leap-years through 2099.
*/
rtems_status_code rtems_clock_tick( void )
{
30008ea0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
_TOD_Tickle_ticks();
30008ea4: eb0004e7 bl 3000a248 <_TOD_Tickle_ticks>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{
_Watchdog_Tickle( &_Watchdog_Ticks_chain );
30008ea8: e59f002c ldr r0, [pc, #44] ; 30008edc <rtems_clock_tick+0x3c> 30008eac: eb000e19 bl 3000c718 <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
30008eb0: eb000caf bl 3000c174 <_Thread_Tickle_timeslice>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
30008eb4: e59f3024 ldr r3, [pc, #36] ; 30008ee0 <rtems_clock_tick+0x40> 30008eb8: e5d33010 ldrb r3, [r3, #16]
if ( _Thread_Is_context_switch_necessary() &&
30008ebc: e3530000 cmp r3, #0
30008ec0: 0a000003 beq 30008ed4 <rtems_clock_tick+0x34>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
30008ec4: e59f3018 ldr r3, [pc, #24] ; 30008ee4 <rtems_clock_tick+0x44><== NOT EXECUTED 30008ec8: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008ecc: e3530000 cmp r3, #0 <== NOT EXECUTED
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
30008ed0: 0b0009fb bleq 3000b6c4 <_Thread_Dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
30008ed4: e3a00000 mov r0, #0
30008ed8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30006ac0 <rtems_cpu_usage_report>:
void rtems_cpu_usage_report( void )
{
rtems_cpu_usage_report_with_plugin( NULL, printk_plugin );
30006ac0: e59f1004 ldr r1, [pc, #4] ; 30006acc <rtems_cpu_usage_report+0xc><== NOT EXECUTED 30006ac4: e3a00000 mov r0, #0 <== NOT EXECUTED 30006ac8: eaffff88 b 300068f0 <rtems_cpu_usage_report_with_plugin> <== NOT EXECUTED
300068f0 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
300068f0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
300068f4: e251a000 subs sl, r1, #0 <== NOT EXECUTED
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
300068f8: e24dd050 sub sp, sp, #80 ; 0x50 <== NOT EXECUTED 300068fc: e1a09000 mov r9, r0 <== NOT EXECUTED
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
30006900: 0a000063 beq 30006a94 <rtems_cpu_usage_report_with_plugin+0x1a4><== NOT EXECUTED
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
30006904: e3a03000 mov r3, #0 <== NOT EXECUTED 30006908: e58d3038 str r3, [sp, #56] ; 0x38 <== NOT EXECUTED 3000690c: e58d303c str r3, [sp, #60] ; 0x3c <== NOT EXECUTED
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
30006910: e59f3184 ldr r3, [pc, #388] ; 30006a9c <rtems_cpu_usage_report_with_plugin+0x1ac><== NOT EXECUTED
}
}
}
#endif
(*print)(
30006914: e59f1184 ldr r1, [pc, #388] ; 30006aa0 <rtems_cpu_usage_report_with_plugin+0x1b0><== NOT EXECUTED
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
30006918: e8930018 ldm r3, {r3, r4} <== NOT EXECUTED
3000691c: e58d3028 str r3, [sp, #40] ; 0x28 <== NOT EXECUTED
30006920: e58d402c str r4, [sp, #44] ; 0x2c <== NOT EXECUTED
}
}
}
#endif
(*print)(
30006924: e1a0e00f mov lr, pc <== NOT EXECUTED 30006928: e12fff1a bx sl <== NOT EXECUTED 3000692c: e59f5170 ldr r5, [pc, #368] ; 30006aa4 <rtems_cpu_usage_report_with_plugin+0x1b4><== NOT EXECUTED 30006930: e28d8040 add r8, sp, #64 ; 0x40 <== NOT EXECUTED
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
30006934: e5b53004 ldr r3, [r5, #4]! <== NOT EXECUTED 30006938: e3530000 cmp r3, #0 <== NOT EXECUTED 3000693c: 0a000048 beq 30006a64 <rtems_cpu_usage_report_with_plugin+0x174><== NOT EXECUTED
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
30006940: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED
if ( information ) {
30006944: e3560000 cmp r6, #0 <== NOT EXECUTED 30006948: 13a07001 movne r7, #1 <== NOT EXECUTED
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
_Timestamp_Divide( &ran, &total, &ival, &fval );
3000694c: 128db030 addne fp, sp, #48 ; 0x30 <== NOT EXECUTED
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
30006950: 1a000040 bne 30006a58 <rtems_cpu_usage_report_with_plugin+0x168><== NOT EXECUTED 30006954: ea000042 b 30006a64 <rtems_cpu_usage_report_with_plugin+0x174><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
30006958: e596301c ldr r3, [r6, #28] <== NOT EXECUTED 3000695c: e7934107 ldr r4, [r3, r7, lsl #2] <== NOT EXECUTED
if ( !the_thread )
30006960: e3540000 cmp r4, #0 <== NOT EXECUTED 30006964: 0a00003a beq 30006a54 <rtems_cpu_usage_report_with_plugin+0x164><== NOT EXECUTED
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
30006968: e3a0100d mov r1, #13 <== NOT EXECUTED 3000696c: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30006970: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED 30006974: eb000fde bl 3000a8f4 <rtems_object_get_name> <== NOT EXECUTED
(*print)(
30006978: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3000697c: e28d3008 add r3, sp, #8 <== NOT EXECUTED 30006980: e1a00009 mov r0, r9 <== NOT EXECUTED 30006984: e59f111c ldr r1, [pc, #284] ; 30006aa8 <rtems_cpu_usage_report_with_plugin+0x1b8><== NOT EXECUTED 30006988: e1a0e00f mov lr, pc <== NOT EXECUTED 3000698c: e12fff1a bx sl <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
30006990: e2843084 add r3, r4, #132 ; 0x84 <== NOT EXECUTED
30006994: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30006998: e58d2030 str r2, [sp, #48] ; 0x30 <== NOT EXECUTED
3000699c: e58d3034 str r3, [sp, #52] ; 0x34 <== NOT EXECUTED
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
300069a0: e59f2104 ldr r2, [pc, #260] ; 30006aac <rtems_cpu_usage_report_with_plugin+0x1bc><== NOT EXECUTED 300069a4: e5923004 ldr r3, [r2, #4] <== NOT EXECUTED 300069a8: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 300069ac: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 300069b0: e1520003 cmp r2, r3 <== NOT EXECUTED 300069b4: 1a00000e bne 300069f4 <rtems_cpu_usage_report_with_plugin+0x104><== NOT EXECUTED
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
300069b8: e59f20f0 ldr r2, [pc, #240] ; 30006ab0 <rtems_cpu_usage_report_with_plugin+0x1c0><== NOT EXECUTED
_TOD_Get_uptime( &uptime );
300069bc: e1a00008 mov r0, r8 <== NOT EXECUTED
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
300069c0: e8920018 ldm r2, {r3, r4} <== NOT EXECUTED
300069c4: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
300069c8: e58d401c str r4, [sp, #28] <== NOT EXECUTED
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
300069cc: e28d4020 add r4, sp, #32 <== NOT EXECUTED
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
_TOD_Get_uptime( &uptime );
300069d0: eb001454 bl 3000bb28 <_TOD_Get_uptime> <== NOT EXECUTED
_Timestamp_Subtract( &last, &uptime, &used );
300069d4: e28d0018 add r0, sp, #24 <== NOT EXECUTED 300069d8: e1a01008 mov r1, r8 <== NOT EXECUTED 300069dc: e1a02004 mov r2, r4 <== NOT EXECUTED 300069e0: eb001ce6 bl 3000dd80 <_Timespec_Subtract> <== NOT EXECUTED
_Timestamp_Add_to( &ran, &used );
300069e4: e1a0000b mov r0, fp <== NOT EXECUTED 300069e8: e1a01004 mov r1, r4 <== NOT EXECUTED 300069ec: eb001ca8 bl 3000dc94 <_Timespec_Add_to> <== NOT EXECUTED 300069f0: ea000001 b 300069fc <rtems_cpu_usage_report_with_plugin+0x10c><== NOT EXECUTED
} else {
_TOD_Get_uptime( &uptime );
300069f4: e1a00008 mov r0, r8 <== NOT EXECUTED 300069f8: eb00144a bl 3000bb28 <_TOD_Get_uptime> <== NOT EXECUTED
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
300069fc: e28d0028 add r0, sp, #40 ; 0x28 <== NOT EXECUTED 30006a00: e1a01008 mov r1, r8 <== NOT EXECUTED 30006a04: e28d2038 add r2, sp, #56 ; 0x38 <== NOT EXECUTED 30006a08: eb001cdc bl 3000dd80 <_Timespec_Subtract> <== NOT EXECUTED
_Timestamp_Divide( &ran, &total, &ival, &fval );
30006a0c: e28d204c add r2, sp, #76 ; 0x4c <== NOT EXECUTED 30006a10: e28d3048 add r3, sp, #72 ; 0x48 <== NOT EXECUTED 30006a14: e1a0000b mov r0, fp <== NOT EXECUTED 30006a18: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 30006a1c: eb001cb4 bl 3000dcf4 <_Timespec_Divide> <== NOT EXECUTED
/*
* Print the information
*/
(*print)( context,
30006a20: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30006a24: e59d0034 ldr r0, [sp, #52] ; 0x34 <== NOT EXECUTED 30006a28: eb0052b9 bl 3001b514 <__aeabi_uidiv> <== NOT EXECUTED 30006a2c: e59d204c ldr r2, [sp, #76] ; 0x4c <== NOT EXECUTED 30006a30: e1a03000 mov r3, r0 <== NOT EXECUTED 30006a34: e58d2000 str r2, [sp] <== NOT EXECUTED 30006a38: e59d2048 ldr r2, [sp, #72] ; 0x48 <== NOT EXECUTED 30006a3c: e1a00009 mov r0, r9 <== NOT EXECUTED 30006a40: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 30006a44: e59f1068 ldr r1, [pc, #104] ; 30006ab4 <rtems_cpu_usage_report_with_plugin+0x1c4><== NOT EXECUTED 30006a48: e59d2030 ldr r2, [sp, #48] ; 0x30 <== NOT EXECUTED 30006a4c: e1a0e00f mov lr, pc <== NOT EXECUTED 30006a50: e12fff1a bx sl <== NOT EXECUTED
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
30006a54: e2877001 add r7, r7, #1 <== NOT EXECUTED 30006a58: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED 30006a5c: e1570003 cmp r7, r3 <== NOT EXECUTED 30006a60: 9affffbc bls 30006958 <rtems_cpu_usage_report_with_plugin+0x68><== NOT EXECUTED
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
30006a64: e59f304c ldr r3, [pc, #76] ; 30006ab8 <rtems_cpu_usage_report_with_plugin+0x1c8><== NOT EXECUTED 30006a68: e1550003 cmp r5, r3 <== NOT EXECUTED 30006a6c: 1affffb0 bne 30006934 <rtems_cpu_usage_report_with_plugin+0x44><== NOT EXECUTED
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
30006a70: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30006a74: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED 30006a78: eb0052a5 bl 3001b514 <__aeabi_uidiv> <== NOT EXECUTED 30006a7c: e59f1038 ldr r1, [pc, #56] ; 30006abc <rtems_cpu_usage_report_with_plugin+0x1cc><== NOT EXECUTED 30006a80: e1a03000 mov r3, r0 <== NOT EXECUTED 30006a84: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 30006a88: e1a00009 mov r0, r9 <== NOT EXECUTED 30006a8c: e1a0e00f mov lr, pc <== NOT EXECUTED 30006a90: e12fff1a bx sl <== NOT EXECUTED
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
30006a94: e28dd050 add sp, sp, #80 ; 0x50 <== NOT EXECUTED
30006a98: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30006ae0 <rtems_cpu_usage_reset>:
/*
* rtems_cpu_usage_reset
*/
void rtems_cpu_usage_reset( void )
{
30006ae0: e92d4010 push {r4, lr} <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &CPU_usage_Uptime_at_last_reset );
30006ae4: e59f401c ldr r4, [pc, #28] ; 30006b08 <rtems_cpu_usage_reset+0x28><== NOT EXECUTED 30006ae8: e1a00004 mov r0, r4 <== NOT EXECUTED 30006aec: eb00140d bl 3000bb28 <_TOD_Get_uptime> <== NOT EXECUTED
_Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
30006af0: e8940006 ldm r4, {r1, r2} <== NOT EXECUTED
30006af4: e59f3010 ldr r3, [pc, #16] ; 30006b0c <rtems_cpu_usage_reset+0x2c><== NOT EXECUTED
#else
CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot;
#endif
rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler);
30006af8: e59f0010 ldr r0, [pc, #16] ; 30006b10 <rtems_cpu_usage_reset+0x30><== NOT EXECUTED
*/
void rtems_cpu_usage_reset( void )
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &CPU_usage_Uptime_at_last_reset );
_Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
30006afc: e8830006 stm r3, {r1, r2} <== NOT EXECUTED
#else
CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot;
#endif
rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler);
}
30006b00: e8bd4010 pop {r4, lr} <== NOT EXECUTED
_Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
#else
CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot;
#endif
rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler);
30006b04: ea001579 b 3000c0f0 <rtems_iterate_over_all_threads> <== NOT EXECUTED
300101f8 <rtems_deviceio_errno>:
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
300101f8: e3500000 cmp r0, #0
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
300101fc: e92d4010 push {r4, lr}
if (sc == RTEMS_SUCCESSFUL) {
30010200: 08bd8010 popeq {r4, pc}
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
30010204: e350001c cmp r0, #28 <== NOT EXECUTED
eno = status_code_to_errno [sc];
30010208: 959f3014 ldrls r3, [pc, #20] ; 30010224 <rtems_deviceio_errno+0x2c><== NOT EXECUTED
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
3001020c: 83a04016 movhi r4, #22 <== NOT EXECUTED
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
30010210: 97934100 ldrls r4, [r3, r0, lsl #2] <== NOT EXECUTED
}
errno = eno;
30010214: eb000008 bl 3001023c <__errno> <== NOT EXECUTED 30010218: e5804000 str r4, [r0] <== NOT EXECUTED
return -1;
3001021c: e3e00000 mvn r0, #0 <== NOT EXECUTED
} }
30010220: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a940 <rtems_error>:
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
3000a940: e92d000e push {r1, r2, r3} <== NOT EXECUTED
3000a944: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
chars_written = rtems_verror(error_flag, printf_format, arglist);
3000a948: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
3000a94c: e1a04000 mov r4, r0 <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
3000a950: e28d2010 add r2, sp, #16 <== NOT EXECUTED 3000a954: e58d2000 str r2, [sp] <== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
3000a958: ebffff9e bl 3000a7d8 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
if (error_flag & RTEMS_ERROR_PANIC) {
3000a95c: e2143202 ands r3, r4, #536870912 ; 0x20000000 <== NOT EXECUTED 3000a960: 0a000005 beq 3000a97c <rtems_error+0x3c> <== NOT EXECUTED
rtems_error(0, "fatal error, exiting");
3000a964: e59f1034 ldr r1, [pc, #52] ; 3000a9a0 <rtems_error+0x60> <== NOT EXECUTED 3000a968: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a96c: ebfffff3 bl 3000a940 <rtems_error> <== NOT EXECUTED
_exit(errno);
3000a970: eb002a7f bl 30015374 <__errno> <== NOT EXECUTED 3000a974: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000a978: eb00029c bl 3000b3f0 <_exit> <== NOT EXECUTED
}
if (error_flag & RTEMS_ERROR_ABORT) {
3000a97c: e3140201 tst r4, #268435456 ; 0x10000000 <== NOT EXECUTED 3000a980: 0a000003 beq 3000a994 <rtems_error+0x54> <== NOT EXECUTED
rtems_error(0, "fatal error, aborting");
3000a984: e1a00003 mov r0, r3 <== NOT EXECUTED 3000a988: e59f1014 ldr r1, [pc, #20] ; 3000a9a4 <rtems_error+0x64> <== NOT EXECUTED 3000a98c: ebffffeb bl 3000a940 <rtems_error> <== NOT EXECUTED
abort();
3000a990: eb002a6d bl 3001534c <abort> <== NOT EXECUTED
}
return chars_written;
}
3000a994: e8bd4018 pop {r3, r4, lr} <== NOT EXECUTED
3000a998: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000a99c: e12fff1e bx lr <== NOT EXECUTED
30008ee8 <rtems_event_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
30008ee8: e92d4070 push {r4, r5, r6, lr}
RTEMS_API_Control *api;
if ( !event_out )
30008eec: e2535000 subs r5, r3, #0
30008ef0: 0a000010 beq 30008f38 <rtems_event_receive+0x50>
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
30008ef4: e59f4044 ldr r4, [pc, #68] ; 30008f40 <rtems_event_receive+0x58>
if ( _Event_sets_Is_empty( event_in ) ) {
30008ef8: e3500000 cmp r0, #0
RTEMS_API_Control *api;
if ( !event_out )
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
30008efc: e5946004 ldr r6, [r4, #4]
if ( _Event_sets_Is_empty( event_in ) ) {
*event_out = api->pending_events;
return RTEMS_SUCCESSFUL;
30008f00: 01a00000 moveq r0, r0
RTEMS_API_Control *api;
if ( !event_out )
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
30008f04: e59660f4 ldr r6, [r6, #244] ; 0xf4
if ( _Event_sets_Is_empty( event_in ) ) {
*event_out = api->pending_events;
30008f08: 05963000 ldreq r3, [r6] 30008f0c: 05853000 streq r3, [r5]
if ( !event_out )
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
if ( _Event_sets_Is_empty( event_in ) ) {
30008f10: 08bd8070 popeq {r4, r5, r6, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30008f14: e59fc028 ldr ip, [pc, #40] ; 30008f44 <rtems_event_receive+0x5c> 30008f18: e59ce000 ldr lr, [ip] 30008f1c: e28ee001 add lr, lr, #1 30008f20: e58ce000 str lr, [ip]
*event_out = api->pending_events;
return RTEMS_SUCCESSFUL;
}
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
30008f24: eb000007 bl 30008f48 <_Event_Seize>
_Thread_Enable_dispatch();
30008f28: eb000a29 bl 3000b7d4 <_Thread_Enable_dispatch>
return( _Thread_Executing->Wait.return_code );
30008f2c: e5943004 ldr r3, [r4, #4]
30008f30: e5930034 ldr r0, [r3, #52] ; 0x34
30008f34: e8bd8070 pop {r4, r5, r6, pc}
)
{
RTEMS_API_Control *api;
if ( !event_out )
return RTEMS_INVALID_ADDRESS;
30008f38: e3a00009 mov r0, #9 <== NOT EXECUTED
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
_Thread_Enable_dispatch();
return( _Thread_Executing->Wait.return_code );
}
30008f3c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000b340 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000b340: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Extension_Control *the_extension;
if ( !id )
3000b344: e2527000 subs r7, r2, #0
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000b348: e1a05000 mov r5, r0 3000b34c: e1a08001 mov r8, r1
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000b350: 03a00009 moveq r0, #9
rtems_id *id
)
{
Extension_Control *the_extension;
if ( !id )
3000b354: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
3000b358: e3550000 cmp r5, #0
3000b35c: 0a00001c beq 3000b3d4 <rtems_extension_create+0x94>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b360: e59f3074 ldr r3, [pc, #116] ; 3000b3dc <rtems_extension_create+0x9c> 3000b364: e5932000 ldr r2, [r3] 3000b368: e2822001 add r2, r2, #1 3000b36c: e5832000 str r2, [r3]
#ifndef __EXTENSION_MANAGER_inl
#define __EXTENSION_MANAGER_inl
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
3000b370: e59f6068 ldr r6, [pc, #104] ; 3000b3e0 <rtems_extension_create+0xa0> 3000b374: e1a00006 mov r0, r6 3000b378: eb000376 bl 3000c158 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
3000b37c: e2504000 subs r4, r0, #0
3000b380: 1a000002 bne 3000b390 <rtems_extension_create+0x50>
_Thread_Enable_dispatch();
3000b384: eb0007bf bl 3000d288 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000b388: e3a00005 mov r0, #5 <== NOT EXECUTED
3000b38c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
3000b390: e284c024 add ip, r4, #36 ; 0x24
3000b394: e1a0e008 mov lr, r8
3000b398: e8be000f ldm lr!, {r0, r1, r2, r3}
3000b39c: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000b3a0: e89e000f ldm lr, {r0, r1, r2, r3}
3000b3a4: e88c000f stm ip, {r0, r1, r2, r3}
_User_extensions_Add_set( extension );
3000b3a8: e2840010 add r0, r4, #16 3000b3ac: eb000a85 bl 3000ddc8 <_User_extensions_Add_set>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b3b0: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000b3b4: e5943008 ldr r3, [r4, #8] 3000b3b8: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b3bc: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000b3c0: e584500c str r5, [r4, #12]
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
3000b3c4: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
3000b3c8: eb0007ae bl 3000d288 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b3cc: e3a00000 mov r0, #0
3000b3d0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000b3d4: e3a00003 mov r0, #3 <== NOT EXECUTED
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000b3d8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000bd9c <rtems_extension_ident>:
rtems_status_code rtems_extension_ident(
rtems_name name,
rtems_id *id
)
{
3000bd9c: e1a02000 mov r2, r0 <== NOT EXECUTED
3000bda0: e1a03001 mov r3, r1 <== NOT EXECUTED
3000bda4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
status = _Objects_Name_to_id_u32(
3000bda8: e1a01002 mov r1, r2 <== NOT EXECUTED 3000bdac: e59f0010 ldr r0, [pc, #16] ; 3000bdc4 <rtems_extension_ident+0x28><== NOT EXECUTED 3000bdb0: e3e02102 mvn r2, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000bdb4: eb00047a bl 3000cfa4 <_Objects_Name_to_id_u32> <== NOT EXECUTED
OBJECTS_SEARCH_LOCAL_NODE,
id
);
return _Status_Object_name_errors_to_status[ status ];
}
3000bdb8: e59f3008 ldr r3, [pc, #8] ; 3000bdc8 <rtems_extension_ident+0x2c><== NOT EXECUTED
3000bdbc: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
3000bdc0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006004 <rtems_filesystem_initialize>:
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
30006004: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
30006008: e59f60e0 ldr r6, [pc, #224] ; 300060f0 <rtems_filesystem_initialize+0xec> 3000600c: e3a02012 mov r2, #18 30006010: e5963000 ldr r3, [r6]
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
30006014: e24dd018 sub sp, sp, #24
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
30006018: e583202c str r2, [r3, #44] ; 0x2c
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
3000601c: e59f30d0 ldr r3, [pc, #208] ; 300060f4 <rtems_filesystem_initialize+0xf0> 30006020: e5933000 ldr r3, [r3] 30006024: e3530000 cmp r3, #0
rtems_fatal_error_occurred( 0xABCD0001 );
30006028: 059f00c8 ldreq r0, [pc, #200] ; 300060f8 <rtems_filesystem_initialize+0xf4>
rtems_filesystem_umask = 022;
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
3000602c: 0a00000a beq 3000605c <rtems_filesystem_initialize+0x58>
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
30006030: e59f30c4 ldr r3, [pc, #196] ; 300060fc <rtems_filesystem_initialize+0xf8>
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
30006034: e3a05000 mov r5, #0
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
30006038: e5933000 ldr r3, [r3]
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
3000603c: e58d5000 str r5, [sp]
30006040: e5930008 ldr r0, [r3, #8]
30006044: e593100c ldr r1, [r3, #12]
30006048: e893000c ldm r3, {r2, r3}
3000604c: eb0001fc bl 30006844 <mount>
if ( status == -1 )
30006050: e3700001 cmn r0, #1
30006054: 1a000001 bne 30006060 <rtems_filesystem_initialize+0x5c>
rtems_fatal_error_occurred( 0xABCD0002 );
30006058: e59f00a0 ldr r0, [pc, #160] ; 30006100 <rtems_filesystem_initialize+0xfc><== NOT EXECUTED 3000605c: eb000ea9 bl 30009b08 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_filesystem_link_counts = 0;
30006060: e5963000 ldr r3, [r6]
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30006064: e28d4004 add r4, sp, #4
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
30006068: e1c353b0 strh r5, [r3, #48] ; 0x30
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
3000606c: e3a01001 mov r1, #1 30006070: e1a03004 mov r3, r4 30006074: e1a02005 mov r2, r5 30006078: e59f0084 ldr r0, [pc, #132] ; 30006104 <rtems_filesystem_initialize+0x100> 3000607c: e58d5000 str r5, [sp] 30006080: eb000052 bl 300061d0 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
30006084: e596c000 ldr ip, [r6]
30006088: e1a07004 mov r7, r4
3000608c: e28cc018 add ip, ip, #24
30006090: e8b7000f ldm r7!, {r0, r1, r2, r3}
30006094: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006098: e5973000 ldr r3, [r7]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
3000609c: e3a01001 mov r1, #1
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
300060a0: e58c3000 str r3, [ip]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
300060a4: e1a02005 mov r2, r5 300060a8: e1a03004 mov r3, r4 300060ac: e59f0050 ldr r0, [pc, #80] ; 30006104 <rtems_filesystem_initialize+0x100> 300060b0: e58d5000 str r5, [sp] 300060b4: eb000045 bl 300061d0 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
300060b8: e8b4000f ldm r4!, {r0, r1, r2, r3}
300060bc: e596c000 ldr ip, [r6]
300060c0: e28cc004 add ip, ip, #4
300060c4: e8ac000f stmia ip!, {r0, r1, r2, r3}
300060c8: e5973000 ldr r3, [r7]
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
300060cc: e59f0034 ldr r0, [pc, #52] ; 30006108 <rtems_filesystem_initialize+0x104>
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_current = loc;
300060d0: e58c3000 str r3, [ip]
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
300060d4: e59f1030 ldr r1, [pc, #48] ; 3000610c <rtems_filesystem_initialize+0x108> 300060d8: eb00017c bl 300066d0 <mkdir>
if ( status != 0 )
300060dc: e3500000 cmp r0, #0
rtems_fatal_error_occurred( 0xABCD0003 );
300060e0: 159f0028 ldrne r0, [pc, #40] ; 30006110 <rtems_filesystem_initialize+0x10c>
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
300060e4: 1affffdc bne 3000605c <rtems_filesystem_initialize+0x58>
* 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.
*/
}
300060e8: e28dd018 add sp, sp, #24
300060ec: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000bd6c <rtems_get_version_string>:
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
}
3000bd6c: e59f0000 ldr r0, [pc, #0] ; 3000bd74 <rtems_get_version_string+0x8><== NOT EXECUTED 3000bd70: e12fff1e bx lr <== NOT EXECUTED
30006e0c <rtems_gxx_getspecific>:
void *rtems_gxx_getspecific(__gthread_key_t key)
{
30006e0c: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
30006e10: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code status; void *p= 0;
30006e14: e3a05000 mov r5, #0 <== NOT EXECUTED 30006e18: e28d2004 add r2, sp, #4 <== NOT EXECUTED 30006e1c: e5225004 str r5, [r2, #-4]! <== NOT EXECUTED
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_get( RTEMS_SELF, (void **)key, &p );
30006e20: e1a00005 mov r0, r5 <== NOT EXECUTED 30006e24: e1a01004 mov r1, r4 <== NOT EXECUTED 30006e28: e1a0200d mov r2, sp <== NOT EXECUTED 30006e2c: eb000e3b bl 3000a720 <rtems_task_variable_get> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
30006e30: e1500005 cmp r0, r5 <== NOT EXECUTED
/* We do not have to do this, but what the heck ! */
p= key->val;
30006e34: 05943000 ldreq r3, [r4] <== NOT EXECUTED 30006e38: 058d3000 streq r3, [sp] <== NOT EXECUTED
rtems_status_code status;
void *p= 0;
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_get( RTEMS_SELF, (void **)key, &p );
if ( status == RTEMS_SUCCESSFUL ) {
30006e3c: 0a000009 beq 30006e68 <rtems_gxx_getspecific+0x5c> <== NOT EXECUTED
p= key->val;
} else {
/* fisrt time, always set to zero, it is unknown the value that the others
* threads are using at the moment of this call
*/
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
30006e40: e1a00005 mov r0, r5 <== NOT EXECUTED 30006e44: e1a01004 mov r1, r4 <== NOT EXECUTED 30006e48: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 30006e4c: eb000deb bl 3000a600 <rtems_task_variable_add> <== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL ) {
30006e50: e3500000 cmp r0, #0 <== NOT EXECUTED
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_GXX_KEY_ADD_FAILED
);
}
key->val = (void *)0;
30006e54: 05840000 streq r0, [r4] <== NOT EXECUTED
/* fisrt time, always set to zero, it is unknown the value that the others
* threads are using at the moment of this call
*/
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
if ( status != RTEMS_SUCCESSFUL ) {
_Internal_error_Occurred(
30006e58: 11a00005 movne r0, r5 <== NOT EXECUTED 30006e5c: 13a01001 movne r1, #1 <== NOT EXECUTED 30006e60: 13a02015 movne r2, #21 <== NOT EXECUTED 30006e64: 1b0011af blne 3000b528 <_Internal_error_Occurred> <== NOT EXECUTED
p,
rtems_task_self()
);
#endif
return p;
}
30006e68: e59d0000 ldr r0, [sp] <== NOT EXECUTED
30006e6c: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30006d84 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
30006d84: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30006d88: e1a06000 mov r6, r0 <== NOT EXECUTED
* 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 ) );
30006d8c: e3a00008 mov r0, #8 <== NOT EXECUTED
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
30006d90: e1a05001 mov r5, r1 <== NOT EXECUTED
* 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 ) );
30006d94: eb0000fa bl 30007184 <malloc> <== NOT EXECUTED 30006d98: e1a04000 mov r4, r0 <== NOT EXECUTED
*key = new_key;
30006d9c: e5860000 str r0, [r6] <== NOT EXECUTED
"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 );
30006da0: e1a01004 mov r1, r4 <== NOT EXECUTED
* deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) ); *key = new_key; new_key->val = NULL;
30006da4: e3a00000 mov r0, #0 <== NOT EXECUTED
"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 );
30006da8: e1a02005 mov r2, r5 <== NOT EXECUTED
* deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) ); *key = new_key; new_key->val = NULL;
30006dac: e8840021 stm r4, {r0, r5} <== NOT EXECUTED
"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 );
30006db0: eb000e12 bl 3000a600 <rtems_task_variable_add> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
30006db4: e3500000 cmp r0, #0 <== NOT EXECUTED
30006db8: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return 0;
free( new_key );
30006dbc: e1a00004 mov r0, r4 <== NOT EXECUTED 30006dc0: ebffff95 bl 30006c1c <free> <== NOT EXECUTED
return -1;
30006dc4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
30006dc8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30006ddc <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
30006ddc: e92d4010 push {r4, lr} <== NOT EXECUTED
30006de0: e1a04000 mov r4, r0 <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: delete key=%x\n", key );
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );
30006de4: e1a01004 mov r1, r4 <== NOT EXECUTED 30006de8: e3a00000 mov r0, #0 <== NOT EXECUTED 30006dec: eb000e2d bl 3000a6a8 <rtems_task_variable_delete> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
30006df0: e3500000 cmp r0, #0 <== NOT EXECUTED 30006df4: 1a000002 bne 30006e04 <rtems_gxx_key_delete+0x28> <== NOT EXECUTED
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
30006df8: e3540000 cmp r4, #0 <== NOT EXECUTED 30006dfc: 15940000 ldrne r0, [r4] <== NOT EXECUTED 30006e00: 1bffff85 blne 30006c1c <free> <== NOT EXECUTED
return 0;
}
key = NULL;
return 0;
}
30006e04: e3a00000 mov r0, #0 <== NOT EXECUTED
30006e08: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30006dcc <rtems_gxx_key_dtor>:
{
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: dtor key=%x, ptr=%x\n", key, ptr );
#endif
key->val = 0;
30006dcc: e3a03000 mov r3, #0 <== NOT EXECUTED 30006dd0: e5803000 str r3, [r0] <== NOT EXECUTED
return 0; }
30006dd4: e1a00003 mov r0, r3 <== NOT EXECUTED 30006dd8: e12fff1e bx lr <== NOT EXECUTED
30006ef4 <rtems_gxx_mutex_destroy>:
int rtems_gxx_mutex_destroy (__gthread_mutex_t *mutex)
{
30006ef4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: destroy mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_delete(*(rtems_id *)mutex);
30006ef8: e5900000 ldr r0, [r0] <== NOT EXECUTED 30006efc: eb000c29 bl 30009fa8 <rtems_semaphore_delete> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
30006f00: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
30006f04: 13e00000 mvnne r0, #0 <== NOT EXECUTED
30006f08: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006e9c <rtems_gxx_mutex_init>:
/*
* MUTEX support
*/
void rtems_gxx_mutex_init (__gthread_mutex_t *mutex)
{
30006e9c: e92d4001 push {r0, lr} <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: mutex init =%X\n", *mutex );
#endif
status = rtems_semaphore_create(
30006ea0: e3a01001 mov r1, #1 <== NOT EXECUTED 30006ea4: e58d0000 str r0, [sp] <== NOT EXECUTED 30006ea8: e3a02054 mov r2, #84 ; 0x54 <== NOT EXECUTED 30006eac: e59f001c ldr r0, [pc, #28] ; 30006ed0 <rtems_gxx_mutex_init+0x34><== NOT EXECUTED 30006eb0: e3a03000 mov r3, #0 <== NOT EXECUTED 30006eb4: eb000bd0 bl 30009dfc <rtems_semaphore_create> <== NOT EXECUTED
RTEMS_PRIORITY|RTEMS_BINARY_SEMAPHORE|
RTEMS_INHERIT_PRIORITY|RTEMS_NO_PRIORITY_CEILING|RTEMS_LOCAL,
0,
(rtems_id *)mutex
);
if ( status != RTEMS_SUCCESSFUL ) {
30006eb8: e3500000 cmp r0, #0 <== NOT EXECUTED
"gxx_wrappers: mutex init failed %s (%d)\n",
rtems_status_text(status),
status
);
#endif
_Internal_error_Occurred(
30006ebc: 13a00000 movne r0, #0 <== NOT EXECUTED 30006ec0: 13a01001 movne r1, #1 <== NOT EXECUTED 30006ec4: 13a02016 movne r2, #22 <== NOT EXECUTED 30006ec8: 1b001196 blne 3000b528 <_Internal_error_Occurred> <== NOT EXECUTED
);
}
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );
#endif
}
30006ecc: e8bd8008 pop {r3, pc} <== NOT EXECUTED
30006ed4 <rtems_gxx_mutex_lock>:
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: lock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain(
30006ed4: e3a01000 mov r1, #0 <== NOT EXECUTED
printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );
#endif
}
int rtems_gxx_mutex_lock (__gthread_mutex_t *mutex)
{
30006ed8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: lock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain(
30006edc: e1a02001 mov r2, r1 <== NOT EXECUTED 30006ee0: e5900000 ldr r0, [r0] <== NOT EXECUTED 30006ee4: eb000c56 bl 3000a044 <rtems_semaphore_obtain> <== NOT EXECUTED
*(rtems_id *)mutex,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( status == RTEMS_SUCCESSFUL )
30006ee8: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
30006eec: 13e00000 mvnne r0, #0 <== NOT EXECUTED
30006ef0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006f0c <rtems_gxx_mutex_trylock>:
int rtems_gxx_mutex_trylock (__gthread_mutex_t *mutex)
{
30006f0c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: trylock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain (*(rtems_id *)mutex, RTEMS_NO_WAIT, 0);
30006f10: e3a01001 mov r1, #1 <== NOT EXECUTED 30006f14: e3a02000 mov r2, #0 <== NOT EXECUTED 30006f18: e5900000 ldr r0, [r0] <== NOT EXECUTED 30006f1c: eb000c48 bl 3000a044 <rtems_semaphore_obtain> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
30006f20: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
30006f24: 13e00000 mvnne r0, #0 <== NOT EXECUTED
30006f28: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006f2c <rtems_gxx_mutex_unlock>:
int rtems_gxx_mutex_unlock (__gthread_mutex_t *mutex)
{
30006f2c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: unlock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_release( *(rtems_id *)mutex );
30006f30: e5900000 ldr r0, [r0] <== NOT EXECUTED 30006f34: eb000c88 bl 3000a15c <rtems_semaphore_release> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
30006f38: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
30006f3c: 13e00000 mvnne r0, #0 <== NOT EXECUTED
30006f40: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006d28 <rtems_gxx_once>:
{
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
30006d28: e5903000 ldr r3, [r0] <== NOT EXECUTED
/* 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))
{
30006d2c: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
30006d30: e3530000 cmp r3, #0 <== NOT EXECUTED
/* 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))
{
30006d34: e1a04000 mov r4, r0 <== NOT EXECUTED 30006d38: e1a06001 mov r6, r1 <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
30006d3c: 1a00000e bne 30006d7c <rtems_gxx_once+0x54> <== NOT EXECUTED
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
30006d40: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED 30006d44: e1a01000 mov r1, r0 <== NOT EXECUTED 30006d48: e1a0200d mov r2, sp <== NOT EXECUTED 30006d4c: eb000db9 bl 3000a438 <rtems_task_mode> <== NOT EXECUTED
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
30006d50: e5945000 ldr r5, [r4] <== NOT EXECUTED
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
30006d54: e59d0000 ldr r0, [sp] <== NOT EXECUTED
if ( *(volatile __gthread_once_t *)once == 0 ) {
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 ) {
30006d58: e3550000 cmp r5, #0 <== NOT EXECUTED
*(volatile __gthread_once_t *)once = 1;
30006d5c: 03a03001 moveq r3, #1 <== NOT EXECUTED 30006d60: 05843000 streq r3, [r4] <== NOT EXECUTED
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
30006d64: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED 30006d68: e1a0200d mov r2, sp <== NOT EXECUTED 30006d6c: eb000db1 bl 3000a438 <rtems_task_mode> <== NOT EXECUTED
if ( o == 0 )
30006d70: e3550000 cmp r5, #0 <== NOT EXECUTED
(*func)();
30006d74: 01a0e00f moveq lr, pc <== NOT EXECUTED 30006d78: 012fff16 bxeq r6 <== NOT EXECUTED
} return 0; }
30006d7c: e3a00000 mov r0, #0 <== NOT EXECUTED
30006d80: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
30006f44 <rtems_gxx_recursive_mutex_init>:
void rtems_gxx_recursive_mutex_init(__gthread_recursive_mutex_t *mutex)
{
rtems_gxx_mutex_init(mutex);
30006f44: eaffffd4 b 30006e9c <rtems_gxx_mutex_init> <== NOT EXECUTED
30006f48 <rtems_gxx_recursive_mutex_lock>:
}
int rtems_gxx_recursive_mutex_lock(__gthread_recursive_mutex_t *mutex)
{
return rtems_gxx_mutex_lock(mutex);
30006f48: eaffffe1 b 30006ed4 <rtems_gxx_mutex_lock> <== NOT EXECUTED
30006f4c <rtems_gxx_recursive_mutex_trylock>:
}
int rtems_gxx_recursive_mutex_trylock(__gthread_recursive_mutex_t *mutex)
{
return rtems_gxx_mutex_trylock(mutex);
30006f4c: eaffffee b 30006f0c <rtems_gxx_mutex_trylock> <== NOT EXECUTED
30006f50 <rtems_gxx_recursive_mutex_unlock>:
}
int rtems_gxx_recursive_mutex_unlock(__gthread_recursive_mutex_t *mutex)
{
return rtems_gxx_mutex_unlock(mutex);
30006f50: eafffff5 b 30006f2c <rtems_gxx_mutex_unlock> <== NOT EXECUTED
30006e70 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
30006e70: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30006e74: e1a04000 mov r4, r0 <== NOT EXECUTED
30006e78: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_task_self()
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
30006e7c: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 30006e80: e1a01004 mov r1, r4 <== NOT EXECUTED 30006e84: e3a00000 mov r0, #0 <== NOT EXECUTED 30006e88: eb000ddc bl 3000a600 <rtems_task_variable_add> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
30006e8c: e3500000 cmp r0, #0 <== NOT EXECUTED
/* now let's set the proper value */
key->val = (void *)ptr;
30006e90: 05845000 streq r5, [r4] <== NOT EXECUTED
return 0;
}
return -1;
30006e94: 13e00000 mvnne r0, #0 <== NOT EXECUTED
}
30006e98: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b138 <rtems_heap_allocate_aligned_with_boundary>:
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
if (
3000b138: e59f3044 ldr r3, [pc, #68] ; 3000b184 <rtems_heap_allocate_aligned_with_boundary+0x4c><== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b13c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if (
3000b140: e5933000 ldr r3, [r3] <== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b144: e1a06000 mov r6, r0 <== NOT EXECUTED
if (
3000b148: e3530003 cmp r3, #3 <== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b14c: e1a05001 mov r5, r1 <== NOT EXECUTED 3000b150: e1a04002 mov r4, r2 <== NOT EXECUTED
if (
3000b154: 1a000002 bne 3000b164 <rtems_heap_allocate_aligned_with_boundary+0x2c><== NOT EXECUTED
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
3000b158: ebfffbdf bl 3000a0dc <malloc_is_system_state_OK> <== NOT EXECUTED
3000b15c: e3500000 cmp r0, #0 <== NOT EXECUTED
3000b160: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
) {
return NULL;
}
malloc_deferred_frees_process();
3000b164: ebfffbf0 bl 3000a12c <malloc_deferred_frees_process> <== NOT EXECUTED
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
3000b168: e59f3018 ldr r3, [pc, #24] ; 3000b188 <rtems_heap_allocate_aligned_with_boundary+0x50><== NOT EXECUTED 3000b16c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b170: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000b174: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b178: e1a03004 mov r3, r4 <== NOT EXECUTED
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
3000b17c: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
malloc_deferred_frees_process();
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
3000b180: ea001313 b 3000fdd4 <_Protected_heap_Allocate_aligned_with_boundary><== NOT EXECUTED
3000a2f0 <rtems_interrupt_disable>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a2f0: e10f0000 mrs r0, CPSR <== NOT EXECUTED 3000a2f4: e3803080 orr r3, r0, #128 ; 0x80 <== NOT EXECUTED 3000a2f8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_level previous_level;
_ISR_Disable( previous_level );
return previous_level;
}
3000a2fc: e12fff1e bx lr <== NOT EXECUTED
3000a300 <rtems_interrupt_enable>:
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a300: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
void rtems_interrupt_enable(
rtems_interrupt_level previous_level
)
{
_ISR_Enable( previous_level );
}
3000a304: e12fff1e bx lr <== NOT EXECUTED
3000a308 <rtems_interrupt_flash>:
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000a308: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000a30c: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3000a310: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
void rtems_interrupt_flash(
rtems_interrupt_level previous_level
)
{
_ISR_Flash( previous_level );
}
3000a314: e12fff1e bx lr <== NOT EXECUTED
3000a318 <rtems_interrupt_is_in_progress>:
#undef rtems_interrupt_is_in_progress
bool rtems_interrupt_is_in_progress( void )
{
return _ISR_Is_in_progress();
3000a318: e59f300c ldr r3, [pc, #12] ; 3000a32c <rtems_interrupt_is_in_progress+0x14><== NOT EXECUTED 3000a31c: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
3000a320: e2500000 subs r0, r0, #0 <== NOT EXECUTED 3000a324: 13a00001 movne r0, #1 <== NOT EXECUTED 3000a328: e12fff1e bx lr <== NOT EXECUTED
30009d20 <rtems_interrupt_level_attribute>:
rtems_attribute rtems_interrupt_level_attribute(
uint32_t level
)
{
return RTEMS_INTERRUPT_LEVEL(level);
}
30009d20: e2000080 and r0, r0, #128 ; 0x80 <== NOT EXECUTED 30009d24: e12fff1e bx lr <== NOT EXECUTED
3000ff5c <rtems_io_close>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3000ff5c: e59fc044 ldr ip, [pc, #68] ; 3000ffa8 <rtems_io_close+0x4c>
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
3000ff60: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3000ff64: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
3000ff68: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3000ff6c: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
3000ff70: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3000ff74: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
3000ff78: e59fc02c ldr ip, [pc, #44] ; 3000ffac <rtems_io_close+0x50> 3000ff7c: e3a04018 mov r4, #24 3000ff80: e59cc000 ldr ip, [ip] 3000ff84: e023c394 mla r3, r4, r3, ip 3000ff88: e5933008 ldr r3, [r3, #8]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
3000ff8c: e3530000 cmp r3, #0
3000ff90: 0a000002 beq 3000ffa0 <rtems_io_close+0x44>
3000ff94: e1a0e00f mov lr, pc
3000ff98: e12fff13 bx r3
3000ff9c: e8bd8010 pop {r4, pc}
3000ffa0: e1a00003 mov r0, r3 <== NOT EXECUTED
}
3000ffa4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ffb0 <rtems_io_control>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3000ffb0: e59fc044 ldr ip, [pc, #68] ; 3000fffc <rtems_io_control+0x4c>
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
3000ffb4: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3000ffb8: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
3000ffbc: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3000ffc0: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
3000ffc4: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3000ffc8: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
3000ffcc: e59fc02c ldr ip, [pc, #44] ; 30010000 <rtems_io_control+0x50> 3000ffd0: e3a04018 mov r4, #24 3000ffd4: e59cc000 ldr ip, [ip] 3000ffd8: e023c394 mla r3, r4, r3, ip 3000ffdc: e5933014 ldr r3, [r3, #20]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
3000ffe0: e3530000 cmp r3, #0
3000ffe4: 0a000002 beq 3000fff4 <rtems_io_control+0x44>
3000ffe8: e1a0e00f mov lr, pc
3000ffec: e12fff13 bx r3
3000fff0: e8bd8010 pop {r4, pc}
3000fff4: e1a00003 mov r0, r3 <== NOT EXECUTED
}
3000fff8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30005f60 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
30005f60: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30005f64: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30005f68: e1a06000 mov r6, r0 <== NOT EXECUTED
30005f6c: e1a05001 mov r5, r1 <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
30005f70: eb002c9b bl 300111e4 <strlen> <== NOT EXECUTED 30005f74: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30005f78: e3a03001 mov r3, #1 <== NOT EXECUTED 30005f7c: e1a01000 mov r1, r0 <== NOT EXECUTED 30005f80: e58d3000 str r3, [sp] <== NOT EXECUTED 30005f84: e3a02000 mov r2, #0 <== NOT EXECUTED 30005f88: e1a03004 mov r3, r4 <== NOT EXECUTED 30005f8c: e1a00006 mov r0, r6 <== NOT EXECUTED 30005f90: eb00008e bl 300061d0 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
30005f94: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
30005f98: e1a08000 mov r8, r0 <== NOT EXECUTED
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
30005f9c: e1a00004 mov r0, r4 <== NOT EXECUTED
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
30005fa0: e59d7004 ldr r7, [sp, #4] <== NOT EXECUTED
node_type = (*loc.ops->node_type_h)( &loc );
30005fa4: e1a0e00f mov lr, pc <== NOT EXECUTED 30005fa8: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
30005fac: e3580000 cmp r8, #0 <== NOT EXECUTED 30005fb0: 03500002 cmpeq r0, #2 <== NOT EXECUTED 30005fb4: 03a08000 moveq r8, #0 <== NOT EXECUTED 30005fb8: 13a08001 movne r8, #1 <== NOT EXECUTED 30005fbc: 0a000003 beq 30005fd0 <rtems_io_lookup_name+0x70> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30005fc0: e1a00004 mov r0, r4 <== NOT EXECUTED 30005fc4: eb0000b1 bl 30006290 <rtems_filesystem_freenode> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
30005fc8: e3a0000d mov r0, #13 <== NOT EXECUTED 30005fcc: ea00000a b 30005ffc <rtems_io_lookup_name+0x9c> <== NOT EXECUTED
}
device_info->device_name = (char *) name;
30005fd0: e5856000 str r6, [r5] <== NOT EXECUTED
device_info->device_name_length = strlen( name );
30005fd4: e1a00006 mov r0, r6 <== NOT EXECUTED 30005fd8: eb002c81 bl 300111e4 <strlen> <== NOT EXECUTED 30005fdc: e5850004 str r0, [r5, #4] <== NOT EXECUTED
device_info->major = the_jnode->info.device.major;
30005fe0: e5973050 ldr r3, [r7, #80] ; 0x50 <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
30005fe4: e1a00004 mov r0, r4 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
device_info->device_name_length = strlen( name );
device_info->major = the_jnode->info.device.major;
30005fe8: e5853008 str r3, [r5, #8] <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
30005fec: e5973054 ldr r3, [r7, #84] ; 0x54 <== NOT EXECUTED 30005ff0: e585300c str r3, [r5, #12] <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30005ff4: eb0000a5 bl 30006290 <rtems_filesystem_freenode> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30005ff8: e1a00008 mov r0, r8 <== NOT EXECUTED
}
30005ffc: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30006000: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30010004 <rtems_io_open>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010004: e59fc044 ldr ip, [pc, #68] ; 30010050 <rtems_io_open+0x4c>
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010008: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001000c: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010010: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010014: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30010018: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001001c: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
30010020: e59fc02c ldr ip, [pc, #44] ; 30010054 <rtems_io_open+0x50> 30010024: e3a04018 mov r4, #24 30010028: e59cc000 ldr ip, [ip] 3001002c: e023c394 mla r3, r4, r3, ip 30010030: e5933004 ldr r3, [r3, #4]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010034: e3530000 cmp r3, #0
30010038: 0a000002 beq 30010048 <rtems_io_open+0x44>
3001003c: e1a0e00f mov lr, pc
30010040: e12fff13 bx r3
30010044: e8bd8010 pop {r4, pc}
30010048: e1a00003 mov r0, r3 <== NOT EXECUTED
}
3001004c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30010058 <rtems_io_read>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010058: e59fc044 ldr ip, [pc, #68] ; 300100a4 <rtems_io_read+0x4c>
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
3001005c: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010060: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010064: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010068: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
3001006c: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010070: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
30010074: e59fc02c ldr ip, [pc, #44] ; 300100a8 <rtems_io_read+0x50> 30010078: e3a04018 mov r4, #24 3001007c: e59cc000 ldr ip, [ip] 30010080: e023c394 mla r3, r4, r3, ip 30010084: e593300c ldr r3, [r3, #12]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010088: e3530000 cmp r3, #0
3001008c: 0a000002 beq 3001009c <rtems_io_read+0x44>
30010090: e1a0e00f mov lr, pc
30010094: e12fff13 bx r3
30010098: e8bd8010 pop {r4, pc}
3001009c: e1a00003 mov r0, r3 <== NOT EXECUTED
}
300100a0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000af08 <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
3000af08: e92d4010 push {r4, lr}
3000af0c: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000af10: e59f0158 ldr r0, [pc, #344] ; 3000b070 <rtems_io_register_driver+0x168>
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
3000af14: e59f3158 ldr r3, [pc, #344] ; 3000b074 <rtems_io_register_driver+0x16c>
if ( rtems_interrupt_is_in_progress() )
3000af18: e5900000 ldr r0, [r0]
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
3000af1c: e5933000 ldr r3, [r3]
if ( rtems_interrupt_is_in_progress() )
3000af20: e3500000 cmp r0, #0
return RTEMS_CALLED_FROM_ISR;
3000af24: 13a00012 movne r0, #18
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000af28: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
3000af2c: e3520000 cmp r2, #0
3000af30: 0a000041 beq 3000b03c <rtems_io_register_driver+0x134>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
3000af34: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
3000af38: e5823000 str r3, [r2]
if ( driver_table == NULL )
3000af3c: 0a00003e beq 3000b03c <rtems_io_register_driver+0x134>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000af40: e5910000 ldr r0, [r1] 3000af44: e3500000 cmp r0, #0
3000af48: 1a00003f bne 3000b04c <rtems_io_register_driver+0x144>
3000af4c: e5910004 ldr r0, [r1, #4] 3000af50: e3500000 cmp r0, #0
3000af54: 1a00003c bne 3000b04c <rtems_io_register_driver+0x144>
3000af58: ea000037 b 3000b03c <rtems_io_register_driver+0x134> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000af5c: e59f3114 ldr r3, [pc, #276] ; 3000b078 <rtems_io_register_driver+0x170> 3000af60: e5930000 ldr r0, [r3] 3000af64: e2800001 add r0, r0, #1 3000af68: e5830000 str r0, [r3]
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
3000af6c: e3540000 cmp r4, #0 3000af70: e59f0104 ldr r0, [pc, #260] ; 3000b07c <rtems_io_register_driver+0x174>
3000af74: 1a000010 bne 3000afbc <rtems_io_register_driver+0xb4>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
3000af78: e59f30f4 ldr r3, [pc, #244] ; 3000b074 <rtems_io_register_driver+0x16c> 3000af7c: e593c000 ldr ip, [r3] 3000af80: e5903000 ldr r3, [r0] 3000af84: ea000006 b 3000afa4 <rtems_io_register_driver+0x9c>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000af88: e5930000 ldr r0, [r3] 3000af8c: e3500000 cmp r0, #0
3000af90: 1a000030 bne 3000b058 <rtems_io_register_driver+0x150>
3000af94: e5930004 ldr r0, [r3, #4] 3000af98: e3500000 cmp r0, #0
3000af9c: 1a00002d bne 3000b058 <rtems_io_register_driver+0x150>
3000afa0: ea000001 b 3000afac <rtems_io_register_driver+0xa4>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
3000afa4: e154000c cmp r4, ip
3000afa8: 3afffff6 bcc 3000af88 <rtems_io_register_driver+0x80>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
3000afac: e154000c cmp r4, ip
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
3000afb0: e5824000 str r4, [r2]
if ( m != n )
3000afb4: 1a000011 bne 3000b000 <rtems_io_register_driver+0xf8>
3000afb8: ea000029 b 3000b064 <rtems_io_register_driver+0x15c> <== NOT EXECUTED
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
3000afbc: e3a03018 mov r3, #24 <== NOT EXECUTED 3000afc0: e0030394 mul r3, r4, r3 <== NOT EXECUTED 3000afc4: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000afc8: e080c003 add ip, r0, r3 <== NOT EXECUTED
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000afcc: e7903003 ldr r3, [r0, r3] <== NOT EXECUTED 3000afd0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000afd4: 13a03000 movne r3, #0 <== NOT EXECUTED 3000afd8: 1a000002 bne 3000afe8 <rtems_io_register_driver+0xe0> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
}
rtems_status_code rtems_io_register_driver(
3000afdc: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 3000afe0: e2733001 rsbs r3, r3, #1 <== NOT EXECUTED 3000afe4: 33a03000 movcc r3, #0 <== NOT EXECUTED
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
3000afe8: e3530000 cmp r3, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
3000afec: 15824000 strne r4, [r2] <== NOT EXECUTED
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
3000aff0: 1a000002 bne 3000b000 <rtems_io_register_driver+0xf8> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000aff4: eb00073d bl 3000ccf0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
3000aff8: e3a0000c mov r0, #12 <== NOT EXECUTED
3000affc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
3000b000: e59f3074 ldr r3, [pc, #116] ; 3000b07c <rtems_io_register_driver+0x174>
3000b004: e3a0c018 mov ip, #24
3000b008: e5933000 ldr r3, [r3]
3000b00c: e1a0e001 mov lr, r1
3000b010: e02c3c94 mla ip, r4, ip, r3
3000b014: e8be000f ldm lr!, {r0, r1, r2, r3}
3000b018: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000b01c: e89e0003 ldm lr, {r0, r1}
3000b020: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
3000b024: eb000731 bl 3000ccf0 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
3000b028: e3a01000 mov r1, #0 3000b02c: e1a00004 mov r0, r4 3000b030: e1a02001 mov r2, r1
}
3000b034: e8bd4010 pop {r4, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
3000b038: ea001d12 b 30012488 <rtems_io_initialize>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
3000b03c: e3a00009 mov r0, #9 <== NOT EXECUTED
3000b040: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
3000b044: e3a0000a mov r0, #10 <== NOT EXECUTED
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
3000b048: e8bd8010 pop {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
3000b04c: e1540003 cmp r4, r3
3000b050: 3affffc1 bcc 3000af5c <rtems_io_register_driver+0x54>
3000b054: eafffffa b 3000b044 <rtems_io_register_driver+0x13c> <== NOT EXECUTED
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
3000b058: e2844001 add r4, r4, #1 3000b05c: e2833018 add r3, r3, #24 3000b060: eaffffcf b 3000afa4 <rtems_io_register_driver+0x9c>
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
3000b064: eb000721 bl 3000ccf0 <_Thread_Enable_dispatch> <== NOT EXECUTED
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
3000b068: e3a00005 mov r0, #5 <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
3000b06c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b080 <rtems_io_unregister_driver>:
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000b080: e59f305c ldr r3, [pc, #92] ; 3000b0e4 <rtems_io_unregister_driver+0x64>
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
3000b084: e92d4010 push {r4, lr}
if ( rtems_interrupt_is_in_progress() )
3000b088: e5934000 ldr r4, [r3] 3000b08c: e3540000 cmp r4, #0
return RTEMS_CALLED_FROM_ISR;
3000b090: 13a00012 movne r0, #18
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000b094: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
3000b098: e59f3048 ldr r3, [pc, #72] ; 3000b0e8 <rtems_io_unregister_driver+0x68> 3000b09c: e5933000 ldr r3, [r3] 3000b0a0: e1500003 cmp r0, r3
3000b0a4: 2a00000c bcs 3000b0dc <rtems_io_unregister_driver+0x5c>
3000b0a8: e59f303c ldr r3, [pc, #60] ; 3000b0ec <rtems_io_unregister_driver+0x6c> 3000b0ac: e5932000 ldr r2, [r3] 3000b0b0: e2822001 add r2, r2, #1 3000b0b4: e5832000 str r2, [r3]
_Thread_Disable_dispatch();
memset(
3000b0b8: e59f3030 ldr r3, [pc, #48] ; 3000b0f0 <rtems_io_unregister_driver+0x70>
&_IO_Driver_address_table[major],
3000b0bc: e3a02018 mov r2, #24
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
3000b0c0: e5933000 ldr r3, [r3] 3000b0c4: e1a01004 mov r1, r4 3000b0c8: e0203092 mla r0, r2, r0, r3 3000b0cc: eb0026d9 bl 30014c38 <memset>
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
3000b0d0: eb000706 bl 3000ccf0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b0d4: e1a00004 mov r0, r4
3000b0d8: e8bd8010 pop {r4, pc}
}
return RTEMS_UNSATISFIED;
3000b0dc: e3a0000d mov r0, #13 <== NOT EXECUTED
}
3000b0e0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300100ac <rtems_io_write>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300100ac: e59fc044 ldr ip, [pc, #68] ; 300100f8 <rtems_io_write+0x4c>
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300100b0: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300100b4: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300100b8: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300100bc: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
300100c0: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300100c4: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
300100c8: e59fc02c ldr ip, [pc, #44] ; 300100fc <rtems_io_write+0x50> 300100cc: e3a04018 mov r4, #24 300100d0: e59cc000 ldr ip, [ip] 300100d4: e023c394 mla r3, r4, r3, ip 300100d8: e5933010 ldr r3, [r3, #16]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
300100dc: e3530000 cmp r3, #0
300100e0: 0a000002 beq 300100f0 <rtems_io_write+0x44>
300100e4: e1a0e00f mov lr, pc
300100e8: e12fff13 bx r3
300100ec: e8bd8010 pop {r4, pc}
300100f0: e1a00003 mov r0, r3 <== NOT EXECUTED
}
300100f4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c0f0 <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
3000c0f0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
3000c0f4: e2508000 subs r8, r0, #0 <== NOT EXECUTED
3000c0f8: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c0fc: e59f4050 ldr r4, [pc, #80] ; 3000c154 <rtems_iterate_over_all_threads+0x64><== NOT EXECUTED
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
3000c100: e284700c add r7, r4, #12 <== NOT EXECUTED
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
3000c104: e5b43004 ldr r3, [r4, #4]! <== NOT EXECUTED 3000c108: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c10c: 0a00000d beq 3000c148 <rtems_iterate_over_all_threads+0x58><== NOT EXECUTED
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
3000c110: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED
if ( !information )
3000c114: e3560000 cmp r6, #0 <== NOT EXECUTED 3000c118: 13a05001 movne r5, #1 <== NOT EXECUTED 3000c11c: 1a000006 bne 3000c13c <rtems_iterate_over_all_threads+0x4c><== NOT EXECUTED 3000c120: ea000008 b 3000c148 <rtems_iterate_over_all_threads+0x58> <== NOT EXECUTED
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
3000c124: e596301c ldr r3, [r6, #28] <== NOT EXECUTED 3000c128: e7930105 ldr r0, [r3, r5, lsl #2] <== NOT EXECUTED
if ( !the_thread )
3000c12c: e3500000 cmp r0, #0 <== NOT EXECUTED
continue;
(*routine)(the_thread);
3000c130: 11a0e00f movne lr, pc <== NOT EXECUTED 3000c134: 112fff18 bxne r8 <== NOT EXECUTED
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000c138: e2855001 add r5, r5, #1 <== NOT EXECUTED 3000c13c: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED 3000c140: e1550003 cmp r5, r3 <== NOT EXECUTED 3000c144: 9afffff6 bls 3000c124 <rtems_iterate_over_all_threads+0x34><== NOT EXECUTED
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
3000c148: e1540007 cmp r4, r7 <== NOT EXECUTED
3000c14c: 1affffec bne 3000c104 <rtems_iterate_over_all_threads+0x14><== NOT EXECUTED
3000c150: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300063b0 <rtems_libio_init>:
{
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
300063b0: e59f30a8 ldr r3, [pc, #168] ; 30006460 <rtems_libio_init+0xb0>
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
300063b4: e92d4011 push {r0, r4, lr}
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
300063b8: e5934000 ldr r4, [r3] 300063bc: e3540000 cmp r4, #0
300063c0: 0a000016 beq 30006420 <rtems_libio_init+0x70>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
300063c4: e1a00004 mov r0, r4 300063c8: e3a01038 mov r1, #56 ; 0x38 300063cc: ebffff50 bl 30006114 <calloc> 300063d0: e59f308c ldr r3, [pc, #140] ; 30006464 <rtems_libio_init+0xb4>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
300063d4: 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,
300063d8: e5830000 str r0, [r3]
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
300063dc: 0280001a addeq r0, r0, #26
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
300063e0: 0a000017 beq 30006444 <rtems_libio_init+0x94>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
300063e4: e59f307c ldr r3, [pc, #124] ; 30006468 <rtems_libio_init+0xb8>
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
300063e8: e3a02000 mov r2, #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);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
300063ec: e5830000 str r0, [r3] 300063f0: e1a03000 mov r3, r0
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
300063f4: ea000000 b 300063fc <rtems_libio_init+0x4c>
iop->data1 = iop + 1;
300063f8: 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++)
300063fc: e2822001 add r2, r2, #1 30006400: e1520004 cmp r2, r4 30006404: e2833038 add r3, r3, #56 ; 0x38
30006408: 3afffffa bcc 300063f8 <rtems_libio_init+0x48>
iop->data1 = iop + 1;
iop->data1 = NULL;
3000640c: e3a03038 mov r3, #56 ; 0x38 30006410: e0200493 mla r0, r3, r4, r0 30006414: e3a03000 mov r3, #0 30006418: e2400038 sub r0, r0, #56 ; 0x38 3000641c: e5803034 str r3, [r0, #52] ; 0x34
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
30006420: e59f3044 ldr r3, [pc, #68] ; 3000646c <rtems_libio_init+0xbc> 30006424: e59f0044 ldr r0, [pc, #68] ; 30006470 <rtems_libio_init+0xc0> 30006428: e58d3000 str r3, [sp] 3000642c: e3a01001 mov r1, #1 30006430: e3a02054 mov r2, #84 ; 0x54 30006434: e3a03000 mov r3, #0 30006438: eb000b86 bl 30009258 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
3000643c: e3500000 cmp r0, #0
30006440: 0a000000 beq 30006448 <rtems_libio_init+0x98>
rtems_fatal_error_occurred( rc );
30006444: eb000daf bl 30009b08 <rtems_fatal_error_occurred> <== NOT EXECUTED
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
30006448: e59f3024 ldr r3, [pc, #36] ; 30006474 <rtems_libio_init+0xc4> 3000644c: e5933000 ldr r3, [r3] 30006450: e3530000 cmp r3, #0
(* rtems_fs_init_helper)();
30006454: 11a0e00f movne lr, pc 30006458: 112fff13 bxne r3
}
3000645c: e8bd8018 pop {r3, r4, pc}
30007824 <rtems_libio_set_private_env>:
}
}
rtems_status_code rtems_libio_set_private_env(void)
{
30007824: e92d4070 push {r4, r5, r6, lr}
30007828: e24dd02c sub sp, sp, #44 ; 0x2c
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id task_id = rtems_task_self();
3000782c: eb000a92 bl 3000a27c <rtems_task_self>
rtems_filesystem_location_info_t root_loc;
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
30007830: e3a02000 mov r2, #0
}
rtems_status_code rtems_libio_set_private_env(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
30007834: e1a04000 mov r4, r0
rtems_filesystem_location_info_t root_loc;
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
30007838: e3a01001 mov r1, #1 3000783c: e59f00f4 ldr r0, [pc, #244] ; 30007938 <rtems_libio_set_private_env+0x114> 30007840: e28d3018 add r3, sp, #24 30007844: e58d2000 str r2, [sp] 30007848: ebfffba6 bl 300066e8 <rtems_filesystem_evaluate_path>
if (rv != 0)
3000784c: e2502000 subs r2, r0, #0
30007850: 1a000035 bne 3000792c <rtems_libio_set_private_env+0x108>
goto error_0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);
30007854: e59f00dc ldr r0, [pc, #220] ; 30007938 <rtems_libio_set_private_env+0x114> 30007858: e3a01001 mov r1, #1 3000785c: e28d3004 add r3, sp, #4 30007860: e58d2000 str r2, [sp] 30007864: ebfffb9f bl 300066e8 <rtems_filesystem_evaluate_path>
if (rv != 0)
30007868: e3500000 cmp r0, #0
3000786c: 1a00002c bne 30007924 <rtems_libio_set_private_env+0x100>
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
rtems_current_user_env == &rtems_global_user_env
30007870: e59f30c4 ldr r3, [pc, #196] ; 3000793c <rtems_libio_set_private_env+0x118>
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
30007874: e59f20c4 ldr r2, [pc, #196] ; 30007940 <rtems_libio_set_private_env+0x11c>
rtems_current_user_env == &rtems_global_user_env
30007878: e5933000 ldr r3, [r3]
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
3000787c: e1530002 cmp r3, r2
30007880: 0a000002 beq 30007890 <rtems_libio_set_private_env+0x6c>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
30007884: e5933000 ldr r3, [r3] 30007888: e1530004 cmp r3, r4
3000788c: 0a00000b beq 300078c0 <rtems_libio_set_private_env+0x9c>
) {
new_env = malloc(sizeof(rtems_user_env_t));
30007890: e3a00048 mov r0, #72 ; 0x48 30007894: ebfffd36 bl 30006d74 <malloc>
if (new_env == NULL)
30007898: e2505000 subs r5, r0, #0
3000789c: 0a00001e beq 3000791c <rtems_libio_set_private_env+0xf8>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
300078a0: e59f6094 ldr r6, [pc, #148] ; 3000793c <rtems_libio_set_private_env+0x118> 300078a4: e3a00000 mov r0, #0 300078a8: e1a01006 mov r1, r6 300078ac: e59f2090 ldr r2, [pc, #144] ; 30007944 <rtems_libio_set_private_env+0x120> 300078b0: eb000a8e bl 3000a2f0 <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
300078b4: e3500000 cmp r0, #0
300078b8: 1a000015 bne 30007914 <rtems_libio_set_private_env+0xf0>
goto error_3;
rtems_current_user_env = new_env;
300078bc: e5865000 str r5, [r6]
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
300078c0: e59f3074 ldr r3, [pc, #116] ; 3000793c <rtems_libio_set_private_env+0x118> 300078c4: e59f1074 ldr r1, [pc, #116] ; 30007940 <rtems_libio_set_private_env+0x11c> 300078c8: e5935000 ldr r5, [r3] 300078cc: e3a02048 mov r2, #72 ; 0x48 300078d0: e1a00005 mov r0, r5 300078d4: eb0026ab bl 30011388 <memcpy>
rtems_current_user_env->task_id = task_id;
300078d8: e1a0c005 mov ip, r5 300078dc: e48c4018 str r4, [ip], #24
* Clone the pathlocs. In contrast to most other code we must _not_ free the * original locs because what we are trying to do here is forking off clones. * The reason is a pathloc can be allocated by the file system and needs to * be freed when deleting the environment. */ rtems_filesystem_root = root_loc;
300078e0: e28d4018 add r4, sp, #24
300078e4: e8b4000f ldm r4!, {r0, r1, r2, r3}
300078e8: e8ac000f stmia ip!, {r0, r1, r2, r3}
300078ec: e5943000 ldr r3, [r4]
rtems_filesystem_current = current_loc;
300078f0: e28d4004 add r4, sp, #4
* Clone the pathlocs. In contrast to most other code we must _not_ free the * original locs because what we are trying to do here is forking off clones. * The reason is a pathloc can be allocated by the file system and needs to * be freed when deleting the environment. */ rtems_filesystem_root = root_loc;
300078f4: e58c3000 str r3, [ip]
rtems_filesystem_current = current_loc;
300078f8: e285c004 add ip, r5, #4
300078fc: e8b4000f ldm r4!, {r0, r1, r2, r3}
30007900: e8ac000f stmia ip!, {r0, r1, r2, r3}
30007904: e5943000 ldr r3, [r4]
return RTEMS_SUCCESSFUL;
30007908: e3a00000 mov r0, #0
* original locs because what we are trying to do here is forking off clones. * The reason is a pathloc can be allocated by the file system and needs to * be freed when deleting the environment. */ rtems_filesystem_root = root_loc; rtems_filesystem_current = current_loc;
3000790c: e58c3000 str r3, [ip]
return RTEMS_SUCCESSFUL;
30007910: ea000006 b 30007930 <rtems_libio_set_private_env+0x10c>
error_3:
free(new_env);
30007914: e1a00005 mov r0, r5 <== NOT EXECUTED 30007918: ebfffba7 bl 300067bc <free> <== NOT EXECUTED
error_2:
rtems_filesystem_freenode(¤t_loc);
3000791c: e28d0004 add r0, sp, #4 30007920: ebfffba0 bl 300067a8 <rtems_filesystem_freenode>
error_1:
rtems_filesystem_freenode(&root_loc);
30007924: e28d0018 add r0, sp, #24 30007928: ebfffb9e bl 300067a8 <rtems_filesystem_freenode>
error_0:
return RTEMS_NO_MEMORY;
3000792c: e3a0001a mov r0, #26
}
30007930: e28dd02c add sp, sp, #44 ; 0x2c
30007934: e8bd8070 pop {r4, r5, r6, pc}
30007948 <rtems_libio_share_private_env>:
* b) mutex access to rtems_filesystem_current, rtems_filesytem_root
* while changing any of those (chdir(), chroot()).
*/
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
30007948: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
3000794c: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
30007950: eb000a49 bl 3000a27c <rtems_task_self> <== NOT EXECUTED
/*
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
30007954: e1560000 cmp r6, r0 <== NOT EXECUTED
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
30007958: e1a04000 mov r4, r0 <== NOT EXECUTED
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
return RTEMS_SUCCESSFUL;
3000795c: 03a06000 moveq r6, #0 <== NOT EXECUTED
/*
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
30007960: 0a00000d beq 3000799c <rtems_libio_share_private_env+0x54> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
30007964: e59f5038 ldr r5, [pc, #56] ; 300079a4 <rtems_libio_share_private_env+0x5c><== NOT EXECUTED 30007968: e1a00006 mov r0, r6 <== NOT EXECUTED 3000796c: e1a01005 mov r1, r5 <== NOT EXECUTED 30007970: e1a0200d mov r2, sp <== NOT EXECUTED 30007974: eb000a87 bl 3000a398 <rtems_task_variable_get> <== NOT EXECUTED
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
30007978: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000797c: 1a000006 bne 3000799c <rtems_libio_share_private_env+0x54> <== NOT EXECUTED
* If we have a current environment in place, we need to
* free it, since we will be sharing the variable with the
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
30007980: e5950000 ldr r0, [r5] <== NOT EXECUTED 30007984: e5903000 ldr r3, [r0] <== NOT EXECUTED 30007988: e1530004 cmp r3, r4 <== NOT EXECUTED
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
3000798c: 0bffff97 bleq 300077f0 <free_user_env> <== NOT EXECUTED
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
30007990: e59d2000 ldr r2, [sp] <== NOT EXECUTED 30007994: e59f3008 ldr r3, [pc, #8] ; 300079a4 <rtems_libio_share_private_env+0x5c><== NOT EXECUTED 30007998: e5832000 str r2, [r3] <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
3000799c: e1a00006 mov r0, r6 <== NOT EXECUTED
300079a0: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000db2c <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
3000db2c: e2003006 and r3, r0, #6 3000db30: e3530006 cmp r3, #6
fcntl_flags |= O_RDWR;
3000db34: 03a03002 moveq r3, #2
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
3000db38: 0a000005 beq 3000db54 <rtems_libio_to_fcntl_flags+0x28>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
3000db3c: e3100002 tst r0, #2
fcntl_flags |= O_RDONLY;
3000db40: 13a03000 movne r3, #0
{
uint32_t 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) {
3000db44: 1a000002 bne 3000db54 <rtems_libio_to_fcntl_flags+0x28>
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
3000db48: e3100004 tst r0, #4 <== NOT EXECUTED 3000db4c: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000db50: 13a03001 movne r3, #1 <== NOT EXECUTED
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 ) {
3000db54: e3100001 tst r0, #1
fcntl_flags |= O_NONBLOCK;
3000db58: 13833901 orrne r3, r3, #16384 ; 0x4000
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
3000db5c: e3100c02 tst r0, #512 ; 0x200
fcntl_flags |= O_APPEND;
3000db60: 13833008 orrne r3, r3, #8
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
3000db64: e3100b01 tst r0, #1024 ; 0x400
fcntl_flags |= O_CREAT;
3000db68: 13833c02 orrne r3, r3, #512 ; 0x200
}
return fcntl_flags;
}
3000db6c: e1a00003 mov r0, r3 3000db70: e12fff1e bx lr
3000a498 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
3000a498: e92d4001 push {r0, lr} <== NOT EXECUTED
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
3000a49c: e59f3038 ldr r3, [pc, #56] ; 3000a4dc <rtems_malloc_statistics_at_free+0x44><== NOT EXECUTED
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
3000a4a0: e1a01000 mov r1, r0 <== NOT EXECUTED
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
3000a4a4: e1a0200d mov r2, sp <== NOT EXECUTED 3000a4a8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000a4ac: eb00167c bl 3000fea4 <_Protected_heap_Get_block_size> <== NOT EXECUTED 3000a4b0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a4b4: 0a000007 beq 3000a4d8 <rtems_malloc_statistics_at_free+0x40><== NOT EXECUTED
MSBUMP(lifetime_freed, size);
3000a4b8: e59f3020 ldr r3, [pc, #32] ; 3000a4e0 <rtems_malloc_statistics_at_free+0x48><== NOT EXECUTED
3000a4bc: e59d0000 ldr r0, [sp] <== NOT EXECUTED
3000a4c0: e2832024 add r2, r3, #36 ; 0x24 <== NOT EXECUTED
3000a4c4: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
3000a4c8: e0911000 adds r1, r1, r0 <== NOT EXECUTED
3000a4cc: e2a22000 adc r2, r2, #0 <== NOT EXECUTED
3000a4d0: e5831024 str r1, [r3, #36] ; 0x24 <== NOT EXECUTED
3000a4d4: e5832028 str r2, [r3, #40] ; 0x28 <== NOT EXECUTED
} }
3000a4d8: e8bd8008 pop {r3, pc} <== NOT EXECUTED
30011cd8 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
30011cd8: e92d4070 push {r4, r5, r6, lr}
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
30011cdc: e2504000 subs r4, r0, #0
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
30011ce0: e1a05001 mov r5, r1 30011ce4: e1a06002 mov r6, r2
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
30011ce8: 0a00001a beq 30011d58 <rtems_memalign+0x80>
return EINVAL;
*pointer = NULL;
30011cec: e3a03000 mov r3, #0 30011cf0: e5843000 str r3, [r4]
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30011cf4: e59f306c ldr r3, [pc, #108] ; 30011d68 <rtems_memalign+0x90> 30011cf8: e5933000 ldr r3, [r3] 30011cfc: e3530003 cmp r3, #3
30011d00: 1a000002 bne 30011d10 <rtems_memalign+0x38>
!malloc_is_system_state_OK() )
30011d04: ebffd61b bl 30007578 <malloc_is_system_state_OK>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30011d08: e3500000 cmp r0, #0
30011d0c: 0a000011 beq 30011d58 <rtems_memalign+0x80>
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
30011d10: ebffd62c bl 300075c8 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
30011d14: e59f3050 ldr r3, [pc, #80] ; 30011d6c <rtems_memalign+0x94> 30011d18: e1a02005 mov r2, r5 30011d1c: e5930000 ldr r0, [r3] 30011d20: e1a01006 mov r1, r6 30011d24: e3a03000 mov r3, #0 30011d28: ebffe94c bl 3000c260 <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
30011d2c: e2505000 subs r5, r0, #0
30011d30: 0a00000a beq 30011d60 <rtems_memalign+0x88>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
30011d34: e59f3034 ldr r3, [pc, #52] ; 30011d70 <rtems_memalign+0x98> 30011d38: e5933000 ldr r3, [r3] 30011d3c: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
30011d40: 11a00004 movne r0, r4 30011d44: 11a0e00f movne lr, pc 30011d48: 1593f004 ldrne pc, [r3, #4]
*pointer = return_this;
30011d4c: e5845000 str r5, [r4]
return 0;
30011d50: e3a00000 mov r0, #0
30011d54: 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() )
return EINVAL;
30011d58: e3a00016 mov r0, #22 <== NOT EXECUTED
30011d5c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
30011d60: e3a0000c mov r0, #12 <== NOT EXECUTED
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
30011d64: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30015d8c <rtems_message_queue_broadcast>:
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
30015d8c: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr}
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
30015d90: e2517000 subs r7, r1, #0
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
30015d94: e1a04000 mov r4, r0 30015d98: e1a05002 mov r5, r2 30015d9c: e1a06003 mov r6, r3
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
30015da0: 0a000015 beq 30015dfc <rtems_message_queue_broadcast+0x70>
return RTEMS_INVALID_ADDRESS;
if ( !count )
30015da4: e3530000 cmp r3, #0
30015da8: 0a000013 beq 30015dfc <rtems_message_queue_broadcast+0x70>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
30015dac: e59f0050 ldr r0, [pc, #80] ; 30015e04 <rtems_message_queue_broadcast+0x78> 30015db0: e1a01004 mov r1, r4 30015db4: e28d2008 add r2, sp, #8 30015db8: eb0013d2 bl 3001ad08 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30015dbc: e59d3008 ldr r3, [sp, #8] 30015dc0: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30015dc4: 13a00004 movne r0, #4
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30015dc8: 1a00000c bne 30015e00 <rtems_message_queue_broadcast+0x74>
case OBJECTS_LOCAL:
core_status = _CORE_message_queue_Broadcast(
30015dcc: e58d3000 str r3, [sp] 30015dd0: e1a01007 mov r1, r7 30015dd4: e1a03004 mov r3, r4 30015dd8: e1a02005 mov r2, r5 30015ddc: e2800014 add r0, r0, #20 30015de0: e58d6004 str r6, [sp, #4] 30015de4: eb000d00 bl 300191ec <_CORE_message_queue_Broadcast> 30015de8: e1a04000 mov r4, r0
NULL,
#endif
count
);
_Thread_Enable_dispatch();
30015dec: eb0016df bl 3001b970 <_Thread_Enable_dispatch>
return
30015df0: e1a00004 mov r0, r4 30015df4: eb0000cc bl 3001612c <_Message_queue_Translate_core_message_queue_return_code> 30015df8: ea000000 b 30015e00 <rtems_message_queue_broadcast+0x74>
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
30015dfc: e3a00009 mov r0, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30015e00: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc}
30011028 <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30011028: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr}
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
3001102c: e2507000 subs r7, r0, #0
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30011030: e1a06001 mov r6, r1 30011034: e1a05002 mov r5, r2 30011038: e1a0a003 mov sl, r3 3001103c: e59d8020 ldr r8, [sp, #32]
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30011040: 03a00003 moveq r0, #3
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
30011044: 0a00002d beq 30011100 <rtems_message_queue_create+0xd8>
return RTEMS_INVALID_NAME;
if ( !id )
30011048: e3580000 cmp r8, #0
return RTEMS_INVALID_ADDRESS;
3001104c: 03a00009 moveq r0, #9
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30011050: 0a00002a beq 30011100 <rtems_message_queue_create+0xd8>
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
30011054: e3510000 cmp r1, #0
return RTEMS_INVALID_NUMBER;
30011058: 03a0000a moveq r0, #10
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
3001105c: 0a000027 beq 30011100 <rtems_message_queue_create+0xd8>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
30011060: e3520000 cmp r2, #0
return RTEMS_INVALID_SIZE;
30011064: 03a00008 moveq r0, #8
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
30011068: 0a000024 beq 30011100 <rtems_message_queue_create+0xd8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3001106c: e59f3090 ldr r3, [pc, #144] ; 30011104 <rtems_message_queue_create+0xdc> 30011070: e5932000 ldr r2, [r3] 30011074: e2822001 add r2, r2, #1 30011078: e5832000 str r2, [r3]
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
3001107c: eb0015a9 bl 30016728 <_Message_queue_Allocate>
if ( !the_message_queue ) {
30011080: e2504000 subs r4, r0, #0
30011084: 1a000002 bne 30011094 <rtems_message_queue_create+0x6c>
_Thread_Enable_dispatch();
30011088: eb000b78 bl 30013e70 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3001108c: e3a00005 mov r0, #5 <== NOT EXECUTED 30011090: ea00001a b 30011100 <rtems_message_queue_create+0xd8> <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
30011094: e584a010 str sl, [r4, #16]
if (_Attributes_Is_priority( attribute_set ) )
30011098: e21aa004 ands sl, sl, #4
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
3001109c: 13a03001 movne r3, #1 300110a0: 158d3000 strne r3, [sp]
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
300110a4: e2840014 add r0, r4, #20 300110a8: e1a0100d mov r1, sp 300110ac: e1a02006 mov r2, r6 300110b0: e1a03005 mov r3, r5
the_message_queue->attribute_set = attribute_set;
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
300110b4: 058da000 streq sl, [sp]
if ( ! _CORE_message_queue_Initialize(
300110b8: eb00044a bl 300121e8 <_CORE_message_queue_Initialize> 300110bc: e3500000 cmp r0, #0
300110c0: 1a000005 bne 300110dc <rtems_message_queue_create+0xb4>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
300110c4: e59f003c ldr r0, [pc, #60] ; 30011108 <rtems_message_queue_create+0xe0><== NOT EXECUTED 300110c8: e1a01004 mov r1, r4 <== NOT EXECUTED 300110cc: eb0007d2 bl 3001301c <_Objects_Free> <== NOT EXECUTED
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
300110d0: eb000b66 bl 30013e70 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
300110d4: e3a0000d mov r0, #13 <== NOT EXECUTED 300110d8: ea000008 b 30011100 <rtems_message_queue_create+0xd8> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300110dc: e59f2024 ldr r2, [pc, #36] ; 30011108 <rtems_message_queue_create+0xe0>
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300110e0: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300110e4: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300110e8: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300110ec: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300110f0: e584700c str r7, [r4, #12]
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
300110f4: e5883000 str r3, [r8]
name,
0
);
#endif
_Thread_Enable_dispatch();
300110f8: eb000b5c bl 30013e70 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300110fc: e3a00000 mov r0, #0
}
30011100: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc}
30015f9c <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
30015f9c: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
30015fa0: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
30015fa4: e1a03000 mov r3, r0 <== NOT EXECUTED
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
30015fa8: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
30015fac: 0a00000b beq 30015fe0 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED 30015fb0: e59f002c ldr r0, [pc, #44] ; 30015fe4 <rtems_message_queue_get_number_pending+0x48><== NOT EXECUTED 30015fb4: e1a01003 mov r1, r3 <== NOT EXECUTED 30015fb8: e1a0200d mov r2, sp <== NOT EXECUTED 30015fbc: eb001351 bl 3001ad08 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30015fc0: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30015fc4: e3550000 cmp r5, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30015fc8: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30015fcc: 1a000003 bne 30015fe0 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
30015fd0: e590305c ldr r3, [r0, #92] ; 0x5c <== NOT EXECUTED 30015fd4: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
30015fd8: eb001664 bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30015fdc: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30015fe0: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30011140 <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
30011140: e92d4077 push {r0, r1, r2, r4, r5, r6, lr}
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
30011144: e2515000 subs r5, r1, #0
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
30011148: e1a0c000 mov ip, r0 3001114c: e1a04002 mov r4, r2 30011150: e1a06003 mov r6, r3
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
30011154: 0a00001a beq 300111c4 <rtems_message_queue_receive+0x84>
return RTEMS_INVALID_ADDRESS;
if ( !size )
30011158: e3520000 cmp r2, #0
3001115c: 0a000018 beq 300111c4 <rtems_message_queue_receive+0x84>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
30011160: e28d2008 add r2, sp, #8 30011164: e59f0060 ldr r0, [pc, #96] ; 300111cc <rtems_message_queue_receive+0x8c> 30011168: e1a0100c mov r1, ip 3001116c: eb0007ff bl 30013170 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30011170: e59d2008 ldr r2, [sp, #8] 30011174: e1a03000 mov r3, r0 30011178: e3520000 cmp r2, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001117c: 13a00004 movne r0, #4
if ( !size )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30011180: 1a000010 bne 300111c8 <rtems_message_queue_receive+0x88>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
30011184: e59d201c ldr r2, [sp, #28]
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
30011188: e2066001 and r6, r6, #1 3001118c: e2266001 eor r6, r6, #1 30011190: e58d2004 str r2, [sp, #4] 30011194: e58d6000 str r6, [sp] 30011198: e2830014 add r0, r3, #20 3001119c: e5931008 ldr r1, [r3, #8] 300111a0: e1a02005 mov r2, r5 300111a4: e1a03004 mov r3, r4 300111a8: eb00043c bl 300122a0 <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
300111ac: eb000b2f bl 30013e70 <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
_Thread_Executing->Wait.return_code
300111b0: e59f3018 ldr r3, [pc, #24] ; 300111d0 <rtems_message_queue_receive+0x90> 300111b4: e5933004 ldr r3, [r3, #4]
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
300111b8: e5930034 ldr r0, [r3, #52] ; 0x34 300111bc: eb000023 bl 30011250 <_Message_queue_Translate_core_message_queue_return_code> 300111c0: ea000000 b 300111c8 <rtems_message_queue_receive+0x88>
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
300111c4: e3a00009 mov r0, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300111c8: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc}
3000b234 <rtems_object_api_maximum_class>:
int rtems_object_api_maximum_class(
int api
)
{
return _Objects_API_maximum_class(api);
3000b234: ea0005e9 b 3000c9e0 <_Objects_API_maximum_class> <== NOT EXECUTED
3000b238 <rtems_object_api_minimum_class>:
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000b238: e2400001 sub r0, r0, #1 <== NOT EXECUTED
uint32_t api
)
{
if ( _Objects_Is_api_valid( api ) )
return 1;
return -1;
3000b23c: e3500003 cmp r0, #3 <== NOT EXECUTED
}
3000b240: 33a00001 movcc r0, #1 <== NOT EXECUTED 3000b244: 23e00000 mvncs r0, #0 <== NOT EXECUTED 3000b248: e12fff1e bx lr <== NOT EXECUTED
3000b24c <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
3000b24c: e3500001 cmp r0, #1 <== NOT EXECUTED
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
3000b250: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
3000b254: 0a000003 beq 3000b268 <rtems_object_get_api_class_name+0x1c><== NOT EXECUTED
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
3000b258: e3500002 cmp r0, #2 <== NOT EXECUTED
api_assoc = rtems_object_api_classic_assoc;
3000b25c: 059f002c ldreq r0, [pc, #44] ; 3000b290 <rtems_object_get_api_class_name+0x44><== NOT EXECUTED
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
3000b260: 1a000006 bne 3000b280 <rtems_object_get_api_class_name+0x34><== NOT EXECUTED 3000b264: ea000000 b 3000b26c <rtems_object_get_api_class_name+0x20> <== NOT EXECUTED
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
3000b268: e59f0024 ldr r0, [pc, #36] ; 3000b294 <rtems_object_get_api_class_name+0x48><== NOT EXECUTED
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
3000b26c: eb0012bd bl 3000fd68 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( class_assoc )
3000b270: e3500000 cmp r0, #0 <== NOT EXECUTED
return class_assoc->name;
3000b274: 15900000 ldrne r0, [r0] <== NOT EXECUTED
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
3000b278: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
3000b27c: ea000001 b 3000b288 <rtems_object_get_api_class_name+0x3c> <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
3000b280: e59f0010 ldr r0, [pc, #16] ; 3000b298 <rtems_object_get_api_class_name+0x4c><== NOT EXECUTED
3000b284: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
return class_assoc->name;
return "BAD CLASS";
3000b288: e59f000c ldr r0, [pc, #12] ; 3000b29c <rtems_object_get_api_class_name+0x50><== NOT EXECUTED
}
3000b28c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b2a0 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
3000b2a0: e1a01000 mov r1, r0 <== NOT EXECUTED
3000b2a4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
3000b2a8: e59f0010 ldr r0, [pc, #16] ; 3000b2c0 <rtems_object_get_api_name+0x20><== NOT EXECUTED 3000b2ac: eb0012ad bl 3000fd68 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( api_assoc )
3000b2b0: e3500000 cmp r0, #0 <== NOT EXECUTED
return api_assoc->name;
3000b2b4: 15900000 ldrne r0, [r0] <== NOT EXECUTED
return "BAD CLASS";
3000b2b8: 059f0004 ldreq r0, [pc, #4] ; 3000b2c4 <rtems_object_get_api_name+0x24><== NOT EXECUTED
}
3000b2bc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b2f8 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
3000b2f8: e92d4010 push {r4, lr} <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000b2fc: e2524000 subs r4, r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000b300: 03a00009 moveq r0, #9 <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000b304: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
3000b308: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000b30c: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3000b310: eb000680 bl 3000cd18 <_Objects_Get_information> <== NOT EXECUTED
if ( !obj_info )
3000b314: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b318: 0a000014 beq 3000b370 <rtems_object_get_class_information+0x78><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
3000b31c: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum;
3000b320: e1d011b0 ldrh r1, [r0, #16] <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
3000b324: e5843000 str r3, [r4] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id;
3000b328: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000b32c: e3a02000 mov r2, #0 <== NOT EXECUTED
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
3000b330: e5843004 str r3, [r4, #4] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
3000b334: e5d03012 ldrb r3, [r0, #18] <== NOT EXECUTED
info->maximum = obj_info->maximum;
3000b338: e5841008 str r1, [r4, #8] <== NOT EXECUTED
/* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend;
3000b33c: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000b340: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b344: ea000004 b 3000b35c <rtems_object_get_class_information+0x64><== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000b348: e590c01c ldr ip, [r0, #28] <== NOT EXECUTED 3000b34c: e79cc103 ldr ip, [ip, r3, lsl #2] <== NOT EXECUTED
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000b350: e2833001 add r3, r3, #1 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000b354: e35c0000 cmp ip, #0 <== NOT EXECUTED
unallocated++;
3000b358: 02822001 addeq r2, r2, #1 <== NOT EXECUTED
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000b35c: e1530001 cmp r3, r1 <== NOT EXECUTED 3000b360: 9afffff8 bls 3000b348 <rtems_object_get_class_information+0x50><== NOT EXECUTED
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
3000b364: e5842010 str r2, [r4, #16] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b368: e3a00000 mov r0, #0 <== NOT EXECUTED
3000b36c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( !info )
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
if ( !obj_info )
return RTEMS_INVALID_NUMBER;
3000b370: e3a0000a mov r0, #10 <== NOT EXECUTED
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
3000b374: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a60c <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
3000a60c: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
3000a610: e2514000 subs r4, r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000a614: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
3000a618: 0a000005 beq 3000a634 <rtems_object_get_classic_name+0x28> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
3000a61c: e1a0100d mov r1, sp <== NOT EXECUTED 3000a620: eb0006a9 bl 3000c0cc <_Objects_Id_to_name> <== NOT EXECUTED
*name = name_u.name_u32;
3000a624: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a628: e5843000 str r3, [r4] <== NOT EXECUTED
return _Status_Object_name_errors_to_status[ status ];
3000a62c: e59f3004 ldr r3, [pc, #4] ; 3000a638 <rtems_object_get_classic_name+0x2c><== NOT EXECUTED 3000a630: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
}
3000a634: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000a8f4 <rtems_object_get_name>:
Objects_Id id,
size_t length,
char *name
)
{
return _Objects_Get_name_as_string( id, length, name );
3000a8f4: ea000733 b 3000c5c8 <_Objects_Get_name_as_string> <== NOT EXECUTED
3000b37c <rtems_object_id_api_maximum>:
#undef rtems_object_id_api_maximum
int rtems_object_id_api_maximum(void)
{
return OBJECTS_APIS_LAST;
}
3000b37c: e3a00003 mov r0, #3 <== NOT EXECUTED 3000b380: e12fff1e bx lr <== NOT EXECUTED
3000b384 <rtems_object_id_api_minimum>:
#undef rtems_object_id_api_minimum
int rtems_object_id_api_minimum(void)
{
return OBJECTS_INTERNAL_API;
}
3000b384: e3a00001 mov r0, #1 <== NOT EXECUTED 3000b388: e12fff1e bx lr <== NOT EXECUTED
3000b38c <rtems_object_id_get_api>:
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
3000b38c: e1a00c20 lsr r0, r0, #24 <== NOT EXECUTED
int rtems_object_id_get_api(
rtems_id id
)
{
return _Objects_Get_API( id );
}
3000b390: e2000007 and r0, r0, #7 <== NOT EXECUTED 3000b394: e12fff1e bx lr <== NOT EXECUTED
3000b398 <rtems_object_id_get_class>:
int rtems_object_id_get_class(
rtems_id id
)
{
return _Objects_Get_class( id );
}
3000b398: e1a00da0 lsr r0, r0, #27 <== NOT EXECUTED 3000b39c: e12fff1e bx lr <== NOT EXECUTED
3000b3a0 <rtems_object_id_get_index>:
#undef rtems_object_id_get_index
int rtems_object_id_get_index(
rtems_id id
)
{
return _Objects_Get_index( id );
3000b3a0: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
}
3000b3a4: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 3000b3a8: e12fff1e bx lr <== NOT EXECUTED
3000b3ac <rtems_object_id_get_node>:
* be a single processor system.
*/
#if defined(RTEMS_USE_16_BIT_OBJECT)
return 1;
#else
return (id >> OBJECTS_NODE_START_BIT) & OBJECTS_NODE_VALID_BITS;
3000b3ac: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED
int rtems_object_id_get_node(
rtems_id id
)
{
return _Objects_Get_node( id );
}
3000b3b0: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 3000b3b4: e12fff1e bx lr <== NOT EXECUTED
3000b3b8 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
3000b3b8: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
3000b3bc: e2515000 subs r5, r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000b3c0: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
3000b3c4: 0a000016 beq 3000b424 <rtems_object_set_name+0x6c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000b3c8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b3cc: 059f3054 ldreq r3, [pc, #84] ; 3000b428 <rtems_object_set_name+0x70><== NOT EXECUTED 3000b3d0: 11a04000 movne r4, r0 <== NOT EXECUTED 3000b3d4: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000b3d8: 05934008 ldreq r4, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3000b3dc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b3e0: eb000647 bl 3000cd04 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
3000b3e4: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000b3e8: 0a00000c beq 3000b420 <rtems_object_set_name+0x68> <== NOT EXECUTED
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
3000b3ec: e1a01004 mov r1, r4 <== NOT EXECUTED 3000b3f0: e1a0200d mov r2, sp <== NOT EXECUTED 3000b3f4: eb0006b2 bl 3000cec4 <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3000b3f8: e59d4000 ldr r4, [sp] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
if ( !information )
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
3000b3fc: e1a01000 mov r1, r0 <== NOT EXECUTED
switch ( location ) {
3000b400: e3540000 cmp r4, #0 <== NOT EXECUTED 3000b404: 1a000005 bne 3000b420 <rtems_object_set_name+0x68> <== NOT EXECUTED
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
3000b408: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b40c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b410: eb00071a bl 3000d080 <_Objects_Set_name> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b414: eb0009dd bl 3000db90 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b418: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b41c: ea000000 b 3000b424 <rtems_object_set_name+0x6c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000b420: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3000b424: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000a9a8 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
3000a9a8: e92d000f push {r0, r1, r2, r3} <== NOT EXECUTED
3000a9ac: e92d4001 push {r0, lr} <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
3000a9b0: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
3000a9b4: e28d200c add r2, sp, #12 <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
3000a9b8: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
3000a9bc: e58d2000 str r2, [sp] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
3000a9c0: ebffff84 bl 3000a7d8 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
rtems_error(0, "fatal error, exiting");
3000a9c4: e59f1010 ldr r1, [pc, #16] ; 3000a9dc <rtems_panic+0x34> <== NOT EXECUTED 3000a9c8: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a9cc: ebffffdb bl 3000a940 <rtems_error> <== NOT EXECUTED
_exit(errno);
3000a9d0: eb002a67 bl 30015374 <__errno> <== NOT EXECUTED 3000a9d4: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000a9d8: eb000284 bl 3000b3f0 <_exit> <== NOT EXECUTED
300161b8 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
300161b8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
300161bc: e2508000 subs r8, r0, #0
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
300161c0: e1a05001 mov r5, r1 300161c4: e1a09002 mov r9, r2 300161c8: e1a0a003 mov sl, r3
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
300161cc: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
300161d0: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_NAME;
if ( !starting_address )
300161d4: e3510000 cmp r1, #0
300161d8: 0a000030 beq 300162a0 <rtems_partition_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( !id )
300161dc: e59d2028 ldr r2, [sp, #40] ; 0x28 300161e0: e3520000 cmp r2, #0
300161e4: 0a00002d beq 300162a0 <rtems_partition_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
300161e8: e3590000 cmp r9, #0 300161ec: 13530000 cmpne r3, #0
300161f0: 0a00002c beq 300162a8 <rtems_partition_create+0xf0>
300161f4: e1590003 cmp r9, r3
300161f8: 3a00002a bcc 300162a8 <rtems_partition_create+0xf0>
300161fc: e3130007 tst r3, #7
30016200: 1a000028 bne 300162a8 <rtems_partition_create+0xf0>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
30016204: e2116007 ands r6, r1, #7
30016208: 1a000028 bne 300162b0 <rtems_partition_create+0xf8>
3001620c: e59f30a4 ldr r3, [pc, #164] ; 300162b8 <rtems_partition_create+0x100> 30016210: e5932000 ldr r2, [r3] 30016214: e2822001 add r2, r2, #1 30016218: e5832000 str r2, [r3]
* This function allocates a partition control block from
* the inactive chain of free partition control blocks.
*/
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
3001621c: e59f7098 ldr r7, [pc, #152] ; 300162bc <rtems_partition_create+0x104> 30016220: e1a00007 mov r0, r7 30016224: eb00118b bl 3001a858 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
30016228: e2504000 subs r4, r0, #0
3001622c: 1a000002 bne 3001623c <rtems_partition_create+0x84>
_Thread_Enable_dispatch();
30016230: eb0015ce bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30016234: e3a00005 mov r0, #5 <== NOT EXECUTED
30016238: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
3001623c: e59d3024 ldr r3, [sp, #36] ; 0x24
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
30016240: e1a0100a mov r1, sl
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
30016244: e584301c str r3, [r4, #28]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
30016248: e5845010 str r5, [r4, #16]
the_partition->length = length;
3001624c: e5849014 str r9, [r4, #20]
the_partition->buffer_size = buffer_size;
30016250: e584a018 str sl, [r4, #24]
the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0;
30016254: e5846020 str r6, [r4, #32]
_Chain_Initialize( &the_partition->Memory, starting_address,
30016258: e1a00009 mov r0, r9 3001625c: eb005d87 bl 3002d880 <__aeabi_uidiv> 30016260: e284b024 add fp, r4, #36 ; 0x24 30016264: e1a02000 mov r2, r0 30016268: e1a01005 mov r1, r5 3001626c: e1a0000b mov r0, fp 30016270: e1a0300a mov r3, sl 30016274: eb000bcc bl 300191ac <_Chain_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30016278: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3001627c: e1d410b8 ldrh r1, [r4, #8] 30016280: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30016284: e7824101 str r4, [r2, r1, lsl #2]
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
30016288: e59d2028 ldr r2, [sp, #40] ; 0x28
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3001628c: e584800c str r8, [r4, #12] 30016290: e5823000 str r3, [r2]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
30016294: eb0015b5 bl 3001b970 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30016298: e1a00006 mov r0, r6
3001629c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
300162a0: e3a00009 mov r0, #9 <== NOT EXECUTED
300162a4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
300162a8: e3a00008 mov r0, #8 <== NOT EXECUTED
300162ac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
300162b0: e3a00009 mov r0, #9 <== NOT EXECUTED
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
300162b4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
300162c0 <rtems_partition_delete>:
*/
rtems_status_code rtems_partition_delete(
rtems_id id
)
{
300162c0: e92d4031 push {r0, r4, r5, lr}
300162c4: e1a01000 mov r1, r0
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
300162c8: e1a0200d mov r2, sp 300162cc: e59f0050 ldr r0, [pc, #80] ; 30016324 <rtems_partition_delete+0x64> 300162d0: eb00128c bl 3001ad08 <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
300162d4: e59d3000 ldr r3, [sp] 300162d8: e1a04000 mov r4, r0 300162dc: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300162e0: 13a00004 movne r0, #4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
300162e4: 1a00000d bne 30016320 <rtems_partition_delete+0x60>
case OBJECTS_LOCAL:
if ( the_partition->number_of_used_blocks == 0 ) {
300162e8: e5945020 ldr r5, [r4, #32] 300162ec: e3550000 cmp r5, #0
300162f0: 1a000008 bne 30016318 <rtems_partition_delete+0x58>
_Objects_Close( &_Partition_Information, &the_partition->Object );
300162f4: e59f0028 ldr r0, [pc, #40] ; 30016324 <rtems_partition_delete+0x64> 300162f8: e1a01004 mov r1, r4 300162fc: eb001177 bl 3001a8e0 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Partition_Free (
Partition_Control *the_partition
)
{
_Objects_Free( &_Partition_Information, &the_partition->Object );
30016300: e59f001c ldr r0, [pc, #28] ; 30016324 <rtems_partition_delete+0x64> 30016304: e1a01004 mov r1, r4 30016308: eb001219 bl 3001ab74 <_Objects_Free>
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
3001630c: eb001597 bl 3001b970 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30016310: e1a00005 mov r0, r5 30016314: ea000001 b 30016320 <rtems_partition_delete+0x60>
}
_Thread_Enable_dispatch();
30016318: eb001594 bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
3001631c: e3a0000c mov r0, #12 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30016320: e8bd8038 pop {r3, r4, r5, pc}
300163d0 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
300163d0: e92d4071 push {r0, r4, r5, r6, lr}
300163d4: e1a03000 mov r3, r0
300163d8: e1a04001 mov r4, r1
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
300163dc: e59f0088 ldr r0, [pc, #136] ; 3001646c <rtems_partition_return_buffer+0x9c> 300163e0: e1a01003 mov r1, r3 300163e4: e1a0200d mov r2, sp 300163e8: eb001246 bl 3001ad08 <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
300163ec: e59d3000 ldr r3, [sp] 300163f0: e1a05000 mov r5, r0 300163f4: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300163f8: 13a00004 movne r0, #4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
300163fc: 1a000016 bne 3001645c <rtems_partition_return_buffer+0x8c>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
30016400: e5950010 ldr r0, [r5, #16] 30016404: e5953014 ldr r3, [r5, #20] 30016408: e0803003 add r3, r0, r3
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
3001640c: e1540003 cmp r4, r3 30016410: 83a03000 movhi r3, #0 30016414: 93a03001 movls r3, #1 30016418: e1540000 cmp r4, r0 3001641c: 33a03000 movcc r3, #0
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
30016420: e3530000 cmp r3, #0
30016424: 0a00000d beq 30016460 <rtems_partition_return_buffer+0x90>
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
30016428: e0600004 rsb r0, r0, r4 3001642c: e5951018 ldr r1, [r5, #24] 30016430: eb005daa bl 3002dae0 <__umodsi3>
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
30016434: e2506000 subs r6, r0, #0
30016438: 1a000008 bne 30016460 <rtems_partition_return_buffer+0x90>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
3001643c: e2850024 add r0, r5, #36 ; 0x24 30016440: e1a01004 mov r1, r4 30016444: eb000b38 bl 3001912c <_Chain_Append>
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
30016448: e5953020 ldr r3, [r5, #32] 3001644c: e2433001 sub r3, r3, #1 30016450: e5853020 str r3, [r5, #32]
_Thread_Enable_dispatch();
30016454: eb001545 bl 3001b970 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30016458: e1a00006 mov r0, r6
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001645c: e8bd8078 pop {r3, r4, r5, r6, pc}
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
30016460: eb001542 bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30016464: e3a00009 mov r0, #9 <== NOT EXECUTED 30016468: eafffffb b 3001645c <rtems_partition_return_buffer+0x8c> <== NOT EXECUTED
30015820 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
30015820: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
30015824: e250a000 subs sl, r0, #0
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
30015828: e1a04001 mov r4, r1 3001582c: e1a05002 mov r5, r2 30015830: e1a09003 mov r9, r3 30015834: e59d6020 ldr r6, [sp, #32]
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30015838: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
3001583c: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
return RTEMS_INVALID_NAME;
if ( !id )
30015840: e3560000 cmp r6, #0
return RTEMS_INVALID_ADDRESS;
30015844: 03a00009 moveq r0, #9
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30015848: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
* id - port id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_port_create(
3001584c: e1828001 orr r8, r2, r1
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
30015850: e2188007 ands r8, r8, #7
30015854: 1a000018 bne 300158bc <rtems_port_create+0x9c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30015858: e59f3064 ldr r3, [pc, #100] ; 300158c4 <rtems_port_create+0xa4> 3001585c: e5932000 ldr r2, [r3] 30015860: e2822001 add r2, r2, #1 30015864: e5832000 str r2, [r3]
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
_Objects_Allocate( &_Dual_ported_memory_Information );
30015868: e59f7058 ldr r7, [pc, #88] ; 300158c8 <rtems_port_create+0xa8> 3001586c: e1a00007 mov r0, r7 30015870: eb0013f8 bl 3001a858 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
30015874: e3500000 cmp r0, #0
30015878: 1a000002 bne 30015888 <rtems_port_create+0x68>
_Thread_Enable_dispatch();
3001587c: eb00183b bl 3001b970 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
30015880: e3a00005 mov r0, #5
30015884: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30015888: e5903008 ldr r3, [r0, #8] 3001588c: e1d010b8 ldrh r1, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30015890: e597201c ldr r2, [r7, #28]
}
the_port->internal_base = internal_start;
the_port->external_base = external_start;
the_port->length = length - 1;
30015894: e2499001 sub r9, r9, #1
if ( !the_port ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
30015898: e5804010 str r4, [r0, #16]
the_port->external_base = external_start;
3001589c: e5805014 str r5, [r0, #20]
the_port->length = length - 1;
300158a0: e5809018 str r9, [r0, #24] 300158a4: e7820101 str r0, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300158a8: e580a00c str sl, [r0, #12]
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
300158ac: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
300158b0: eb00182e bl 3001b970 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300158b4: e1a00008 mov r0, r8
300158b8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
!_Addresses_Is_aligned( external_start ) )
return RTEMS_INVALID_ADDRESS;
300158bc: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
300158c0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
30005b0c <rtems_print_buffer>:
)
{
int i, mod, max;
if ( !length ) return;
30005b0c: e3510000 cmp r1, #0 <== NOT EXECUTED
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
30005b10: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
30005b14: e1a07000 mov r7, r0 <== NOT EXECUTED
int i, mod, max;
if ( !length ) return;
30005b18: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
mod = length % 16;
30005b1c: e211413e ands r4, r1, #-2147483633 ; 0x8000000f <== NOT EXECUTED 30005b20: 42444001 submi r4, r4, #1 <== NOT EXECUTED 30005b24: 41e04e04 mvnmi r4, r4, lsl #28 <== NOT EXECUTED 30005b28: 41e04e24 mvnmi r4, r4, lsr #28 <== NOT EXECUTED 30005b2c: 42844001 addmi r4, r4, #1 <== NOT EXECUTED
max = length - mod;
30005b30: e0646001 rsb r6, r4, r1 <== NOT EXECUTED
for ( i=0 ; i<max ; i+=16 )
30005b34: e3a05000 mov r5, #0 <== NOT EXECUTED 30005b38: ea000003 b 30005b4c <rtems_print_buffer+0x40> <== NOT EXECUTED
Dump_Line( &buffer[ i ], 16 );
30005b3c: e0870005 add r0, r7, r5 <== NOT EXECUTED 30005b40: e3a01010 mov r1, #16 <== NOT EXECUTED 30005b44: ebffffae bl 30005a04 <Dump_Line> <== NOT EXECUTED
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
30005b48: e2855010 add r5, r5, #16 <== NOT EXECUTED 30005b4c: e1550006 cmp r5, r6 <== NOT EXECUTED 30005b50: bafffff9 blt 30005b3c <rtems_print_buffer+0x30> <== NOT EXECUTED
Dump_Line( &buffer[ i ], 16 );
if ( mod )
30005b54: e3540000 cmp r4, #0 <== NOT EXECUTED
30005b58: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
Dump_Line( &buffer[ max ], mod );
30005b5c: e0870006 add r0, r7, r6 <== NOT EXECUTED 30005b60: e1a01004 mov r1, r4 <== NOT EXECUTED
}
30005b64: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
for ( i=0 ; i<max ; i+=16 )
Dump_Line( &buffer[ i ], 16 );
if ( mod )
Dump_Line( &buffer[ max ], mod );
30005b68: eaffffa5 b 30005a04 <Dump_Line> <== NOT EXECUTED
30016470 <rtems_rate_monotonic_cancel>:
*/
rtems_status_code rtems_rate_monotonic_cancel(
rtems_id id
)
{
30016470: e92d4031 push {r0, r4, r5, lr}
30016474: e1a01000 mov r1, r0
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
30016478: e1a0200d mov r2, sp 3001647c: e59f004c ldr r0, [pc, #76] ; 300164d0 <rtems_rate_monotonic_cancel+0x60> 30016480: eb001220 bl 3001ad08 <_Objects_Get>
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30016484: e59d4000 ldr r4, [sp] 30016488: e1a05000 mov r5, r0 3001648c: e3540000 cmp r4, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30016490: 13a00004 movne r0, #4
{
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30016494: 1a00000c bne 300164cc <rtems_rate_monotonic_cancel+0x5c>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
30016498: e59f3034 ldr r3, [pc, #52] ; 300164d4 <rtems_rate_monotonic_cancel+0x64> 3001649c: e5952040 ldr r2, [r5, #64] ; 0x40 300164a0: e5933004 ldr r3, [r3, #4] 300164a4: e1520003 cmp r2, r3
300164a8: 0a000002 beq 300164b8 <rtems_rate_monotonic_cancel+0x48>
_Thread_Enable_dispatch();
300164ac: eb00152f bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
300164b0: e3a00017 mov r0, #23 <== NOT EXECUTED 300164b4: ea000004 b 300164cc <rtems_rate_monotonic_cancel+0x5c> <== NOT EXECUTED
}
(void) _Watchdog_Remove( &the_period->Timer );
300164b8: e2850010 add r0, r5, #16 300164bc: eb00196f bl 3001ca80 <_Watchdog_Remove>
the_period->state = RATE_MONOTONIC_INACTIVE;
300164c0: e5854038 str r4, [r5, #56] ; 0x38
_Thread_Enable_dispatch();
300164c4: eb001529 bl 3001b970 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300164c8: e1a00004 mov r0, r4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300164cc: e8bd8038 pop {r3, r4, r5, pc}
3000a23c <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000a23c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000a240: e2508000 subs r8, r0, #0
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000a244: e1a06001 mov r6, r1
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000a248: 03a00003 moveq r0, #3
rtems_id *id
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000a24c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_NAME;
if ( !id )
3000a250: e3510000 cmp r1, #0
3000a254: 0a000026 beq 3000a2f4 <rtems_rate_monotonic_create+0xb8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000a258: e59f309c ldr r3, [pc, #156] ; 3000a2fc <rtems_rate_monotonic_create+0xc0> 3000a25c: e5932000 ldr r2, [r3] 3000a260: e2822001 add r2, r2, #1 3000a264: e5832000 str r2, [r3]
* the inactive chain of free period control blocks.
*/
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
{
return (Rate_monotonic_Control *)
_Objects_Allocate( &_Rate_monotonic_Information );
3000a268: e59f7090 ldr r7, [pc, #144] ; 3000a300 <rtems_rate_monotonic_create+0xc4> 3000a26c: e1a00007 mov r0, r7 3000a270: eb000795 bl 3000c0cc <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
3000a274: e2504000 subs r4, r0, #0
3000a278: 1a000002 bne 3000a288 <rtems_rate_monotonic_create+0x4c>
_Thread_Enable_dispatch();
3000a27c: eb000c00 bl 3000d284 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000a280: e3a00005 mov r0, #5 <== NOT EXECUTED
3000a284: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
the_period->owner = _Thread_Executing;
3000a288: e59f3074 ldr r3, [pc, #116] ; 3000a304 <rtems_rate_monotonic_create+0xc8>
the_period->state = RATE_MONOTONIC_INACTIVE;
3000a28c: e3a05000 mov r5, #0
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000a290: e5933004 ldr r3, [r3, #4]
the_period->state = RATE_MONOTONIC_INACTIVE;
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000a294: e1a01005 mov r1, r5
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000a298: e5843040 str r3, [r4, #64] ; 0x40
the_period->state = RATE_MONOTONIC_INACTIVE;
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000a29c: e3a02038 mov r2, #56 ; 0x38
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
the_period->state = RATE_MONOTONIC_INACTIVE;
3000a2a0: e5845038 str r5, [r4, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a2a4: e5845018 str r5, [r4, #24]
the_watchdog->routine = routine;
3000a2a8: e584502c str r5, [r4, #44] ; 0x2c
the_watchdog->id = id;
3000a2ac: e5845030 str r5, [r4, #48] ; 0x30
the_watchdog->user_data = user_data;
3000a2b0: e5845034 str r5, [r4, #52] ; 0x34
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000a2b4: e2840054 add r0, r4, #84 ; 0x54 3000a2b8: eb002164 bl 30012850 <memset> 3000a2bc: e3e03102 mvn r3, #-2147483648 ; 0x80000000 3000a2c0: e584305c str r3, [r4, #92] ; 0x5c 3000a2c4: e5843060 str r3, [r4, #96] ; 0x60 3000a2c8: e5843074 str r3, [r4, #116] ; 0x74 3000a2cc: e5843078 str r3, [r4, #120] ; 0x78
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a2d0: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000a2d4: e5943008 ldr r3, [r4, #8] 3000a2d8: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a2dc: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000a2e0: e584800c str r8, [r4, #12]
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
3000a2e4: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
3000a2e8: eb000be5 bl 3000d284 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a2ec: e1a00005 mov r0, r5
3000a2f0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000a2f4: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000a2f8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000fd18 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
3000fd18: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
3000fd1c: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
3000fd20: e1a03000 mov r3, r0 <== NOT EXECUTED
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
3000fd24: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
3000fd28: 0a000025 beq 3000fdc4 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED 3000fd2c: e59f0094 ldr r0, [pc, #148] ; 3000fdc8 <rtems_rate_monotonic_get_statistics+0xb0><== NOT EXECUTED 3000fd30: e1a01003 mov r1, r3 <== NOT EXECUTED 3000fd34: e1a0200d mov r2, sp <== NOT EXECUTED 3000fd38: ebfff237 bl 3000c61c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000fd3c: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000fd40: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000fd44: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000fd48: 1a00001d bne 3000fdc4 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
3000fd4c: e5903054 ldr r3, [r0, #84] ; 0x54 <== NOT EXECUTED 3000fd50: e5843000 str r3, [r4] <== NOT EXECUTED
dst->missed_count = src->missed_count;
3000fd54: e5903058 ldr r3, [r0, #88] ; 0x58 <== NOT EXECUTED 3000fd58: e5843004 str r3, [r4, #4] <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
3000fd5c: e280305c add r3, r0, #92 ; 0x5c <== NOT EXECUTED
3000fd60: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000fd64: e5842008 str r2, [r4, #8] <== NOT EXECUTED
3000fd68: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
3000fd6c: e2803064 add r3, r0, #100 ; 0x64 <== NOT EXECUTED
3000fd70: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000fd74: e5842010 str r2, [r4, #16] <== NOT EXECUTED
3000fd78: e5843014 str r3, [r4, #20] <== NOT EXECUTED
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
3000fd7c: e280306c add r3, r0, #108 ; 0x6c <== NOT EXECUTED
3000fd80: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000fd84: e5842018 str r2, [r4, #24] <== NOT EXECUTED
3000fd88: e584301c str r3, [r4, #28] <== NOT EXECUTED
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
3000fd8c: e2803074 add r3, r0, #116 ; 0x74 <== NOT EXECUTED
3000fd90: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000fd94: e5842020 str r2, [r4, #32] <== NOT EXECUTED
3000fd98: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
3000fd9c: e280307c add r3, r0, #124 ; 0x7c <== NOT EXECUTED
3000fda0: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000fda4: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED
3000fda8: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
3000fdac: e2803084 add r3, r0, #132 ; 0x84 <== NOT EXECUTED
3000fdb0: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000fdb4: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED
3000fdb8: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
dst->min_wall_time = src->min_wall_time;
dst->max_wall_time = src->max_wall_time;
dst->total_wall_time = src->total_wall_time;
#endif
_Thread_Enable_dispatch();
3000fdbc: ebfff530 bl 3000d284 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000fdc0: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000fdc4: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000fdcc <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
3000fdcc: e92d4010 push {r4, lr} <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
3000fdd0: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
3000fdd4: e1a03000 mov r3, r0 <== NOT EXECUTED 3000fdd8: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
return RTEMS_INVALID_ADDRESS;
3000fddc: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
3000fde0: 0a000023 beq 3000fe74 <rtems_rate_monotonic_get_status+0xa8><== NOT EXECUTED 3000fde4: e1a01003 mov r1, r3 <== NOT EXECUTED 3000fde8: e28d2010 add r2, sp, #16 <== NOT EXECUTED 3000fdec: e59f0088 ldr r0, [pc, #136] ; 3000fe7c <rtems_rate_monotonic_get_status+0xb0><== NOT EXECUTED 3000fdf0: ebfff209 bl 3000c61c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000fdf4: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000fdf8: e1a03000 mov r3, r0 <== NOT EXECUTED 3000fdfc: e3520000 cmp r2, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000fe00: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !status )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000fe04: 1a00001a bne 3000fe74 <rtems_rate_monotonic_get_status+0xa8><== NOT EXECUTED
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
3000fe08: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED
status->state = the_period->state;
3000fe0c: e5933038 ldr r3, [r3, #56] ; 0x38 <== NOT EXECUTED
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
3000fe10: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED
status->state = the_period->state;
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
3000fe14: e3530000 cmp r3, #0 <== NOT EXECUTED
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
3000fe18: e884000c stm r4, {r2, r3} <== NOT EXECUTED
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
3000fe1c: 05843008 streq r3, [r4, #8] <== NOT EXECUTED 3000fe20: 0584300c streq r3, [r4, #12] <== NOT EXECUTED
_Timespec_Set_to_zero( &status->executed_since_last_period );
3000fe24: 05843010 streq r3, [r4, #16] <== NOT EXECUTED 3000fe28: 05843014 streq r3, [r4, #20] <== NOT EXECUTED 3000fe2c: 0a00000e beq 3000fe6c <rtems_rate_monotonic_get_status+0xa0><== NOT EXECUTED
} else {
/*
* Grab the current status.
*/
valid_status =
3000fe30: e1a0100d mov r1, sp <== NOT EXECUTED 3000fe34: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000fe38: ebffe93e bl 3000a338 <_Rate_monotonic_Get_status> <== NOT EXECUTED
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
3000fe3c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fe40: 1a000002 bne 3000fe50 <rtems_rate_monotonic_get_status+0x84><== NOT EXECUTED
_Thread_Enable_dispatch();
3000fe44: ebfff50e bl 3000d284 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
3000fe48: e3a0000b mov r0, #11 <== NOT EXECUTED 3000fe4c: ea000008 b 3000fe74 <rtems_rate_monotonic_get_status+0xa8> <== NOT EXECUTED
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
3000fe50: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
3000fe54: e5842008 str r2, [r4, #8] <== NOT EXECUTED
3000fe58: e584300c str r3, [r4, #12] <== NOT EXECUTED
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
3000fe5c: e28d3008 add r3, sp, #8 <== NOT EXECUTED
3000fe60: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000fe64: e5842010 str r2, [r4, #16] <== NOT EXECUTED
3000fe68: e5843014 str r3, [r4, #20] <== NOT EXECUTED
status->since_last_period = since_last_period;
status->executed_since_last_period = executed;
#endif
}
_Thread_Enable_dispatch();
3000fe6c: ebfff504 bl 3000d284 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000fe70: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000fe74: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000fe78: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a53c <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
3000a53c: e92d40f1 push {r0, r4, r5, r6, r7, lr}
3000a540: e1a05000 mov r5, r0
3000a544: e1a04001 mov r4, r1
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
3000a548: e59f016c ldr r0, [pc, #364] ; 3000a6bc <rtems_rate_monotonic_period+0x180> 3000a54c: e1a01005 mov r1, r5 3000a550: e1a0200d mov r2, sp 3000a554: eb000830 bl 3000c61c <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000a558: e59d3000 ldr r3, [sp] 3000a55c: e1a06000 mov r6, r0 3000a560: e3530000 cmp r3, #0
3000a564: 1a000051 bne 3000a6b0 <rtems_rate_monotonic_period+0x174>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
3000a568: e59f3150 ldr r3, [pc, #336] ; 3000a6c0 <rtems_rate_monotonic_period+0x184> 3000a56c: e5902040 ldr r2, [r0, #64] ; 0x40 3000a570: e5933004 ldr r3, [r3, #4] 3000a574: e1520003 cmp r2, r3
3000a578: 0a000002 beq 3000a588 <rtems_rate_monotonic_period+0x4c>
_Thread_Enable_dispatch();
3000a57c: eb000b40 bl 3000d284 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
3000a580: e3a04017 mov r4, #23 <== NOT EXECUTED 3000a584: ea00004a b 3000a6b4 <rtems_rate_monotonic_period+0x178> <== NOT EXECUTED
}
if ( length == RTEMS_PERIOD_STATUS ) {
3000a588: e3540000 cmp r4, #0
3000a58c: 1a000005 bne 3000a5a8 <rtems_rate_monotonic_period+0x6c>
switch ( the_period->state ) {
3000a590: e5903038 ldr r3, [r0, #56] ; 0x38 3000a594: e3530004 cmp r3, #4 3000a598: 959f2124 ldrls r2, [pc, #292] ; 3000a6c4 <rtems_rate_monotonic_period+0x188> 3000a59c: 97924103 ldrls r4, [r2, r3, lsl #2]
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
3000a5a0: eb000b37 bl 3000d284 <_Thread_Enable_dispatch>
return( return_value );
3000a5a4: ea000042 b 3000a6b4 <rtems_rate_monotonic_period+0x178>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a5a8: e10f7000 mrs r7, CPSR 3000a5ac: e3873080 orr r3, r7, #128 ; 0x80 3000a5b0: e129f003 msr CPSR_fc, r3
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
3000a5b4: e5903038 ldr r3, [r0, #56] ; 0x38 3000a5b8: e3530000 cmp r3, #0
3000a5bc: 1a000011 bne 3000a608 <rtems_rate_monotonic_period+0xcc>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a5c0: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
3000a5c4: ebffff89 bl 3000a3f0 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
3000a5c8: e3a03002 mov r3, #2 3000a5cc: e5863038 str r3, [r6, #56] ; 0x38
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000a5d0: e59f30f0 ldr r3, [pc, #240] ; 3000a6c8 <rtems_rate_monotonic_period+0x18c>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a5d4: e3a07000 mov r7, #0
the_watchdog->routine = routine;
3000a5d8: e586302c str r3, [r6, #44] ; 0x2c
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
3000a5dc: e586403c str r4, [r6, #60] ; 0x3c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a5e0: e586401c str r4, [r6, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a5e4: e59f00e0 ldr r0, [pc, #224] ; 3000a6cc <rtems_rate_monotonic_period+0x190> 3000a5e8: e2861010 add r1, r6, #16
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a5ec: e5867018 str r7, [r6, #24]
the_watchdog->routine = routine; the_watchdog->id = id;
3000a5f0: e5865030 str r5, [r6, #48] ; 0x30
the_watchdog->user_data = user_data;
3000a5f4: e5867034 str r7, [r6, #52] ; 0x34
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a5f8: eb000eac bl 3000e0b0 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
3000a5fc: e1a04007 mov r4, r7
);
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
3000a600: eb000b1f bl 3000d284 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a604: ea00002a b 3000a6b4 <rtems_rate_monotonic_period+0x178>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
3000a608: e3530002 cmp r3, #2
3000a60c: 1a000019 bne 3000a678 <rtems_rate_monotonic_period+0x13c>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
3000a610: ebffff93 bl 3000a464 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
3000a614: e3a03001 mov r3, #1 3000a618: e5863038 str r3, [r6, #56] ; 0x38
the_period->next_length = length;
3000a61c: e586403c str r4, [r6, #60] ; 0x3c 3000a620: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
3000a624: e59f3094 ldr r3, [pc, #148] ; 3000a6c0 <rtems_rate_monotonic_period+0x184>
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
3000a628: e3a01901 mov r1, #16384 ; 0x4000
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
3000a62c: e5930004 ldr r0, [r3, #4] 3000a630: e5963008 ldr r3, [r6, #8] 3000a634: e5803020 str r3, [r0, #32]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
3000a638: eb000d14 bl 3000da90 <_Thread_Set_state>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a63c: e10f2000 mrs r2, CPSR 3000a640: e3823080 orr r3, r2, #128 ; 0x80 3000a644: e129f003 msr CPSR_fc, r3
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
3000a648: e3a01002 mov r1, #2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
3000a64c: e5963038 ldr r3, [r6, #56] ; 0x38
the_period->state = RATE_MONOTONIC_ACTIVE;
3000a650: e5861038 str r1, [r6, #56] ; 0x38
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a654: e129f002 msr CPSR_fc, r2
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
3000a658: e3530003 cmp r3, #3
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
3000a65c: 059f305c ldreq r3, [pc, #92] ; 3000a6c0 <rtems_rate_monotonic_period+0x184> 3000a660: 03a01901 moveq r1, #16384 ; 0x4000 3000a664: 05930004 ldreq r0, [r3, #4] 3000a668: 0b000a40 bleq 3000cf70 <_Thread_Clear_state>
_Thread_Enable_dispatch();
3000a66c: eb000b04 bl 3000d284 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a670: e3a04000 mov r4, #0 <== NOT EXECUTED 3000a674: ea00000e b 3000a6b4 <rtems_rate_monotonic_period+0x178> <== NOT EXECUTED
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
3000a678: e3530004 cmp r3, #4 <== NOT EXECUTED 3000a67c: 1a00000b bne 3000a6b0 <rtems_rate_monotonic_period+0x174> <== NOT EXECUTED
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
3000a680: ebffff77 bl 3000a464 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED 3000a684: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
3000a688: e3a03002 mov r3, #2 <== NOT EXECUTED 3000a68c: e5863038 str r3, [r6, #56] ; 0x38 <== NOT EXECUTED
the_period->next_length = length;
3000a690: e586403c str r4, [r6, #60] ; 0x3c <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a694: e586401c str r4, [r6, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a698: e59f002c ldr r0, [pc, #44] ; 3000a6cc <rtems_rate_monotonic_period+0x190><== NOT EXECUTED 3000a69c: e2861010 add r1, r6, #16 <== NOT EXECUTED 3000a6a0: eb000e82 bl 3000e0b0 <_Watchdog_Insert> <== NOT EXECUTED
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
3000a6a4: e3a04006 mov r4, #6 <== NOT EXECUTED
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
3000a6a8: eb000af5 bl 3000d284 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TIMEOUT;
3000a6ac: ea000000 b 3000a6b4 <rtems_rate_monotonic_period+0x178> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a6b0: e3a04004 mov r4, #4 <== NOT EXECUTED
}
3000a6b4: e1a00004 mov r0, r4
3000a6b8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
3000a8dc <rtems_rate_monotonic_report_statistics>:
void rtems_rate_monotonic_report_statistics( void )
{
rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin );
3000a8dc: e59f1004 ldr r1, [pc, #4] ; 3000a8e8 <rtems_rate_monotonic_report_statistics+0xc><== NOT EXECUTED 3000a8e0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a8e4: eaffff79 b 3000a6d0 <rtems_rate_monotonic_report_statistics_with_plugin><== NOT EXECUTED
3000a6d0 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a6d0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
3000a6d4: e2514000 subs r4, r1, #0 <== NOT EXECUTED
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a6d8: e24dd078 sub sp, sp, #120 ; 0x78 <== NOT EXECUTED 3000a6dc: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
3000a6e0: 0a000071 beq 3000a8ac <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NOT EXECUTED
return;
(*print)( context, "Period information by period\n" );
3000a6e4: e59f11c8 ldr r1, [pc, #456] ; 3000a8b4 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e4><== NOT EXECUTED 3000a6e8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a6ec: e12fff14 bx r4 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
3000a6f0: e59f11c0 ldr r1, [pc, #448] ; 3000a8b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e8><== NOT EXECUTED 3000a6f4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a6f8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a6fc: e12fff14 bx r4 <== NOT EXECUTED
(*print)( context, "--- Wall times are in seconds ---\n" );
3000a700: e59f11b4 ldr r1, [pc, #436] ; 3000a8bc <rtems_rate_monotonic_report_statistics_with_plugin+0x1ec><== NOT EXECUTED 3000a704: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a708: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a70c: e12fff14 bx r4 <== NOT EXECUTED
Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED "
3000a710: e59f11a8 ldr r1, [pc, #424] ; 3000a8c0 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f0><== NOT EXECUTED 3000a714: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a718: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a71c: e12fff14 bx r4 <== NOT EXECUTED
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
3000a720: e28d7018 add r7, sp, #24 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
3000a724: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a728: e59f1194 ldr r1, [pc, #404] ; 3000a8c4 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f4><== NOT EXECUTED 3000a72c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a730: e12fff14 bx r4 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000a734: e59f818c ldr r8, [pc, #396] ; 3000a8c8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f8><== NOT EXECUTED
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
3000a738: e2873018 add r3, r7, #24 <== NOT EXECUTED 3000a73c: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
3000a740: e2873030 add r3, r7, #48 ; 0x30 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000a744: e5986008 ldr r6, [r8, #8] <== NOT EXECUTED
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
3000a748: e28da070 add sl, sp, #112 ; 0x70 <== NOT EXECUTED
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
3000a74c: e28d9068 add r9, sp, #104 ; 0x68 <== NOT EXECUTED
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
3000a750: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000a754: ea000051 b 3000a8a0 <rtems_rate_monotonic_report_statistics_with_plugin+0x1d0><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
3000a758: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a75c: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a760: eb00156c bl 3000fd18 <rtems_rate_monotonic_get_statistics> <== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL )
3000a764: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a768: 1a00004b bne 3000a89c <rtems_rate_monotonic_report_statistics_with_plugin+0x1cc><== NOT EXECUTED
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
3000a76c: e28d1050 add r1, sp, #80 ; 0x50 <== NOT EXECUTED 3000a770: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a774: eb001594 bl 3000fdcc <rtems_rate_monotonic_get_status> <== NOT EXECUTED
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
3000a778: e3a01005 mov r1, #5 <== NOT EXECUTED 3000a77c: e1a0200a mov r2, sl <== NOT EXECUTED 3000a780: e59d0050 ldr r0, [sp, #80] ; 0x50 <== NOT EXECUTED 3000a784: eb0000ac bl 3000aa3c <rtems_object_get_name> <== NOT EXECUTED
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
3000a788: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3000a78c: e59f1138 ldr r1, [pc, #312] ; 3000a8cc <rtems_rate_monotonic_report_statistics_with_plugin+0x1fc><== NOT EXECUTED 3000a790: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a794: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 3000a798: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a79c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000a7a0: e1a02006 mov r2, r6 <== NOT EXECUTED 3000a7a4: e1a0300a mov r3, sl <== NOT EXECUTED 3000a7a8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a7ac: e12fff14 bx r4 <== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
3000a7b0: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 3000a7b4: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a7b8: 1a000004 bne 3000a7d0 <rtems_rate_monotonic_report_statistics_with_plugin+0x100><== NOT EXECUTED
(*print)( context, "\n" );
3000a7bc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a7c0: e59f1108 ldr r1, [pc, #264] ; 3000a8d0 <rtems_rate_monotonic_report_statistics_with_plugin+0x200><== NOT EXECUTED 3000a7c4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a7c8: e12fff14 bx r4 <== NOT EXECUTED
continue;
3000a7cc: ea000032 b 3000a89c <rtems_rate_monotonic_report_statistics_with_plugin+0x1cc><== NOT EXECUTED
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
3000a7d0: e1a02009 mov r2, r9 <== NOT EXECUTED 3000a7d4: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED 3000a7d8: eb000d44 bl 3000dcf0 <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
3000a7dc: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 3000a7e0: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a7e4: eb004204 bl 3001affc <__aeabi_idiv> <== NOT EXECUTED 3000a7e8: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000a7ec: e1a0b000 mov fp, r0 <== NOT EXECUTED 3000a7f0: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a7f4: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED 3000a7f8: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a7fc: eb0041fe bl 3001affc <__aeabi_idiv> <== NOT EXECUTED 3000a800: e59d3068 ldr r3, [sp, #104] ; 0x68 <== NOT EXECUTED 3000a804: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 3000a808: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a80c: e59d006c ldr r0, [sp, #108] ; 0x6c <== NOT EXECUTED 3000a810: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000a814: eb0041f8 bl 3001affc <__aeabi_idiv> <== NOT EXECUTED 3000a818: e1a0300b mov r3, fp <== NOT EXECUTED 3000a81c: e58d000c str r0, [sp, #12] <== NOT EXECUTED 3000a820: e59f10ac ldr r1, [pc, #172] ; 3000a8d4 <rtems_rate_monotonic_report_statistics_with_plugin+0x204><== NOT EXECUTED 3000a824: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000a828: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a82c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a830: e12fff14 bx r4 <== NOT EXECUTED
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
3000a834: e1a02009 mov r2, r9 <== NOT EXECUTED 3000a838: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED 3000a83c: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 3000a840: eb000d2a bl 3000dcf0 <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
3000a844: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a848: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED 3000a84c: eb0041ea bl 3001affc <__aeabi_idiv> <== NOT EXECUTED 3000a850: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED 3000a854: e1a0b000 mov fp, r0 <== NOT EXECUTED 3000a858: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a85c: e59d0044 ldr r0, [sp, #68] ; 0x44 <== NOT EXECUTED 3000a860: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a864: eb0041e4 bl 3001affc <__aeabi_idiv> <== NOT EXECUTED 3000a868: e59d3068 ldr r3, [sp, #104] ; 0x68 <== NOT EXECUTED 3000a86c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 3000a870: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a874: e59d006c ldr r0, [sp, #108] ; 0x6c <== NOT EXECUTED 3000a878: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000a87c: eb0041de bl 3001affc <__aeabi_idiv> <== NOT EXECUTED 3000a880: e59f1050 ldr r1, [pc, #80] ; 3000a8d8 <rtems_rate_monotonic_report_statistics_with_plugin+0x208><== NOT EXECUTED 3000a884: e58d000c str r0, [sp, #12] <== NOT EXECUTED 3000a888: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 3000a88c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a890: e1a0300b mov r3, fp <== NOT EXECUTED 3000a894: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a898: e12fff14 bx r4 <== NOT EXECUTED
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3000a89c: e2866001 add r6, r6, #1 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000a8a0: e598300c ldr r3, [r8, #12] <== NOT EXECUTED 3000a8a4: e1560003 cmp r6, r3 <== NOT EXECUTED 3000a8a8: 9affffaa bls 3000a758 <rtems_rate_monotonic_report_statistics_with_plugin+0x88><== NOT EXECUTED
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
3000a8ac: e28dd078 add sp, sp, #120 ; 0x78 <== NOT EXECUTED
3000a8b0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000a8ec <rtems_rate_monotonic_reset_all_statistics>:
3000a8ec: e59f3038 ldr r3, [pc, #56] ; 3000a92c <rtems_rate_monotonic_reset_all_statistics+0x40><== NOT EXECUTED
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
3000a8f0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000a8f4: e5932000 ldr r2, [r3] <== NOT EXECUTED
3000a8f8: e2822001 add r2, r2, #1 <== NOT EXECUTED
3000a8fc: e5832000 str r2, [r3] <== NOT EXECUTED
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000a900: e59f5028 ldr r5, [pc, #40] ; 3000a930 <rtems_rate_monotonic_reset_all_statistics+0x44><== NOT EXECUTED 3000a904: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED 3000a908: ea000002 b 3000a918 <rtems_rate_monotonic_reset_all_statistics+0x2c><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
3000a90c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a910: eb000007 bl 3000a934 <rtems_rate_monotonic_reset_statistics><== NOT EXECUTED
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3000a914: e2844001 add r4, r4, #1 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000a918: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000a91c: e1540003 cmp r4, r3 <== NOT EXECUTED 3000a920: 9afffff9 bls 3000a90c <rtems_rate_monotonic_reset_all_statistics+0x20><== NOT EXECUTED
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
3000a924: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
3000a928: ea000a55 b 3000d284 <_Thread_Enable_dispatch> <== NOT EXECUTED
3000a934 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
3000a934: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3000a938: e1a01000 mov r1, r0 <== NOT EXECUTED
3000a93c: e1a0200d mov r2, sp <== NOT EXECUTED
3000a940: e59f0044 ldr r0, [pc, #68] ; 3000a98c <rtems_rate_monotonic_reset_statistics+0x58><== NOT EXECUTED
3000a944: eb000734 bl 3000c61c <_Objects_Get> <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000a948: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000a94c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a950: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a954: 13a00004 movne r0, #4 <== NOT EXECUTED
{
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000a958: 1a00000a bne 3000a988 <rtems_rate_monotonic_reset_statistics+0x54><== NOT EXECUTED
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
3000a95c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a960: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 3000a964: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 3000a968: eb001fb8 bl 30012850 <memset> <== NOT EXECUTED 3000a96c: e3e03102 mvn r3, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000a970: e584305c str r3, [r4, #92] ; 0x5c <== NOT EXECUTED 3000a974: e5843060 str r3, [r4, #96] ; 0x60 <== NOT EXECUTED 3000a978: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED 3000a97c: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a980: eb000a3f bl 3000d284 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a984: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000a988: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30016bdc <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30016bdc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
30016be0: e2509000 subs r9, r0, #0
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30016be4: e1a06001 mov r6, r1 30016be8: e1a07002 mov r7, r2 30016bec: e1a08003 mov r8, r3 30016bf0: e59da024 ldr sl, [sp, #36] ; 0x24 30016bf4: e59db028 ldr fp, [sp, #40] ; 0x28
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30016bf8: 03a06003 moveq r6, #3
)
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
30016bfc: 0a000031 beq 30016cc8 <rtems_region_create+0xec>
return RTEMS_INVALID_NAME;
if ( !starting_address )
30016c00: e3560000 cmp r6, #0
30016c04: 0a00002e beq 30016cc4 <rtems_region_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( !id )
30016c08: e35b0000 cmp fp, #0
30016c0c: 0a00002c beq 30016cc4 <rtems_region_create+0xe8>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
30016c10: e59f30b8 ldr r3, [pc, #184] ; 30016cd0 <rtems_region_create+0xf4>
* This function allocates a region control block from
* the inactive chain of free region control blocks.
*/
RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void )
{
return (Region_Control *) _Objects_Allocate( &_Region_Information );
30016c14: e59f50b8 ldr r5, [pc, #184] ; 30016cd4 <rtems_region_create+0xf8> 30016c18: e5930000 ldr r0, [r3] 30016c1c: eb00091c bl 30019094 <_API_Mutex_Lock> 30016c20: e1a00005 mov r0, r5 30016c24: eb000f0b bl 3001a858 <_Objects_Allocate>
the_region = _Region_Allocate();
if ( !the_region )
30016c28: e2504000 subs r4, r0, #0
return_status = RTEMS_TOO_MANY;
30016c2c: 03a06005 moveq r6, #5
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Allocate();
if ( !the_region )
30016c30: 0a00001f beq 30016cb4 <rtems_region_create+0xd8>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
30016c34: e2840068 add r0, r4, #104 ; 0x68 30016c38: e1a01006 mov r1, r6 30016c3c: e1a02007 mov r2, r7 30016c40: e1a03008 mov r3, r8 30016c44: eb000de6 bl 3001a3e4 <_Heap_Initialize>
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
30016c48: e3500000 cmp r0, #0
if ( !the_region )
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
30016c4c: e584005c str r0, [r4, #92] ; 0x5c
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
30016c50: 1a000004 bne 30016c68 <rtems_region_create+0x8c>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
30016c54: e1a00005 mov r0, r5 <== NOT EXECUTED 30016c58: e1a01004 mov r1, r4 <== NOT EXECUTED 30016c5c: eb000fc4 bl 3001ab74 <_Objects_Free> <== NOT EXECUTED
_Region_Free( the_region );
return_status = RTEMS_INVALID_SIZE;
30016c60: e3a06008 mov r6, #8 <== NOT EXECUTED 30016c64: ea000012 b 30016cb4 <rtems_region_create+0xd8> <== NOT EXECUTED
}
else {
the_region->starting_address = starting_address;
30016c68: e5846050 str r6, [r4, #80] ; 0x50
the_region->length = length;
the_region->page_size = page_size;
the_region->attribute_set = attribute_set;
the_region->number_of_used_blocks = 0;
_Thread_queue_Initialize(
30016c6c: e31a0004 tst sl, #4
the_region->starting_address = starting_address;
the_region->length = length;
the_region->page_size = page_size;
the_region->attribute_set = attribute_set;
the_region->number_of_used_blocks = 0;
30016c70: e3a06000 mov r6, #0
_Thread_queue_Initialize(
30016c74: 03a01000 moveq r1, #0 30016c78: 13a01001 movne r1, #1 30016c7c: e3a02040 mov r2, #64 ; 0x40 30016c80: e3a03006 mov r3, #6
}
else {
the_region->starting_address = starting_address;
the_region->length = length;
30016c84: e5847054 str r7, [r4, #84] ; 0x54
the_region->page_size = page_size;
30016c88: e5848058 str r8, [r4, #88] ; 0x58
the_region->attribute_set = attribute_set;
30016c8c: e584a060 str sl, [r4, #96] ; 0x60
the_region->number_of_used_blocks = 0;
30016c90: e5846064 str r6, [r4, #100] ; 0x64
_Thread_queue_Initialize(
30016c94: e2840010 add r0, r4, #16 30016c98: eb0014f1 bl 3001c064 <_Thread_queue_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30016c9c: e595201c ldr r2, [r5, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30016ca0: e5943008 ldr r3, [r4, #8] 30016ca4: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30016ca8: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30016cac: e584900c str r9, [r4, #12]
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
30016cb0: e58b3000 str r3, [fp]
return_status = RTEMS_SUCCESSFUL;
}
}
_RTEMS_Unlock_allocator();
30016cb4: e59f3014 ldr r3, [pc, #20] ; 30016cd0 <rtems_region_create+0xf4> 30016cb8: e5930000 ldr r0, [r3] 30016cbc: eb00090d bl 300190f8 <_API_Mutex_Unlock>
return return_status;
30016cc0: ea000000 b 30016cc8 <rtems_region_create+0xec>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
30016cc4: e3a06009 mov r6, #9 <== NOT EXECUTED
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
30016cc8: e1a00006 mov r0, r6
30016ccc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
30016d54 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
30016d54: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr} <== NOT EXECUTED
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
30016d58: e2517000 subs r7, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
30016d5c: e1a04000 mov r4, r0 <== NOT EXECUTED 30016d60: e1a06002 mov r6, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
30016d64: 03a05009 moveq r5, #9 <== NOT EXECUTED
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
30016d68: 0a00001d beq 30016de4 <rtems_region_extend+0x90> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
30016d6c: e59f3078 ldr r3, [pc, #120] ; 30016dec <rtems_region_extend+0x98><== NOT EXECUTED 30016d70: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016d74: eb0008c6 bl 30019094 <_API_Mutex_Lock> <== NOT EXECUTED
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
30016d78: e1a01004 mov r1, r4 <== NOT EXECUTED 30016d7c: e59f006c ldr r0, [pc, #108] ; 30016df0 <rtems_region_extend+0x9c><== NOT EXECUTED 30016d80: e1a0200d mov r2, sp <== NOT EXECUTED 30016d84: eb000fcf bl 3001acc8 <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30016d88: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30016d8c: e1a04000 mov r4, r0 <== NOT EXECUTED 30016d90: e3550000 cmp r5, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30016d94: 13a05004 movne r5, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Get( id, &location );
switch ( location ) {
30016d98: 1a00000e bne 30016dd8 <rtems_region_extend+0x84> <== NOT EXECUTED
case OBJECTS_LOCAL:
extend_ok = _Heap_Extend(
30016d9c: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30016da0: e1a01007 mov r1, r7 <== NOT EXECUTED 30016da4: e1a02006 mov r2, r6 <== NOT EXECUTED 30016da8: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30016dac: eb000bc9 bl 30019cd8 <_Heap_Extend> <== NOT EXECUTED
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
30016db0: e3500000 cmp r0, #0 <== NOT EXECUTED
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
} else {
return_status = RTEMS_INVALID_ADDRESS;
30016db4: 03a05009 moveq r5, #9 <== NOT EXECUTED
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
30016db8: 0a000006 beq 30016dd8 <rtems_region_extend+0x84> <== NOT EXECUTED
the_region->length += amount_extended;
30016dbc: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30016dc0: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 30016dc4: e0822003 add r2, r2, r3 <== NOT EXECUTED 30016dc8: e5842054 str r2, [r4, #84] ; 0x54 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
30016dcc: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED 30016dd0: e0823003 add r3, r2, r3 <== NOT EXECUTED 30016dd4: e584305c str r3, [r4, #92] ; 0x5c <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30016dd8: e59f300c ldr r3, [pc, #12] ; 30016dec <rtems_region_extend+0x98><== NOT EXECUTED 30016ddc: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016de0: eb0008c4 bl 300190f8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30016de4: e1a00005 mov r0, r5 <== NOT EXECUTED
30016de8: e8bd80fc pop {r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
30016df4 <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30016df4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30016df8: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30016dfc: e1a05000 mov r5, r0 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
30016e00: 03a05009 moveq r5, #9 <== NOT EXECUTED
{
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30016e04: 0a000013 beq 30016e58 <rtems_region_get_free_information+0x64><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30016e08: e59f3050 ldr r3, [pc, #80] ; 30016e60 <rtems_region_get_free_information+0x6c><== NOT EXECUTED 30016e0c: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016e10: eb00089f bl 30019094 <_API_Mutex_Lock> <== NOT EXECUTED 30016e14: e1a01005 mov r1, r5 <== NOT EXECUTED 30016e18: e59f0044 ldr r0, [pc, #68] ; 30016e64 <rtems_region_get_free_information+0x70><== NOT EXECUTED 30016e1c: e1a0200d mov r2, sp <== NOT EXECUTED 30016e20: eb000fa8 bl 3001acc8 <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30016e24: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30016e28: e3550000 cmp r5, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30016e2c: 13a05004 movne r5, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
30016e30: 1a000005 bne 30016e4c <rtems_region_get_free_information+0x58><== NOT EXECUTED
case OBJECTS_LOCAL:
the_info->Used.number = 0;
30016e34: e584500c str r5, [r4, #12] <== NOT EXECUTED
the_info->Used.total = 0;
30016e38: e5845014 str r5, [r4, #20] <== NOT EXECUTED
the_info->Used.largest = 0;
30016e3c: e5845010 str r5, [r4, #16] <== NOT EXECUTED
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
30016e40: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30016e44: e1a01004 mov r1, r4 <== NOT EXECUTED 30016e48: eb000cd0 bl 3001a190 <_Heap_Get_free_information> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30016e4c: e59f300c ldr r3, [pc, #12] ; 30016e60 <rtems_region_get_free_information+0x6c><== NOT EXECUTED 30016e50: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016e54: eb0008a7 bl 300190f8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30016e58: e1a00005 mov r0, r5 <== NOT EXECUTED
30016e5c: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30016e68 <rtems_region_get_information>:
rtems_status_code rtems_region_get_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30016e68: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30016e6c: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30016e70: e1a05000 mov r5, r0 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
30016e74: 03a05009 moveq r5, #9 <== NOT EXECUTED
{
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30016e78: 0a00000f beq 30016ebc <rtems_region_get_information+0x54> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30016e7c: e59f3040 ldr r3, [pc, #64] ; 30016ec4 <rtems_region_get_information+0x5c><== NOT EXECUTED 30016e80: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016e84: eb000882 bl 30019094 <_API_Mutex_Lock> <== NOT EXECUTED 30016e88: e1a01005 mov r1, r5 <== NOT EXECUTED 30016e8c: e59f0034 ldr r0, [pc, #52] ; 30016ec8 <rtems_region_get_information+0x60><== NOT EXECUTED 30016e90: e1a0200d mov r2, sp <== NOT EXECUTED 30016e94: eb000f8b bl 3001acc8 <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30016e98: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30016e9c: e3550000 cmp r5, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30016ea0: 13a05004 movne r5, #4 <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Heap_Get_information( &the_region->Memory, the_info );
30016ea4: 02800068 addeq r0, r0, #104 ; 0x68 <== NOT EXECUTED 30016ea8: 01a01004 moveq r1, r4 <== NOT EXECUTED 30016eac: 0b000ccc bleq 3001a1e4 <_Heap_Get_information> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30016eb0: e59f300c ldr r3, [pc, #12] ; 30016ec4 <rtems_region_get_information+0x5c><== NOT EXECUTED 30016eb4: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016eb8: eb00088e bl 300190f8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30016ebc: e1a00005 mov r0, r5 <== NOT EXECUTED
30016ec0: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30016ff8 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
30016ff8: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
30016ffc: e2515000 subs r5, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
30017000: e1a06000 mov r6, r0 <== NOT EXECUTED 30017004: e1a04002 mov r4, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
30017008: 0a000019 beq 30017074 <rtems_region_get_segment_size+0x7c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !size )
3001700c: e3520000 cmp r2, #0 <== NOT EXECUTED 30017010: 0a000017 beq 30017074 <rtems_region_get_segment_size+0x7c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30017014: e59f3064 ldr r3, [pc, #100] ; 30017080 <rtems_region_get_segment_size+0x88><== NOT EXECUTED 30017018: e5930000 ldr r0, [r3] <== NOT EXECUTED 3001701c: eb00081c bl 30019094 <_API_Mutex_Lock> <== NOT EXECUTED 30017020: e59f005c ldr r0, [pc, #92] ; 30017084 <rtems_region_get_segment_size+0x8c><== NOT EXECUTED 30017024: e1a01006 mov r1, r6 <== NOT EXECUTED 30017028: e1a0200d mov r2, sp <== NOT EXECUTED 3001702c: eb000f25 bl 3001acc8 <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30017030: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30017034: e3530000 cmp r3, #0 <== NOT EXECUTED 30017038: 0a000002 beq 30017048 <rtems_region_get_segment_size+0x50> <== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
3001703c: e3530001 cmp r3, #1 <== NOT EXECUTED 30017040: 03a04004 moveq r4, #4 <== NOT EXECUTED 30017044: ea000005 b 30017060 <rtems_region_get_segment_size+0x68> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
30017048: e1a02004 mov r2, r4 <== NOT EXECUTED 3001704c: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017050: e1a01005 mov r1, r5 <== NOT EXECUTED 30017054: eb000dc2 bl 3001a764 <_Heap_Size_of_alloc_area> <== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
30017058: e3500000 cmp r0, #0 <== NOT EXECUTED 3001705c: 03a04009 moveq r4, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30017060: e59f3018 ldr r3, [pc, #24] ; 30017080 <rtems_region_get_segment_size+0x88><== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
30017064: 13a04000 movne r4, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30017068: e5930000 ldr r0, [r3] <== NOT EXECUTED 3001706c: eb000821 bl 300190f8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status;
30017070: ea000000 b 30017078 <rtems_region_get_segment_size+0x80> <== NOT EXECUTED
if ( !segment )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
30017074: e3a04009 mov r4, #9 <== NOT EXECUTED
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
30017078: e1a00004 mov r0, r4 <== NOT EXECUTED
3001707c: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
300170b8 <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
300170b8: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uintptr_t osize;
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
300170bc: e2538000 subs r8, r3, #0 <== NOT EXECUTED
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
300170c0: e1a05000 mov r5, r0 <== NOT EXECUTED 300170c4: e1a07001 mov r7, r1 <== NOT EXECUTED 300170c8: e1a06002 mov r6, r2 <== NOT EXECUTED
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
return RTEMS_INVALID_ADDRESS;
300170cc: 03a00009 moveq r0, #9 <== NOT EXECUTED
uintptr_t osize;
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
300170d0: 0a000022 beq 30017160 <rtems_region_resize_segment+0xa8> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
300170d4: e59f408c ldr r4, [pc, #140] ; 30017168 <rtems_region_resize_segment+0xb0><== NOT EXECUTED 300170d8: e5940000 ldr r0, [r4] <== NOT EXECUTED 300170dc: eb0007ec bl 30019094 <_API_Mutex_Lock> <== NOT EXECUTED 300170e0: e1a01005 mov r1, r5 <== NOT EXECUTED 300170e4: e59f0080 ldr r0, [pc, #128] ; 3001716c <rtems_region_resize_segment+0xb4><== NOT EXECUTED 300170e8: e28d2008 add r2, sp, #8 <== NOT EXECUTED 300170ec: eb000ef5 bl 3001acc8 <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
300170f0: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 300170f4: e1a05000 mov r5, r0 <== NOT EXECUTED 300170f8: e3530000 cmp r3, #0 <== NOT EXECUTED 300170fc: 1a000014 bne 30017154 <rtems_region_resize_segment+0x9c> <== NOT EXECUTED
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
30017100: e28d300c add r3, sp, #12 <== NOT EXECUTED 30017104: e58d3000 str r3, [sp] <== NOT EXECUTED 30017108: e1a02006 mov r2, r6 <== NOT EXECUTED 3001710c: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30017110: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017114: e1a01007 mov r1, r7 <== NOT EXECUTED 30017118: eb000d44 bl 3001a630 <_Heap_Resize_block> <== NOT EXECUTED
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
3001711c: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
30017120: e2506000 subs r6, r0, #0 <== NOT EXECUTED
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
30017124: e5883000 str r3, [r8] <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
30017128: 1a000003 bne 3001713c <rtems_region_resize_segment+0x84> <== NOT EXECUTED
_Region_Process_queue( the_region ); /* unlocks allocator */
3001712c: e1a00005 mov r0, r5 <== NOT EXECUTED 30017130: eb001d2d bl 3001e5ec <_Region_Process_queue> <== NOT EXECUTED
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
30017134: e1a00006 mov r0, r6 <== NOT EXECUTED 30017138: ea000008 b 30017160 <rtems_region_resize_segment+0xa8> <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
3001713c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017140: eb0007ec bl 300190f8 <_API_Mutex_Unlock> <== NOT EXECUTED
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
return RTEMS_UNSATISFIED;
30017144: e3560001 cmp r6, #1 <== NOT EXECUTED 30017148: 13a00009 movne r0, #9 <== NOT EXECUTED 3001714c: 03a0000d moveq r0, #13 <== NOT EXECUTED 30017150: ea000002 b 30017160 <rtems_region_resize_segment+0xa8> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30017154: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017158: eb0007e6 bl 300190f8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status;
3001715c: e3a00004 mov r0, #4 <== NOT EXECUTED
}
30017160: e28dd010 add sp, sp, #16 <== NOT EXECUTED
30017164: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30017170 <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30017170: e92d4071 push {r0, r4, r5, r6, lr}
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30017174: e59f3074 ldr r3, [pc, #116] ; 300171f0 <rtems_region_return_segment+0x80>
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30017178: e1a05000 mov r5, r0
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
3001717c: e5930000 ldr r0, [r3]
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30017180: e1a04001 mov r4, r1
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30017184: eb0007c2 bl 30019094 <_API_Mutex_Lock> 30017188: e1a01005 mov r1, r5 3001718c: e59f0060 ldr r0, [pc, #96] ; 300171f4 <rtems_region_return_segment+0x84> 30017190: e1a0200d mov r2, sp 30017194: eb000ecb bl 3001acc8 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
30017198: e59d6000 ldr r6, [sp] 3001719c: e1a05000 mov r5, r0 300171a0: e3560000 cmp r6, #0
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
300171a4: 13a06004 movne r6, #4
register Region_Control *the_region;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
300171a8: 1a00000b bne 300171dc <rtems_region_return_segment+0x6c>
RTEMS_INLINE_ROUTINE bool _Region_Free_segment (
Region_Control *the_region,
void *the_segment
)
{
return _Heap_Free( &the_region->Memory, the_segment );
300171ac: e2800068 add r0, r0, #104 ; 0x68 300171b0: e1a01004 mov r1, r4 300171b4: eb000b79 bl 30019fa0 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
300171b8: e3500000 cmp r0, #0
return_status = RTEMS_INVALID_ADDRESS;
300171bc: 03a06009 moveq r6, #9
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
300171c0: 0a000005 beq 300171dc <rtems_region_return_segment+0x6c>
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
300171c4: e5953064 ldr r3, [r5, #100] ; 0x64
_Region_Process_queue(the_region); /* unlocks allocator */
300171c8: e1a00005 mov r0, r5
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
300171cc: e2433001 sub r3, r3, #1 300171d0: e5853064 str r3, [r5, #100] ; 0x64
_Region_Process_queue(the_region); /* unlocks allocator */
300171d4: eb001d04 bl 3001e5ec <_Region_Process_queue>
return RTEMS_SUCCESSFUL;
300171d8: ea000002 b 300171e8 <rtems_region_return_segment+0x78>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
300171dc: e59f300c ldr r3, [pc, #12] ; 300171f0 <rtems_region_return_segment+0x80><== NOT EXECUTED 300171e0: e5930000 ldr r0, [r3] <== NOT EXECUTED 300171e4: eb0007c3 bl 300190f8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
300171e8: e1a00006 mov r0, r6
300171ec: e8bd8078 pop {r3, r4, r5, r6, pc}
30009258 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
30009258: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
3000925c: e2507000 subs r7, r0, #0
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
30009260: e24dd018 sub sp, sp, #24 30009264: e1a04001 mov r4, r1 30009268: e1a08002 mov r8, r2 3000926c: e1a09003 mov r9, r3 30009270: e59d6038 ldr r6, [sp, #56] ; 0x38
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30009274: 03a00003 moveq r0, #3
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
30009278: 0a00005d beq 300093f4 <rtems_semaphore_create+0x19c>
return RTEMS_INVALID_NAME;
if ( !id )
3000927c: e3560000 cmp r6, #0
return RTEMS_INVALID_ADDRESS;
30009280: 03a00009 moveq r0, #9
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30009284: 0a00005a beq 300093f4 <rtems_semaphore_create+0x19c>
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
30009288: e21230c0 ands r3, r2, #192 ; 0xc0
3000928c: 0a000006 beq 300092ac <rtems_semaphore_create+0x54>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
30009290: e2022030 and r2, r2, #48 ; 0x30
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
30009294: e3520010 cmp r2, #16
30009298: 1a000054 bne 300093f0 <rtems_semaphore_create+0x198>
3000929c: e3180004 tst r8, #4
300092a0: 0a000052 beq 300093f0 <rtems_semaphore_create+0x198>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
300092a4: e35300c0 cmp r3, #192 ; 0xc0
300092a8: 0a000050 beq 300093f0 <rtems_semaphore_create+0x198>
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
300092ac: e218a030 ands sl, r8, #48 ; 0x30
300092b0: 0a000002 beq 300092c0 <rtems_semaphore_create+0x68>
300092b4: e3540001 cmp r4, #1
return RTEMS_INVALID_NUMBER;
300092b8: 83a0000a movhi r0, #10
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
300092bc: 8a00004c bhi 300093f4 <rtems_semaphore_create+0x19c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
300092c0: e59f3134 ldr r3, [pc, #308] ; 300093fc <rtems_semaphore_create+0x1a4> 300092c4: e5932000 ldr r2, [r3] 300092c8: e2822001 add r2, r2, #1 300092cc: e5832000 str r2, [r3]
* This function allocates a semaphore control block from
* the inactive chain of free semaphore control blocks.
*/
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void )
{
return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information );
300092d0: e59f0128 ldr r0, [pc, #296] ; 30009400 <rtems_semaphore_create+0x1a8> 300092d4: eb000508 bl 3000a6fc <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
300092d8: e2505000 subs r5, r0, #0
300092dc: 1a000002 bne 300092ec <rtems_semaphore_create+0x94>
_Thread_Enable_dispatch();
300092e0: eb00093b bl 3000b7d4 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
300092e4: e3a00005 mov r0, #5 300092e8: ea000041 b 300093f4 <rtems_semaphore_create+0x19c>
the_semaphore->attribute_set = attribute_set;
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
300092ec: e35a0000 cmp sl, #0
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
300092f0: e5858010 str r8, [r5, #16] 300092f4: e2083004 and r3, r8, #4
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
300092f8: 1a00000d bne 30009334 <rtems_semaphore_create+0xdc>
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
if ( _Attributes_Is_priority( attribute_set ) )
300092fc: e3530000 cmp r3, #0
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
30009300: 13a03001 movne r3, #1
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
30009304: e3e02000 mvn r2, #0 30009308: e58d2010 str r2, [sp, #16]
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
3000930c: 158d3014 strne r3, [sp, #20]
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
_CORE_semaphore_Initialize(
30009310: e2850014 add r0, r5, #20
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
30009314: e3a03000 mov r3, #0
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
_CORE_semaphore_Initialize(
30009318: e28d1010 add r1, sp, #16 3000931c: e1a02004 mov r2, r4
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
else
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
30009320: 058da014 streq sl, [sp, #20]
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
30009324: e58d3000 str r3, [sp]
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
30009328: e58d300c str r3, [sp, #12]
_CORE_semaphore_Initialize(
3000932c: eb000380 bl 3000a134 <_CORE_semaphore_Initialize> 30009330: ea000024 b 300093c8 <rtems_semaphore_create+0x170>
} else {
/*
* It is either simple binary semaphore or a more powerful mutex
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
30009334: e3530000 cmp r3, #0
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
30009338: 13a03001 movne r3, #1
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
3000933c: e35a0010 cmp sl, #16
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
30009340: e58d3008 str r3, [sp, #8]
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
the_mutex_attr.only_owner_release = true;
}
}
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
30009344: 13a03001 movne r3, #1 30009348: 158d3000 strne r3, [sp]
the_mutex_attr.only_owner_release = false;
3000934c: 13a03000 movne r3, #0
if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
30009350: 1a00000d bne 3000938c <rtems_semaphore_create+0x134>
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
30009354: e3a03000 mov r3, #0 30009358: e58d3000 str r3, [sp]
the_mutex_attr.only_owner_release = false;
3000935c: e5cd3004 strb r3, [sp, #4]
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
30009360: e59d3008 ldr r3, [sp, #8]
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
30009364: e58d900c str r9, [sp, #12]
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
30009368: e3530001 cmp r3, #1
3000936c: 1a000007 bne 30009390 <rtems_semaphore_create+0x138>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
30009370: e3180040 tst r8, #64 ; 0x40
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
30009374: 13a02002 movne r2, #2
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
30009378: 1a000002 bne 30009388 <rtems_semaphore_create+0x130>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
3000937c: e3180080 tst r8, #128 ; 0x80
30009380: 0a000002 beq 30009390 <rtems_semaphore_create+0x138>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
30009384: e3a02003 mov r2, #3 30009388: e58d2008 str r2, [sp, #8]
the_mutex_attr.only_owner_release = true;
}
}
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
the_mutex_attr.only_owner_release = false;
3000938c: e5cd3004 strb r3, [sp, #4]
}
mutex_status = _CORE_mutex_Initialize(
30009390: e3540001 cmp r4, #1 30009394: 13a02000 movne r2, #0 30009398: 03a02001 moveq r2, #1 3000939c: e2850014 add r0, r5, #20 300093a0: e1a0100d mov r1, sp 300093a4: eb0002a4 bl 30009e3c <_CORE_mutex_Initialize>
&the_semaphore->Core_control.mutex,
&the_mutex_attr,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
300093a8: e3500005 cmp r0, #5
300093ac: 1a000005 bne 300093c8 <rtems_semaphore_create+0x170>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
300093b0: e59f0048 ldr r0, [pc, #72] ; 30009400 <rtems_semaphore_create+0x1a8> 300093b4: e1a01005 mov r1, r5 300093b8: eb000596 bl 3000aa18 <_Objects_Free>
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
300093bc: eb000904 bl 3000b7d4 <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
300093c0: e3a00013 mov r0, #19 300093c4: ea00000a b 300093f4 <rtems_semaphore_create+0x19c>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300093c8: e59f2030 ldr r2, [pc, #48] ; 30009400 <rtems_semaphore_create+0x1a8>
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300093cc: e5953008 ldr r3, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300093d0: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300093d4: e1d510b8 ldrh r1, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300093d8: e7825101 str r5, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300093dc: e585700c str r7, [r5, #12]
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
300093e0: e5863000 str r3, [r6]
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
300093e4: eb0008fa bl 3000b7d4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300093e8: e3a00000 mov r0, #0 300093ec: ea000000 b 300093f4 <rtems_semaphore_create+0x19c>
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
300093f0: e3a0000b mov r0, #11 <== NOT EXECUTED
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
300093f4: e28dd018 add sp, sp, #24
300093f8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
30009404 <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
30009404: e92d4011 push {r0, r4, lr}
30009408: e1a01000 mov r1, r0
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
3000940c: e1a0200d mov r2, sp 30009410: e59f0084 ldr r0, [pc, #132] ; 3000949c <rtems_semaphore_delete+0x98> 30009414: eb0005d4 bl 3000ab6c <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30009418: e59d3000 ldr r3, [sp] 3000941c: e1a04000 mov r4, r0 30009420: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009424: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30009428: 1a00001a bne 30009498 <rtems_semaphore_delete+0x94>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
3000942c: e5941010 ldr r1, [r4, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
30009430: e2111030 ands r1, r1, #48 ; 0x30
30009434: 0a00000c beq 3000946c <rtems_semaphore_delete+0x68>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
30009438: e5943064 ldr r3, [r4, #100] ; 0x64 3000943c: e3530000 cmp r3, #0
30009440: 1a000004 bne 30009458 <rtems_semaphore_delete+0x54>
30009444: e3510020 cmp r1, #32
30009448: 0a000002 beq 30009458 <rtems_semaphore_delete+0x54>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
3000944c: eb0008e0 bl 3000b7d4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
30009450: e3a0000c mov r0, #12 <== NOT EXECUTED 30009454: ea00000f b 30009498 <rtems_semaphore_delete+0x94> <== NOT EXECUTED
}
_CORE_mutex_Flush(
30009458: e2840014 add r0, r4, #20 3000945c: e3a01000 mov r1, #0 30009460: e3a02003 mov r2, #3 30009464: eb000273 bl 30009e38 <_CORE_mutex_Flush> 30009468: ea000002 b 30009478 <rtems_semaphore_delete+0x74>
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
3000946c: e2840014 add r0, r4, #20 30009470: e3a02002 mov r2, #2 30009474: eb00032d bl 3000a130 <_CORE_semaphore_Flush>
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
30009478: e59f001c ldr r0, [pc, #28] ; 3000949c <rtems_semaphore_delete+0x98> 3000947c: e1a01004 mov r1, r4 30009480: eb0004bf bl 3000a784 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
30009484: e59f0010 ldr r0, [pc, #16] ; 3000949c <rtems_semaphore_delete+0x98> 30009488: e1a01004 mov r1, r4 3000948c: eb000561 bl 3000aa18 <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
30009490: eb0008cf bl 3000b7d4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30009494: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30009498: e8bd8018 pop {r3, r4, pc}
30011f9c <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
30011f9c: e92d4001 push {r0, lr}
30011fa0: e1a01000 mov r1, r0
30011fa4: e1a0200d mov r2, sp
30011fa8: e59f0044 ldr r0, [pc, #68] ; 30011ff4 <rtems_semaphore_flush+0x58>
30011fac: ebffe831 bl 3000c078 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30011fb0: e59d3000 ldr r3, [sp] 30011fb4: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30011fb8: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30011fbc: 1a00000b bne 30011ff0 <rtems_semaphore_flush+0x54>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
30011fc0: e5901010 ldr r1, [r0, #16] 30011fc4: e2800014 add r0, r0, #20
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
30011fc8: e2111030 ands r1, r1, #48 ; 0x30
30011fcc: 0a000003 beq 30011fe0 <rtems_semaphore_flush+0x44>
_CORE_mutex_Flush(
30011fd0: e1a01003 mov r1, r3 30011fd4: e3a02001 mov r2, #1 30011fd8: ebffe4d9 bl 3000b344 <_CORE_mutex_Flush> 30011fdc: ea000001 b 30011fe8 <rtems_semaphore_flush+0x4c>
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
30011fe0: e3a02001 mov r2, #1 <== NOT EXECUTED 30011fe4: ebffe594 bl 3000b63c <_CORE_semaphore_Flush> <== NOT EXECUTED
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
30011fe8: ebffeb40 bl 3000ccf0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30011fec: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30011ff0: e8bd8008 pop {r3, pc}
300094a0 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
300094a0: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr}
300094a4: e1a04000 mov r4, r0
Objects_Locations *location,
ISR_Level *level
)
{
return (Semaphore_Control *)
_Objects_Get_isr_disable( &_Semaphore_Information, id, location, level );
300094a8: e28d3004 add r3, sp, #4 300094ac: e1a06001 mov r6, r1 300094b0: e1a05002 mov r5, r2 300094b4: e59f00ec ldr r0, [pc, #236] ; 300095a8 <rtems_semaphore_obtain+0x108> 300094b8: e1a01004 mov r1, r4 300094bc: e28d2008 add r2, sp, #8 300094c0: eb00058f bl 3000ab04 <_Objects_Get_isr_disable>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
ISR_Level level;
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
300094c4: e59d3008 ldr r3, [sp, #8] 300094c8: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300094cc: 13a00004 movne r0, #4
register Semaphore_Control *the_semaphore;
Objects_Locations location;
ISR_Level level;
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
300094d0: 1a000033 bne 300095a4 <rtems_semaphore_obtain+0x104>
300094d4: e5903010 ldr r3, [r0, #16] 300094d8: e59f70cc ldr r7, [pc, #204] ; 300095ac <rtems_semaphore_obtain+0x10c>
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
300094dc: e2132030 ands r2, r3, #48 ; 0x30
300094e0: 0a00000b beq 30009514 <rtems_semaphore_obtain+0x74>
_CORE_mutex_Seize(
300094e4: e59d3004 ldr r3, [sp, #4]
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
300094e8: e2062001 and r2, r6, #1 300094ec: e58d3000 str r3, [sp] 300094f0: e2800014 add r0, r0, #20 300094f4: e1a03005 mov r3, r5 300094f8: e1a01004 mov r1, r4 300094fc: e2222001 eor r2, r2, #1 30009500: eb000294 bl 30009f58 <_CORE_mutex_Seize>
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
_Thread_Executing->Wait.return_code );
30009504: e5973004 ldr r3, [r7, #4]
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
30009508: e5930034 ldr r0, [r3, #52] ; 0x34 3000950c: eb000047 bl 30009630 <_Semaphore_Translate_core_mutex_return_code> 30009510: ea000023 b 300095a4 <rtems_semaphore_obtain+0x104>
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
30009514: e5973004 ldr r3, [r7, #4]
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
30009518: e5832034 str r2, [r3, #52] ; 0x34
if ( the_semaphore->count != 0 ) {
3000951c: e590205c ldr r2, [r0, #92] ; 0x5c 30009520: e3520000 cmp r2, #0
30009524: 0a000004 beq 3000953c <rtems_semaphore_obtain+0x9c>
the_semaphore->count -= 1;
30009528: e2422001 sub r2, r2, #1 3000952c: e580205c str r2, [r0, #92] ; 0x5c 30009530: e59d3004 ldr r3, [sp, #4] 30009534: e129f003 msr CPSR_fc, r3 30009538: ea000015 b 30009594 <rtems_semaphore_obtain+0xf4>
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
3000953c: e3160001 tst r6, #1
30009540: 0a000004 beq 30009558 <rtems_semaphore_obtain+0xb8>
30009544: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 30009548: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( *level_p );
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
3000954c: e3a02001 mov r2, #1 <== NOT EXECUTED 30009550: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED 30009554: ea00000e b 30009594 <rtems_semaphore_obtain+0xf4> <== NOT EXECUTED
30009558: e59f2050 ldr r2, [pc, #80] ; 300095b0 <rtems_semaphore_obtain+0x110> 3000955c: e5921000 ldr r1, [r2] 30009560: e2811001 add r1, r1, #1 30009564: e5821000 str r1, [r2]
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30009568: e3a02001 mov r2, #1 3000956c: e5802044 str r2, [r0, #68] ; 0x44
return;
}
_Thread_Disable_dispatch();
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
30009570: e2800014 add r0, r0, #20 30009574: e5830044 str r0, [r3, #68] ; 0x44
executing->Wait.id = id;
30009578: e5834020 str r4, [r3, #32] 3000957c: e59d3004 ldr r3, [sp, #4] 30009580: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
30009584: e59f2028 ldr r2, [pc, #40] ; 300095b4 <rtems_semaphore_obtain+0x114> 30009588: e1a01005 mov r1, r5 3000958c: eb0009a9 bl 3000bc38 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
30009590: eb00088f bl 3000b7d4 <_Thread_Enable_dispatch>
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
_Thread_Executing->Wait.return_code );
30009594: e59f3010 ldr r3, [pc, #16] ; 300095ac <rtems_semaphore_obtain+0x10c> 30009598: e5933004 ldr r3, [r3, #4]
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
3000959c: e5930034 ldr r0, [r3, #52] ; 0x34 300095a0: eb000026 bl 30009640 <_Semaphore_Translate_core_semaphore_return_code>
break;
}
return RTEMS_INVALID_ID;
}
300095a4: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc}
30015c60 <rtems_shutdown_executive>:
void rtems_shutdown_executive(
uint32_t result
)
{
if ( _System_state_Is_up( _System_state_Get() ) ) {
30015c60: e59f3028 ldr r3, [pc, #40] ; 30015c90 <rtems_shutdown_executive+0x30>
*/
void rtems_shutdown_executive(
uint32_t result
)
{
30015c64: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( _System_state_Is_up( _System_state_Get() ) ) {
30015c68: e5932000 ldr r2, [r3] 30015c6c: e3520003 cmp r2, #3 30015c70: 02822001 addeq r2, r2, #1 30015c74: 05832000 streq r2, [r3]
* if we were running within the same context, it would work. * * And we will not return to this thread, so there is no point of * saving the context. */ _Context_Restart_self( &_Thread_BSP_context );
30015c78: 059f0014 ldreq r0, [pc, #20] ; 30015c94 <rtems_shutdown_executive+0x34> 30015c7c: 0bffdbca bleq 3000cbac <_CPU_Context_restore>
_System_state_Set( SYSTEM_STATE_SHUTDOWN );
_Thread_Stop_multitasking();
}
_Internal_error_Occurred(
30015c80: e3a00000 mov r0, #0 <== NOT EXECUTED 30015c84: e3a01001 mov r1, #1 <== NOT EXECUTED 30015c88: e3a02014 mov r2, #20 <== NOT EXECUTED 30015c8c: ebffd283 bl 3000a6a0 <_Internal_error_Occurred> <== NOT EXECUTED
30017684 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
30017684: e92d4011 push {r0, r4, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
30017688: e2514000 subs r4, r1, #0
return RTEMS_INVALID_NUMBER;
3001768c: 03a0000a moveq r0, #10
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
30017690: 0a000028 beq 30017738 <rtems_signal_send+0xb4>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
30017694: e1a0100d mov r1, sp 30017698: eb0010bd bl 3001b994 <_Thread_Get>
switch ( location ) {
3001769c: e59d3000 ldr r3, [sp] 300176a0: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300176a4: 13a00004 movne r0, #4
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
300176a8: 1a000022 bne 30017738 <rtems_signal_send+0xb4>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
300176ac: e59030f4 ldr r3, [r0, #244] ; 0xf4
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
300176b0: e593200c ldr r2, [r3, #12] 300176b4: e3520000 cmp r2, #0
300176b8: 0a00001c beq 30017730 <rtems_signal_send+0xac>
if ( asr->is_enabled ) {
300176bc: e5d32008 ldrb r2, [r3, #8] 300176c0: e3520000 cmp r2, #0
300176c4: 0a00000f beq 30017708 <rtems_signal_send+0x84>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300176c8: e10f2000 mrs r2, CPSR 300176cc: e3821080 orr r1, r2, #128 ; 0x80 300176d0: e129f001 msr CPSR_fc, r1
)
{
ISR_Level _level;
_ISR_Disable( _level );
*signal_set |= signals;
300176d4: e5931014 ldr r1, [r3, #20] 300176d8: e1814004 orr r4, r1, r4 300176dc: e5834014 str r4, [r3, #20]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300176e0: e129f002 msr CPSR_fc, r2
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
300176e4: e59f3050 ldr r3, [pc, #80] ; 3001773c <rtems_signal_send+0xb8> 300176e8: e5932000 ldr r2, [r3] 300176ec: e3520000 cmp r2, #0
300176f0: 0a00000b beq 30017724 <rtems_signal_send+0xa0>
300176f4: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 300176f8: e1500002 cmp r0, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
300176fc: 03a02001 moveq r2, #1 <== NOT EXECUTED 30017700: 05c32010 strbeq r2, [r3, #16] <== NOT EXECUTED 30017704: ea000006 b 30017724 <rtems_signal_send+0xa0> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30017708: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3001770c: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30017710: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 30017714: e5931018 ldr r1, [r3, #24] <== NOT EXECUTED 30017718: e1814004 orr r4, r1, r4 <== NOT EXECUTED 3001771c: e5834018 str r4, [r3, #24] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30017720: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
30017724: eb001091 bl 3001b970 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30017728: e3a00000 mov r0, #0 3001772c: ea000001 b 30017738 <rtems_signal_send+0xb4>
}
_Thread_Enable_dispatch();
30017730: eb00108e bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
30017734: e3a0000b mov r0, #11 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30017738: e8bd8018 pop {r3, r4, pc}
30005ca4 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
30005ca4: e92d4810 push {r4, fp, lr}
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
30005ca8: e59f3078 ldr r3, [pc, #120] ; 30005d28 <rtems_stack_checker_is_blown+0x84>
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
30005cac: e28db008 add fp, sp, #8
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
30005cb0: e5933004 ldr r3, [r3, #4]
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30005cb4: e59300b8 ldr r0, [r3, #184] ; 0xb8 30005cb8: e15b0000 cmp fp, r0
return false;
30005cbc: 33a04000 movcc r4, #0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30005cc0: 3a000004 bcc 30005cd8 <rtems_stack_checker_is_blown+0x34>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
30005cc4: e59340b4 ldr r4, [r3, #180] ; 0xb4 30005cc8: e0804004 add r4, r0, r4
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
30005ccc: e15b0004 cmp fp, r4 30005cd0: 83a04000 movhi r4, #0 30005cd4: 93a04001 movls r4, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
30005cd8: e59f304c ldr r3, [pc, #76] ; 30005d2c <rtems_stack_checker_is_blown+0x88> 30005cdc: e5933008 ldr r3, [r3, #8] 30005ce0: 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;
30005ce4: 03a01001 moveq r1, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
30005ce8: 0a000005 beq 30005d04 <rtems_stack_checker_is_blown+0x60>
pattern_ok = (!memcmp(
30005cec: e59f103c ldr r1, [pc, #60] ; 30005d30 <rtems_stack_checker_is_blown+0x8c> 30005cf0: e2800008 add r0, r0, #8 30005cf4: e3a02010 mov r2, #16 30005cf8: eb002c88 bl 30010f20 <memcmp> 30005cfc: e2701001 rsbs r1, r0, #1 30005d00: 33a01000 movcc r1, #0
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
30005d04: e3540000 cmp r4, #0
30005d08: 0a000001 beq 30005d14 <rtems_stack_checker_is_blown+0x70>
30005d0c: e3510000 cmp r1, #0
30005d10: 1a000002 bne 30005d20 <rtems_stack_checker_is_blown+0x7c>
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
30005d14: e59f300c ldr r3, [pc, #12] ; 30005d28 <rtems_stack_checker_is_blown+0x84><== NOT EXECUTED 30005d18: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 30005d1c: ebffff9d bl 30005b98 <Stack_check_report_blown_task> <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
30005d20: e3a00000 mov r0, #0
30005d24: e8bd8810 pop {r4, fp, pc}
30005d94 <rtems_stack_checker_report_usage>:
}
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
30005d94: e59f1004 ldr r1, [pc, #4] ; 30005da0 <rtems_stack_checker_report_usage+0xc><== NOT EXECUTED 30005d98: e3a00000 mov r0, #0 <== NOT EXECUTED 30005d9c: eaffffe4 b 30005d34 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
30005d34 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30005d34: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if ( !print )
30005d38: e2515000 subs r5, r1, #0 <== NOT EXECUTED
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30005d3c: e1a06000 mov r6, r0 <== NOT EXECUTED
if ( !print )
30005d40: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return;
print_context = context;
30005d44: e59f4038 ldr r4, [pc, #56] ; 30005d84 <rtems_stack_checker_report_usage_with_plugin+0x50><== NOT EXECUTED
print_handler = print;
(*print)( context, "Stack usage by thread\n");
30005d48: e59f1038 ldr r1, [pc, #56] ; 30005d88 <rtems_stack_checker_report_usage_with_plugin+0x54><== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
30005d4c: e5840004 str r0, [r4, #4] <== NOT EXECUTED
print_handler = print;
30005d50: e5845000 str r5, [r4] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
30005d54: e1a0e00f mov lr, pc <== NOT EXECUTED 30005d58: e12fff15 bx r5 <== NOT EXECUTED
(*print)( context,
30005d5c: e59f1028 ldr r1, [pc, #40] ; 30005d8c <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED 30005d60: e1a00006 mov r0, r6 <== NOT EXECUTED 30005d64: e1a0e00f mov lr, pc <== NOT EXECUTED 30005d68: e12fff15 bx r5 <== NOT EXECUTED
" ID NAME LOW HIGH CURRENT AVAILABLE USED\n"
);
/* iterate over all threads and dump the usage */
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
30005d6c: e59f001c ldr r0, [pc, #28] ; 30005d90 <rtems_stack_checker_report_usage_with_plugin+0x5c><== NOT EXECUTED 30005d70: eb00133c bl 3000aa68 <rtems_iterate_over_all_threads> <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
#endif
print_context = NULL;
30005d74: e3a03000 mov r3, #0 <== NOT EXECUTED 30005d78: e5843004 str r3, [r4, #4] <== NOT EXECUTED
print_handler = NULL;
30005d7c: e5843000 str r3, [r4] <== NOT EXECUTED
30005d80: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30005c40 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30005c40: e92d4830 push {r4, r5, fp, lr} <== NOT EXECUTED
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);
30005c44: e59030b8 ldr r3, [r0, #184] ; 0xb8 <== NOT EXECUTED
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30005c48: e28db00c add fp, sp, #12 <== NOT EXECUTED
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30005c4c: e15b0003 cmp fp, r3 <== NOT EXECUTED
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30005c50: e1a04000 mov r4, r0 <== NOT EXECUTED
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
30005c54: 33a05000 movcc r5, #0 <== NOT EXECUTED
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);
30005c58: e2830008 add r0, r3, #8 <== NOT EXECUTED
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30005c5c: 3a000004 bcc 30005c74 <rtems_stack_checker_switch_extension+0x34><== NOT EXECUTED
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
30005c60: e59450b4 ldr r5, [r4, #180] ; 0xb4 <== NOT EXECUTED 30005c64: e0835005 add r5, r3, r5 <== NOT EXECUTED
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
30005c68: e15b0005 cmp fp, r5 <== NOT EXECUTED 30005c6c: 83a05000 movhi r5, #0 <== NOT EXECUTED 30005c70: 93a05001 movls r5, #1 <== NOT EXECUTED
/*
* 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,
30005c74: e59f1024 ldr r1, [pc, #36] ; 30005ca0 <rtems_stack_checker_switch_extension+0x60><== NOT EXECUTED 30005c78: e3a02010 mov r2, #16 <== NOT EXECUTED 30005c7c: eb002ca7 bl 30010f20 <memcmp> <== NOT EXECUTED 30005c80: e2701001 rsbs r1, r0, #1 <== NOT EXECUTED 30005c84: 33a01000 movcc r1, #0 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
30005c88: e3550000 cmp r5, #0 <== NOT EXECUTED
30005c8c: 0a000001 beq 30005c98 <rtems_stack_checker_switch_extension+0x58><== NOT EXECUTED
30005c90: e3510000 cmp r1, #0 <== NOT EXECUTED
30005c94: 18bd8830 popne {r4, r5, fp, pc} <== NOT EXECUTED
Stack_check_report_blown_task( running, pattern_ok );
30005c98: e1a00004 mov r0, r4 <== NOT EXECUTED 30005c9c: ebffffbd bl 30005b98 <Stack_check_report_blown_task> <== NOT EXECUTED
3000a7c8 <rtems_status_text>:
const char *rtems_status_text(
rtems_status_code status
)
{
3000a7c8: e1a01000 mov r1, r0 <== NOT EXECUTED
return rtems_assoc_name_by_local(rtems_status_assoc, status);
3000a7cc: e59f0000 ldr r0, [pc, #0] ; 3000a7d4 <rtems_status_text+0xc><== NOT EXECUTED 3000a7d0: ea002076 b 300129b0 <rtems_assoc_name_by_local> <== NOT EXECUTED
3000f85c <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
3000f85c: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr}
double result;
char *end;
if ( !n )
3000f860: e2516000 subs r6, r1, #0
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
3000f864: e1a07000 mov r7, r0 3000f868: e1a08002 mov r8, r2
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3000f86c: 03a00009 moveq r0, #9
)
{
double result;
char *end;
if ( !n )
3000f870: 0a00002e beq 3000f930 <rtems_string_to_double+0xd4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
3000f874: eb00083b bl 30011968 <__errno> 3000f878: e3a03000 mov r3, #0 3000f87c: e5803000 str r3, [r0]
*n = 0;
3000f880: e3a04000 mov r4, #0
3000f884: e3a03000 mov r3, #0
3000f888: e8860018 stm r6, {r3, r4}
result = strtod( s, &end );
3000f88c: e1a00007 mov r0, r7 3000f890: e1a0100d mov r1, sp 3000f894: eb0013aa bl 30014744 <strtod>
if ( endptr )
3000f898: e3580000 cmp r8, #0
*endptr = end;
3000f89c: 159d3000 ldrne r3, [sp]
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
3000f8a0: e1a04000 mov r4, r0
if ( endptr )
*endptr = end;
3000f8a4: 15883000 strne r3, [r8]
if ( end == s )
3000f8a8: e59d3000 ldr r3, [sp]
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
3000f8ac: e1a05001 mov r5, r1
if ( endptr )
*endptr = end;
if ( end == s )
3000f8b0: e1530007 cmp r3, r7
return RTEMS_NOT_DEFINED;
3000f8b4: 03a0000b moveq r0, #11
result = strtod( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
3000f8b8: 0a00001c beq 3000f930 <rtems_string_to_double+0xd4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3000f8bc: eb000829 bl 30011968 <__errno> 3000f8c0: e5903000 ldr r3, [r0] 3000f8c4: e3530022 cmp r3, #34 ; 0x22
3000f8c8: 1a000014 bne 3000f920 <rtems_string_to_double+0xc4>
3000f8cc: e1a00004 mov r0, r4 3000f8d0: e1a01005 mov r1, r5 3000f8d4: e3a02000 mov r2, #0 3000f8d8: e3a03000 mov r3, #0 3000f8dc: ebffdeb5 bl 300073b8 <__cmpdf2> 3000f8e0: e3500000 cmp r0, #0
3000f8e4: 0a000010 beq 3000f92c <rtems_string_to_double+0xd0>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
3000f8e8: e1a00004 mov r0, r4 3000f8ec: e1a01005 mov r1, r5 3000f8f0: e3e02000 mvn r2, #0 3000f8f4: e59f3038 ldr r3, [pc, #56] ; 3000f934 <rtems_string_to_double+0xd8> 3000f8f8: ebffdeaa bl 300073a8 <__gedf2> 3000f8fc: e3500000 cmp r0, #0
3000f900: ca000009 bgt 3000f92c <rtems_string_to_double+0xd0>
3000f904: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f908: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f90c: e3e02000 mvn r2, #0 <== NOT EXECUTED 3000f910: e3e03601 mvn r3, #1048576 ; 0x100000 <== NOT EXECUTED 3000f914: ebffdea5 bl 300073b0 <__ledf2> <== NOT EXECUTED 3000f918: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f91c: ba000002 blt 3000f92c <rtems_string_to_double+0xd0> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
3000f920: e8860030 stm r6, {r4, r5}
return RTEMS_SUCCESSFUL;
3000f924: e3a00000 mov r0, #0 3000f928: ea000000 b 3000f930 <rtems_string_to_double+0xd4>
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
3000f92c: e3a0000a mov r0, #10
*n = result;
return RTEMS_SUCCESSFUL;
}
3000f930: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc}
3000f938 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
3000f938: e92d40f1 push {r0, r4, r5, r6, r7, lr}
float result;
char *end;
if ( !n )
3000f93c: e2516000 subs r6, r1, #0
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
3000f940: e1a04000 mov r4, r0 3000f944: e1a07002 mov r7, r2
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3000f948: 03a00009 moveq r0, #9
)
{
float result;
char *end;
if ( !n )
3000f94c: 0a000026 beq 3000f9ec <rtems_string_to_float+0xb4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
3000f950: eb000804 bl 30011968 <__errno> 3000f954: e3a03000 mov r3, #0 3000f958: e5803000 str r3, [r0]
*n = 0;
3000f95c: e3a03000 mov r3, #0 3000f960: e5863000 str r3, [r6]
result = strtof( s, &end );
3000f964: e1a00004 mov r0, r4 3000f968: e1a0100d mov r1, sp 3000f96c: eb00137b bl 30014760 <strtof>
if ( endptr )
3000f970: e3570000 cmp r7, #0
*endptr = end;
3000f974: 159d3000 ldrne r3, [sp]
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
3000f978: e1a05000 mov r5, r0
if ( endptr )
*endptr = end;
3000f97c: 15873000 strne r3, [r7]
if ( end == s )
3000f980: e59d3000 ldr r3, [sp] 3000f984: e1530004 cmp r3, r4
return RTEMS_NOT_DEFINED;
3000f988: 03a0000b moveq r0, #11
result = strtof( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
3000f98c: 0a000016 beq 3000f9ec <rtems_string_to_float+0xb4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3000f990: eb0007f4 bl 30011968 <__errno> 3000f994: e5903000 ldr r3, [r0] 3000f998: e3530022 cmp r3, #34 ; 0x22
3000f99c: 1a00000e bne 3000f9dc <rtems_string_to_float+0xa4>
3000f9a0: e1a00005 mov r0, r5 3000f9a4: e3a01000 mov r1, #0 3000f9a8: ebffdecd bl 300074e4 <__cmpsf2> 3000f9ac: e3500000 cmp r0, #0
3000f9b0: 0a00000c beq 3000f9e8 <rtems_string_to_float+0xb0>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
3000f9b4: e1a00005 mov r0, r5 3000f9b8: e59f1030 ldr r1, [pc, #48] ; 3000f9f0 <rtems_string_to_float+0xb8> 3000f9bc: ebffdec4 bl 300074d4 <__gesf2> 3000f9c0: e3500000 cmp r0, #0
3000f9c4: ca000007 bgt 3000f9e8 <rtems_string_to_float+0xb0>
3000f9c8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f9cc: e3e01502 mvn r1, #8388608 ; 0x800000 <== NOT EXECUTED 3000f9d0: ebffdec1 bl 300074dc <__lesf2> <== NOT EXECUTED 3000f9d4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f9d8: ba000002 blt 3000f9e8 <rtems_string_to_float+0xb0> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
3000f9dc: e5865000 str r5, [r6]
return RTEMS_SUCCESSFUL;
3000f9e0: e3a00000 mov r0, #0 3000f9e4: ea000000 b 3000f9ec <rtems_string_to_float+0xb4>
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
3000f9e8: e3a0000a mov r0, #10
*n = result;
return RTEMS_SUCCESSFUL;
}
3000f9ec: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
3000f9f4 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
3000f9f4: e92d40f1 push {r0, r4, r5, r6, r7, lr}
long result;
char *end;
if ( !n )
3000f9f8: e2516000 subs r6, r1, #0
const char *s,
int *n,
char **endptr,
int base
)
{
3000f9fc: e1a04000 mov r4, r0 3000fa00: e1a05002 mov r5, r2 3000fa04: e1a07003 mov r7, r3
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3000fa08: 03a00009 moveq r0, #9
)
{
long result;
char *end;
if ( !n )
3000fa0c: 0a00001c beq 3000fa84 <rtems_string_to_int+0x90>
return RTEMS_INVALID_ADDRESS;
errno = 0;
3000fa10: eb0007d4 bl 30011968 <__errno> 3000fa14: e3a03000 mov r3, #0 3000fa18: e5803000 str r3, [r0]
*n = 0;
result = strtol( s, &end, base );
3000fa1c: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
3000fa20: e5863000 str r3, [r6]
result = strtol( s, &end, base );
3000fa24: e1a00004 mov r0, r4 3000fa28: e1a0100d mov r1, sp 3000fa2c: eb0013cd bl 30014968 <strtol>
if ( endptr )
3000fa30: e3550000 cmp r5, #0
*endptr = end;
3000fa34: 159d3000 ldrne r3, [sp]
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
3000fa38: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
3000fa3c: 15853000 strne r3, [r5]
if ( end == s )
3000fa40: e59d3000 ldr r3, [sp] 3000fa44: e1530004 cmp r3, r4
return RTEMS_NOT_DEFINED;
3000fa48: 03a0000b moveq r0, #11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
3000fa4c: 0a00000c beq 3000fa84 <rtems_string_to_int+0x90>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3000fa50: eb0007c4 bl 30011968 <__errno> 3000fa54: e5903000 ldr r3, [r0] 3000fa58: e3530022 cmp r3, #34 ; 0x22
3000fa5c: 1a000004 bne 3000fa74 <rtems_string_to_int+0x80>
3000fa60: e3770106 cmn r7, #-2147483647 ; 0x80000001 3000fa64: 13570000 cmpne r7, #0
3000fa68: 0a000004 beq 3000fa80 <rtems_string_to_int+0x8c>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
3000fa6c: e3570102 cmp r7, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000fa70: 0a000002 beq 3000fa80 <rtems_string_to_int+0x8c> <== NOT EXECUTED
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
3000fa74: e5867000 str r7, [r6]
return RTEMS_SUCCESSFUL;
3000fa78: e3a00000 mov r0, #0 3000fa7c: ea000000 b 3000fa84 <rtems_string_to_int+0x90>
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
3000fa80: e3a0000a mov r0, #10
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
3000fa84: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
3000fbec <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
3000fbec: e92d40f1 push {r0, r4, r5, r6, r7, lr}
unsigned long result;
char *end;
if ( !n )
3000fbf0: e2516000 subs r6, r1, #0
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
3000fbf4: e1a04000 mov r4, r0 3000fbf8: e1a05002 mov r5, r2 3000fbfc: e1a07003 mov r7, r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3000fc00: 03a00009 moveq r0, #9
)
{
unsigned long result;
char *end;
if ( !n )
3000fc04: 0a00001e beq 3000fc84 <rtems_string_to_unsigned_char+0x98>
return RTEMS_INVALID_ADDRESS;
errno = 0;
3000fc08: eb000756 bl 30011968 <__errno> 3000fc0c: e3a03000 mov r3, #0 3000fc10: e5803000 str r3, [r0]
*n = 0;
result = strtoul( s, &end, base );
3000fc14: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
3000fc18: e5c63000 strb r3, [r6]
result = strtoul( s, &end, base );
3000fc1c: e1a00004 mov r0, r4 3000fc20: e1a0100d mov r1, sp 3000fc24: eb00147e bl 30014e24 <strtoul>
if ( endptr )
3000fc28: e3550000 cmp r5, #0
*endptr = end;
3000fc2c: 159d3000 ldrne r3, [sp]
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
3000fc30: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
3000fc34: 15853000 strne r3, [r5]
if ( end == s )
3000fc38: e59d3000 ldr r3, [sp] 3000fc3c: e1530004 cmp r3, r4
return RTEMS_NOT_DEFINED;
3000fc40: 03a0000b moveq r0, #11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
3000fc44: 0a00000e beq 3000fc84 <rtems_string_to_unsigned_char+0x98>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3000fc48: eb000746 bl 30011968 <__errno> 3000fc4c: e5903000 ldr r3, [r0] 3000fc50: e3530022 cmp r3, #34 ; 0x22
3000fc54: 1a000002 bne 3000fc64 <rtems_string_to_unsigned_char+0x78>
(( result == 0 ) || ( result == ULONG_MAX )))
3000fc58: e2473001 sub r3, r7, #1 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3000fc5c: e3730003 cmn r3, #3 <== NOT EXECUTED 3000fc60: 8a000006 bhi 3000fc80 <rtems_string_to_unsigned_char+0x94> <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
3000fc64: e35700ff cmp r7, #255 ; 0xff
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
3000fc68: 95c67000 strbls r7, [r6]
return RTEMS_SUCCESSFUL;
3000fc6c: 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 ) {
3000fc70: 9a000003 bls 3000fc84 <rtems_string_to_unsigned_char+0x98>
errno = ERANGE;
3000fc74: eb00073b bl 30011968 <__errno> <== NOT EXECUTED 3000fc78: e3a03022 mov r3, #34 ; 0x22 <== NOT EXECUTED 3000fc7c: e5803000 str r3, [r0] <== NOT EXECUTED
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
3000fc80: e3a0000a mov r0, #10 <== NOT EXECUTED
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
3000fc84: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
30006068 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
30006068: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000606c: e24ddf6b sub sp, sp, #428 ; 0x1ac
30006070: e58d1010 str r1, [sp, #16]
30006074: e58d2018 str r2, [sp, #24]
30006078: e58d000c str r0, [sp, #12]
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
3000607c: eb003aeb bl 30014c30 <strlen> 30006080: e3a02000 mov r2, #0 30006084: e1a01000 mov r1, r0 30006088: e28d3f65 add r3, sp, #404 ; 0x194 3000608c: e59d000c ldr r0, [sp, #12] 30006090: e58d2000 str r2, [sp] 30006094: eb00029b bl 30006b08 <rtems_filesystem_evaluate_path>
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
30006098: e2504000 subs r4, r0, #0
3000609c: 1a00006c bne 30006254 <rtems_tarfs_load+0x1ec>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
300060a0: e59d31a0 ldr r3, [sp, #416] ; 0x1a0 300060a4: e59f21c0 ldr r2, [pc, #448] ; 3000626c <rtems_tarfs_load+0x204> 300060a8: e1530002 cmp r3, r2
300060ac: 0a000005 beq 300060c8 <rtems_tarfs_load+0x60>
300060b0: e59f21b8 ldr r2, [pc, #440] ; 30006270 <rtems_tarfs_load+0x208><== NOT EXECUTED 300060b4: e1530002 cmp r3, r2 <== NOT EXECUTED 300060b8: 1a000065 bne 30006254 <rtems_tarfs_load+0x1ec> <== NOT EXECUTED 300060bc: ea000001 b 300060c8 <rtems_tarfs_load+0x60> <== NOT EXECUTED
300060c0: e1a08004 mov r8, r4 300060c4: ea000006 b 300060e4 <rtems_tarfs_load+0x7c>
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
300060c8: e28d2f65 add r2, sp, #404 ; 0x194
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
300060cc: e1a08004 mov r8, r4
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
300060d0: e28d7f47 add r7, sp, #284 ; 0x11c
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
300060d4: e28d9d06 add r9, sp, #384 ; 0x180 300060d8: e58d2004 str r2, [sp, #4]
* - 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);
300060dc: e28d501c add r5, sp, #28 300060e0: e1a0a004 mov sl, r4
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
300060e4: e59d3018 ldr r3, [sp, #24] 300060e8: e2884c02 add r4, r8, #512 ; 0x200 300060ec: e1540003 cmp r4, r3
300060f0: 8a000059 bhi 3000625c <rtems_tarfs_load+0x1f4>
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
300060f4: e59de010 ldr lr, [sp, #16]
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
300060f8: e59f1174 ldr r1, [pc, #372] ; 30006274 <rtems_tarfs_load+0x20c>
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
300060fc: e08e8008 add r8, lr, r8
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
30006100: e2880c01 add r0, r8, #256 ; 0x100 30006104: e2800001 add r0, r0, #1 30006108: e3a02005 mov r2, #5 3000610c: eb003adf bl 30014c90 <strncmp> 30006110: e2506000 subs r6, r0, #0
30006114: 1a000050 bne 3000625c <rtems_tarfs_load+0x1f4>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
30006118: e3a02063 mov r2, #99 ; 0x63 3000611c: e1a01008 mov r1, r8 30006120: e1a00007 mov r0, r7 30006124: eb003b3a bl 30014e14 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
30006128: e5cd617f strb r6, [sp, #383] ; 0x17f
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
3000612c: e3a01008 mov r1, #8 30006130: e2880064 add r0, r8, #100 ; 0x64
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
30006134: e5d8609c ldrb r6, [r8, #156] ; 0x9c
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
30006138: eb001e00 bl 3000d940 <_rtems_octal2ulong>
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
3000613c: 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);
30006140: e58d0014 str r0, [sp, #20]
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
30006144: e288007c add r0, r8, #124 ; 0x7c 30006148: eb001dfc bl 3000d940 <_rtems_octal2ulong>
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
3000614c: 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);
30006150: e1a0b000 mov fp, r0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
30006154: e2880094 add r0, r8, #148 ; 0x94 30006158: eb001df8 bl 3000d940 <_rtems_octal2ulong> 3000615c: e1a03000 mov r3, r0
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
30006160: e1a00008 mov r0, r8 30006164: e58d3008 str r3, [sp, #8] 30006168: eb001e02 bl 3000d978 <_rtems_tar_header_checksum> 3000616c: e59d3008 ldr r3, [sp, #8] 30006170: e1500003 cmp r0, r3
30006174: 1a000038 bne 3000625c <rtems_tarfs_load+0x1f4>
* 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) {
30006178: e3560035 cmp r6, #53 ; 0x35
3000617c: 1a000012 bne 300061cc <rtems_tarfs_load+0x164>
strcpy(full_filename, mountpoint);
30006180: e59d100c ldr r1, [sp, #12] 30006184: e1a00005 mov r0, r5 30006188: eb0038e4 bl 30014520 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
3000618c: e1a00005 mov r0, r5 30006190: eb003aa6 bl 30014c30 <strlen> 30006194: e28d2f6b add r2, sp, #428 ; 0x1ac 30006198: e0820000 add r0, r2, r0 3000619c: e5503191 ldrb r3, [r0, #-401] ; 0x191 300061a0: e353002f cmp r3, #47 ; 0x2f
strcat(full_filename, "/");
300061a4: 11a00005 movne r0, r5 300061a8: 159f10c8 ldrne r1, [pc, #200] ; 30006278 <rtems_tarfs_load+0x210> 300061ac: 1b003824 blne 30014244 <strcat>
strcat(full_filename, filename);
300061b0: e1a01007 mov r1, r7 300061b4: e1a00005 mov r0, r5 300061b8: eb003821 bl 30014244 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
300061bc: e1a00005 mov r0, r5 300061c0: e59f10b4 ldr r1, [pc, #180] ; 3000627c <rtems_tarfs_load+0x214> 300061c4: eb000464 bl 3000735c <mkdir> 300061c8: eaffffbc b 300060c0 <rtems_tarfs_load+0x58>
* IMFS_create_node was ONLY passed a NULL when we created the
* root node. We added a new IMFS_create_root_node() so this
* path no longer existed. The result was simpler code which
* should not have this path.
*/
else if (linkflag == REGTYPE) {
300061cc: e3560030 cmp r6, #48 ; 0x30
300061d0: 1affffba bne 300060c0 <rtems_tarfs_load+0x58>
const char *name;
loc = root_loc;
300061d4: e59dc004 ldr ip, [sp, #4]
300061d8: e1a0e009 mov lr, r9
300061dc: e8bc000f ldm ip!, {r0, r1, r2, r3}
300061e0: e8ae000f stmia lr!, {r0, r1, r2, r3}
300061e4: e59c2000 ldr r2, [ip]
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
300061e8: e1a00007 mov r0, r7
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
300061ec: e58e2000 str r2, [lr]
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
300061f0: e1a01009 mov r1, r9 300061f4: e28d2f6a add r2, sp, #424 ; 0x1a8 300061f8: eb0020a9 bl 3000e4a4 <IMFS_evaluate_for_make> 300061fc: e2506000 subs r6, r0, #0
30006200: 1a00000d bne 3000623c <rtems_tarfs_load+0x1d4>
node = IMFS_create_node(
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
30006204: e59d2014 ldr r2, [sp, #20]
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
30006208: e1a00009 mov r0, r9
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
3000620c: e1a03b82 lsl r3, r2, #23 30006210: e1a03ba3 lsr r3, r3, #23
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
30006214: e59d21a8 ldr r2, [sp, #424] ; 0x1a8 30006218: e3833902 orr r3, r3, #32768 ; 0x8000 3000621c: e3a01006 mov r1, #6 30006220: e58d6000 str r6, [sp] 30006224: eb001f1c bl 3000de9c <IMFS_create_node>
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
30006228: e59d2010 ldr r2, [sp, #16]
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
3000622c: e580b050 str fp, [r0, #80] ; 0x50
node->info.linearfile.direct = &tar_image[offset];
30006230: e0823004 add r3, r2, r4
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
30006234: e5806054 str r6, [r0, #84] ; 0x54
node->info.linearfile.direct = &tar_image[offset];
30006238: e5803058 str r3, [r0, #88] ; 0x58
}
nblocks = (((file_size) + 511) & ~511) / 512;
3000623c: e28bbf7f add fp, fp, #508 ; 0x1fc 30006240: e28bb003 add fp, fp, #3
offset += 512 * nblocks;
30006244: e3cbbf7f bic fp, fp, #508 ; 0x1fc 30006248: e3cbb003 bic fp, fp, #3 3000624c: e08b4004 add r4, fp, r4 30006250: eaffff9a b 300060c0 <rtems_tarfs_load+0x58>
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
return -1;
30006254: e3e04000 mvn r4, #0 <== NOT EXECUTED 30006258: ea000000 b 30006260 <rtems_tarfs_load+0x1f8> <== NOT EXECUTED
3000625c: e1a0400a mov r4, sl
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
30006260: e1a00004 mov r0, r4
30006264: e28ddf6b add sp, sp, #428 ; 0x1ac
30006268: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000979c <rtems_task_delete>:
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
3000979c: e92d4071 push {r0, r4, r5, r6, lr}
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
300097a0: e59f5068 ldr r5, [pc, #104] ; 30009810 <rtems_task_delete+0x74>
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
300097a4: e1a04000 mov r4, r0
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
300097a8: e5950000 ldr r0, [r5] 300097ac: eb00015b bl 30009d20 <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
300097b0: e1a00004 mov r0, r4 300097b4: e1a0100d mov r1, sp 300097b8: eb00080e bl 3000b7f8 <_Thread_Get>
switch ( location ) {
300097bc: e59d6000 ldr r6, [sp]
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
the_thread = _Thread_Get( id, &location );
300097c0: e1a04000 mov r4, r0
switch ( location ) {
300097c4: e3560000 cmp r6, #0
300097c8: 1a00000c bne 30009800 <rtems_task_delete+0x64>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
300097cc: e5900008 ldr r0, [r0, #8] 300097d0: eb0004ad bl 3000aa8c <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
300097d4: e1a01004 mov r1, r4 300097d8: eb000748 bl 3000b500 <_Thread_Close> 300097dc: e5940008 ldr r0, [r4, #8] 300097e0: eb0004a9 bl 3000aa8c <_Objects_Get_information_id> 300097e4: e1a01004 mov r1, r4 300097e8: eb00048a bl 3000aa18 <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
300097ec: e5950000 ldr r0, [r5] 300097f0: eb000163 bl 30009d84 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
300097f4: eb0007f6 bl 3000b7d4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300097f8: e1a00006 mov r0, r6 300097fc: ea000002 b 3000980c <rtems_task_delete+0x70>
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
30009800: e5950000 ldr r0, [r5] <== NOT EXECUTED 30009804: eb00015e bl 30009d84 <_API_Mutex_Unlock> <== NOT EXECUTED
return RTEMS_INVALID_ID;
30009808: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3000980c: e8bd8078 pop {r3, r4, r5, r6, pc}
3000b784 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000b784: e92d4071 push {r0, r4, r5, r6, lr}
3000b788: e1a05002 mov r5, r2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000b78c: e59f209c ldr r2, [pc, #156] ; 3000b830 <rtems_task_get_note+0xac>
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000b790: e1a03000 mov r3, r0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000b794: e5d22004 ldrb r2, [r2, #4]
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000b798: e1a04001 mov r4, r1
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000b79c: e3520000 cmp r2, #0
return RTEMS_NOT_CONFIGURED;
3000b7a0: 03a00016 moveq r0, #22
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000b7a4: 0a000020 beq 3000b82c <rtems_task_get_note+0xa8>
return RTEMS_NOT_CONFIGURED;
if ( !note )
3000b7a8: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3000b7ac: 03a00009 moveq r0, #9
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
3000b7b0: 0a00001d beq 3000b82c <rtems_task_get_note+0xa8>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000b7b4: e351000f cmp r1, #15
return RTEMS_INVALID_NUMBER;
3000b7b8: 83a0000a movhi r0, #10
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000b7bc: 8a00001a bhi 3000b82c <rtems_task_get_note+0xa8>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000b7c0: e3530000 cmp r3, #0
3000b7c4: 0a000004 beq 3000b7dc <rtems_task_get_note+0x58>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
3000b7c8: e59f2064 ldr r2, [pc, #100] ; 3000b834 <rtems_task_get_note+0xb0> 3000b7cc: e5922004 ldr r2, [r2, #4]
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000b7d0: e5922008 ldr r2, [r2, #8] 3000b7d4: e1530002 cmp r3, r2
3000b7d8: 1a000007 bne 3000b7fc <rtems_task_get_note+0x78>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
3000b7dc: e59f3050 ldr r3, [pc, #80] ; 3000b834 <rtems_task_get_note+0xb0><== NOT EXECUTED
*note = api->Notepads[ notepad ];
3000b7e0: e2844008 add r4, r4, #8 <== NOT EXECUTED
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
3000b7e4: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
3000b7e8: e3a00000 mov r0, #0 <== NOT EXECUTED
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
3000b7ec: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED 3000b7f0: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000b7f4: e5853000 str r3, [r5] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b7f8: ea00000b b 3000b82c <rtems_task_get_note+0xa8> <== NOT EXECUTED
}
the_thread = _Thread_Get( id, &location );
3000b7fc: e1a0100d mov r1, sp 3000b800: eb0008bd bl 3000dafc <_Thread_Get>
switch ( location ) {
3000b804: e59d6000 ldr r6, [sp] 3000b808: e3560000 cmp r6, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000b80c: 13a00004 movne r0, #4
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000b810: 1a000005 bne 3000b82c <rtems_task_get_note+0xa8>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
3000b814: e59030f4 ldr r3, [r0, #244] ; 0xf4 3000b818: e2844008 add r4, r4, #8 3000b81c: e7933104 ldr r3, [r3, r4, lsl #2] 3000b820: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
3000b824: eb0008ab bl 3000dad8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b828: e1a00006 mov r0, r6
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000b82c: e8bd8078 pop {r3, r4, r5, r6, pc}
30009814 <rtems_task_ident>:
rtems_id *id
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
30009814: e2523000 subs r3, r2, #0
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
rtems_id *id
)
{
30009818: e92d4010 push {r4, lr}
3000981c: e1a0c000 mov ip, r0
30009820: e1a04001 mov r4, r1
Objects_Name_or_id_lookup_errors status;
if ( !id )
30009824: 0a00000d beq 30009860 <rtems_task_ident+0x4c>
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
30009828: e3500000 cmp r0, #0
3000982c: 1a000004 bne 30009844 <rtems_task_ident+0x30>
*id = _Thread_Executing->Object.id;
30009830: e59f2030 ldr r2, [pc, #48] ; 30009868 <rtems_task_ident+0x54><== NOT EXECUTED 30009834: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 30009838: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000983c: e5832000 str r2, [r3] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30009840: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
30009844: e59f0020 ldr r0, [pc, #32] ; 3000986c <rtems_task_ident+0x58> 30009848: e1a0100c mov r1, ip 3000984c: e1a02004 mov r2, r4 30009850: eb000512 bl 3000aca0 <_Objects_Name_to_id_u32>
return _Status_Object_name_errors_to_status[ status ];
30009854: e59f3014 ldr r3, [pc, #20] ; 30009870 <rtems_task_ident+0x5c>
30009858: e7930100 ldr r0, [r3, r0, lsl #2]
3000985c: e8bd8010 pop {r4, pc}
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
return RTEMS_INVALID_ADDRESS;
30009860: e3a00009 mov r0, #9 <== NOT EXECUTED
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
return _Status_Object_name_errors_to_status[ status ];
}
30009864: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30017a94 <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
rtems_id id
)
{
30017a94: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
30017a98: e1a0100d mov r1, sp <== NOT EXECUTED 30017a9c: eb000fbc bl 3001b994 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30017aa0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30017aa4: e3530000 cmp r3, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30017aa8: 13a00004 movne r0, #4 <== NOT EXECUTED
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
30017aac: 1a000007 bne 30017ad0 <rtems_task_is_suspended+0x3c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
30017ab0: e5904010 ldr r4, [r0, #16] <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
30017ab4: e2144002 ands r4, r4, #2 <== NOT EXECUTED 30017ab8: 1a000002 bne 30017ac8 <rtems_task_is_suspended+0x34> <== NOT EXECUTED
_Thread_Enable_dispatch();
30017abc: eb000fab bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30017ac0: e1a00004 mov r0, r4 <== NOT EXECUTED 30017ac4: ea000001 b 30017ad0 <rtems_task_is_suspended+0x3c> <== NOT EXECUTED
}
_Thread_Enable_dispatch();
30017ac8: eb000fa8 bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_ALREADY_SUSPENDED;
30017acc: e3a0000f mov r0, #15 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30017ad0: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000a518 <rtems_task_restart>:
rtems_status_code rtems_task_restart(
rtems_id id,
uint32_t argument
)
{
3000a518: e92d4031 push {r0, r4, r5, lr}
3000a51c: e1a05001 mov r5, r1
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000a520: e1a0100d mov r1, sp 3000a524: eb0007df bl 3000c4a8 <_Thread_Get>
switch ( location ) {
3000a528: e59d4000 ldr r4, [sp] 3000a52c: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a530: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000a534: 1a000009 bne 3000a560 <rtems_task_restart+0x48>
case OBJECTS_LOCAL:
if ( _Thread_Restart( the_thread, NULL, argument ) ) {
3000a538: e1a01004 mov r1, r4 3000a53c: e1a02005 mov r2, r5 3000a540: eb0009cb bl 3000cc74 <_Thread_Restart> 3000a544: e3500000 cmp r0, #0
3000a548: 0a000002 beq 3000a558 <rtems_task_restart+0x40>
_Thread_Enable_dispatch();
3000a54c: eb0007cc bl 3000c484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a550: e1a00004 mov r0, r4 3000a554: ea000001 b 3000a560 <rtems_task_restart+0x48>
}
_Thread_Enable_dispatch();
3000a558: eb0007c9 bl 3000c484 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000a55c: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000a560: e8bd8038 pop {r3, r4, r5, pc}
3000cc60 <rtems_task_resume>:
*/
rtems_status_code rtems_task_resume(
rtems_id id
)
{
3000cc60: e92d4011 push {r0, r4, lr}
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000cc64: e1a0100d mov r1, sp 3000cc68: eb0007f6 bl 3000ec48 <_Thread_Get>
switch ( location ) {
3000cc6c: e59d4000 ldr r4, [sp]
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000cc70: e1a03000 mov r3, r0
switch ( location ) {
3000cc74: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000cc78: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000cc7c: 1a000009 bne 3000cca8 <rtems_task_resume+0x48>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3000cc80: e5933010 ldr r3, [r3, #16]
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
3000cc84: e3130002 tst r3, #2
3000cc88: 0a000004 beq 3000cca0 <rtems_task_resume+0x40>
_Thread_Resume( the_thread );
3000cc8c: e3a01002 mov r1, #2 3000cc90: eb00071e bl 3000e910 <_Thread_Clear_state>
_Thread_Enable_dispatch();
3000cc94: eb0007e2 bl 3000ec24 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000cc98: e1a00004 mov r0, r4 3000cc9c: ea000001 b 3000cca8 <rtems_task_resume+0x48>
}
_Thread_Enable_dispatch();
3000cca0: eb0007df bl 3000ec24 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000cca4: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000cca8: e8bd8018 pop {r3, r4, pc}
3000b918 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000b918: e92d4071 push {r0, r4, r5, r6, lr}
3000b91c: e1a05002 mov r5, r2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000b920: e59f2088 ldr r2, [pc, #136] ; 3000b9b0 <rtems_task_set_note+0x98>
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000b924: e1a03000 mov r3, r0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000b928: e5d22004 ldrb r2, [r2, #4]
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000b92c: e1a04001 mov r4, r1
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000b930: e3520000 cmp r2, #0
return RTEMS_NOT_CONFIGURED;
3000b934: 03a00016 moveq r0, #22
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000b938: 0a00001b beq 3000b9ac <rtems_task_set_note+0x94>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000b93c: e351000f cmp r1, #15
return RTEMS_INVALID_NUMBER;
3000b940: 83a0000a movhi r0, #10
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000b944: 8a000018 bhi 3000b9ac <rtems_task_set_note+0x94>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000b948: e3530000 cmp r3, #0
3000b94c: 0a000004 beq 3000b964 <rtems_task_set_note+0x4c>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
3000b950: e59f205c ldr r2, [pc, #92] ; 3000b9b4 <rtems_task_set_note+0x9c> 3000b954: e5922004 ldr r2, [r2, #4]
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000b958: e5922008 ldr r2, [r2, #8] 3000b95c: e1530002 cmp r3, r2
3000b960: 1a000006 bne 3000b980 <rtems_task_set_note+0x68>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
3000b964: e59f3048 ldr r3, [pc, #72] ; 3000b9b4 <rtems_task_set_note+0x9c><== NOT EXECUTED
api->Notepads[ notepad ] = note;
3000b968: e2844008 add r4, r4, #8 <== NOT EXECUTED
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
3000b96c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
3000b970: e3a00000 mov r0, #0 <== NOT EXECUTED
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
3000b974: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED 3000b978: e7835104 str r5, [r3, r4, lsl #2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b97c: ea00000a b 3000b9ac <rtems_task_set_note+0x94> <== NOT EXECUTED
}
the_thread = _Thread_Get( id, &location );
3000b980: e1a0100d mov r1, sp 3000b984: eb00085c bl 3000dafc <_Thread_Get>
switch ( location ) {
3000b988: e59d6000 ldr r6, [sp] 3000b98c: e3560000 cmp r6, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000b990: 13a00004 movne r0, #4
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000b994: 1a000004 bne 3000b9ac <rtems_task_set_note+0x94>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
3000b998: e59030f4 ldr r3, [r0, #244] ; 0xf4 3000b99c: e2844008 add r4, r4, #8 3000b9a0: e7835104 str r5, [r3, r4, lsl #2]
_Thread_Enable_dispatch();
3000b9a4: eb00084b bl 3000dad8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b9a8: e1a00006 mov r0, r6
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000b9ac: e8bd8078 pop {r3, r4, r5, r6, pc}
3000da24 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
3000da24: e92d4031 push {r0, r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000da28: e2514000 subs r4, r1, #0
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
3000da2c: e1a05002 mov r5, r2
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000da30: 0a000004 beq 3000da48 <rtems_task_set_priority+0x24>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
3000da34: e59f3074 ldr r3, [pc, #116] ; 3000dab0 <rtems_task_set_priority+0x8c> 3000da38: e5d33000 ldrb r3, [r3] 3000da3c: e1540003 cmp r4, r3
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
3000da40: 83a00013 movhi r0, #19
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000da44: 8a000018 bhi 3000daac <rtems_task_set_priority+0x88>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
3000da48: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3000da4c: 03a00009 moveq r0, #9
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
3000da50: 0a000015 beq 3000daac <rtems_task_set_priority+0x88>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
3000da54: e1a0100d mov r1, sp 3000da58: eb000855 bl 3000fbb4 <_Thread_Get>
switch ( location ) {
3000da5c: e59d3000 ldr r3, [sp] 3000da60: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000da64: 13a00004 movne r0, #4
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000da68: 1a00000f bne 3000daac <rtems_task_set_priority+0x88>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
3000da6c: e5903014 ldr r3, [r0, #20]
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
3000da70: e3540000 cmp r4, #0
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
3000da74: e5853000 str r3, [r5]
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
3000da78: 0a000009 beq 3000daa4 <rtems_task_set_priority+0x80>
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
3000da7c: e590301c ldr r3, [r0, #28]
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
the_thread->real_priority = new_priority;
3000da80: e5804018 str r4, [r0, #24]
if ( the_thread->resource_count == 0 ||
3000da84: e3530000 cmp r3, #0
3000da88: 0a000002 beq 3000da98 <rtems_task_set_priority+0x74>
3000da8c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000da90: e1530004 cmp r3, r4 <== NOT EXECUTED 3000da94: 9a000002 bls 3000daa4 <rtems_task_set_priority+0x80> <== NOT EXECUTED
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
3000da98: e1a01004 mov r1, r4 3000da9c: e3a02000 mov r2, #0 3000daa0: eb000736 bl 3000f780 <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
3000daa4: eb000839 bl 3000fb90 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000daa8: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000daac: e8bd8038 pop {r3, r4, r5, pc}
300098f4 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
300098f4: e92d4073 push {r0, r1, r4, r5, r6, lr}
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
300098f8: e2515000 subs r5, r1, #0
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
300098fc: e1a06002 mov r6, r2
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
30009900: 03a00009 moveq r0, #9
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
30009904: 0a000011 beq 30009950 <rtems_task_start+0x5c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
30009908: e28d1004 add r1, sp, #4 3000990c: eb0007b9 bl 3000b7f8 <_Thread_Get>
switch ( location ) {
30009910: e59d4004 ldr r4, [sp, #4] 30009914: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009918: 13a00004 movne r0, #4
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000991c: 1a00000b bne 30009950 <rtems_task_start+0x5c>
case OBJECTS_LOCAL:
if ( _Thread_Start(
30009920: e1a01004 mov r1, r4 30009924: e1a02005 mov r2, r5 30009928: e1a03004 mov r3, r4 3000992c: e58d6000 str r6, [sp] 30009930: eb0009fc bl 3000c128 <_Thread_Start> 30009934: e3500000 cmp r0, #0
30009938: 0a000002 beq 30009948 <rtems_task_start+0x54>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
3000993c: eb0007a4 bl 3000b7d4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30009940: e1a00004 mov r0, r4 30009944: ea000001 b 30009950 <rtems_task_start+0x5c>
}
_Thread_Enable_dispatch();
30009948: eb0007a1 bl 3000b7d4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000994c: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30009950: e8bd807c pop {r2, r3, r4, r5, r6, pc}
3000cec4 <rtems_task_suspend>:
*/
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
3000cec4: e92d4011 push {r0, r4, lr}
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000cec8: e1a0100d mov r1, sp 3000cecc: eb0007c6 bl 3000edec <_Thread_Get>
switch ( location ) {
3000ced0: e59d2000 ldr r2, [sp]
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000ced4: e1a03000 mov r3, r0
switch ( location ) {
3000ced8: e3520000 cmp r2, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000cedc: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000cee0: 1a000009 bne 3000cf0c <rtems_task_suspend+0x48>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3000cee4: e5934010 ldr r4, [r3, #16]
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
3000cee8: e2144002 ands r4, r4, #2
3000ceec: 1a000004 bne 3000cf04 <rtems_task_suspend+0x40>
_Thread_Suspend( the_thread );
3000cef0: e3a01002 mov r1, #2 3000cef4: eb0009b6 bl 3000f5d4 <_Thread_Set_state>
_Thread_Enable_dispatch();
3000cef8: eb0007b2 bl 3000edc8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000cefc: e1a00004 mov r0, r4 3000cf00: ea000001 b 3000cf0c <rtems_task_suspend+0x48>
}
_Thread_Enable_dispatch();
3000cf04: eb0007af bl 3000edc8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_ALREADY_SUSPENDED;
3000cf08: e3a0000f mov r0, #15 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000cf0c: e8bd8018 pop {r3, r4, pc}
3000a600 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
3000a600: e92d40f1 push {r0, r4, r5, r6, r7, lr}
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
3000a604: e2514000 subs r4, r1, #0
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
3000a608: e1a05002 mov r5, r2
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
3000a60c: 03a00009 moveq r0, #9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
3000a610: 0a000023 beq 3000a6a4 <rtems_task_variable_add+0xa4>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
3000a614: e1a0100d mov r1, sp 3000a618: eb0007f6 bl 3000c5f8 <_Thread_Get>
switch (location) {
3000a61c: e59d3000 ldr r3, [sp]
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
3000a620: e1a07000 mov r7, r0
switch (location) {
3000a624: e3530000 cmp r3, #0
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
3000a628: 05906100 ldreq r6, [r0, #256] ; 0x100
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
3000a62c: 0a000008 beq 3000a654 <rtems_task_variable_add+0x54>
3000a630: ea00001a b 3000a6a0 <rtems_task_variable_add+0xa0> <== NOT EXECUTED
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
3000a634: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED 3000a638: e1530004 cmp r3, r4 <== NOT EXECUTED 3000a63c: 1a000003 bne 3000a650 <rtems_task_variable_add+0x50> <== NOT EXECUTED
tvp->dtor = dtor;
3000a640: e5865010 str r5, [r6, #16] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a644: eb0007e2 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a648: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a64c: ea000014 b 3000a6a4 <rtems_task_variable_add+0xa4> <== NOT EXECUTED
}
tvp = (rtems_task_variable_t *)tvp->next;
3000a650: e5966000 ldr r6, [r6] <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
3000a654: e3560000 cmp r6, #0
3000a658: 1afffff5 bne 3000a634 <rtems_task_variable_add+0x34>
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
3000a65c: e3a00014 mov r0, #20 3000a660: eb000be6 bl 3000d600 <_Workspace_Allocate>
if (new == NULL) {
3000a664: e3500000 cmp r0, #0
3000a668: 1a000002 bne 3000a678 <rtems_task_variable_add+0x78>
_Thread_Enable_dispatch();
3000a66c: eb0007d8 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
3000a670: e3a0001a mov r0, #26 <== NOT EXECUTED 3000a674: ea00000a b 3000a6a4 <rtems_task_variable_add+0xa4> <== NOT EXECUTED
}
new->gval = *ptr;
3000a678: e5943000 ldr r3, [r4]
new->ptr = ptr;
3000a67c: e5804004 str r4, [r0, #4]
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
3000a680: e5803008 str r3, [r0, #8]
new->ptr = ptr;
new->dtor = dtor;
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
3000a684: e5973100 ldr r3, [r7, #256] ; 0x100
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
new->ptr = ptr;
new->dtor = dtor;
3000a688: e5805010 str r5, [r0, #16]
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
3000a68c: e5803000 str r3, [r0]
the_thread->task_variables = new;
3000a690: e5870100 str r0, [r7, #256] ; 0x100
_Thread_Enable_dispatch();
3000a694: eb0007ce bl 3000c5d4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a698: e1a00006 mov r0, r6 3000a69c: ea000000 b 3000a6a4 <rtems_task_variable_add+0xa4>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a6a0: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3000a6a4: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
3000a6a8 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
3000a6a8: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
3000a6ac: e2514000 subs r4, r1, #0 <== NOT EXECUTED 3000a6b0: 0a000016 beq 3000a710 <rtems_task_variable_delete+0x68> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
3000a6b4: e1a0100d mov r1, sp <== NOT EXECUTED 3000a6b8: eb0007ce bl 3000c5f8 <_Thread_Get> <== NOT EXECUTED
switch (location) {
3000a6bc: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a6c0: e3530000 cmp r3, #0 <== NOT EXECUTED
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
3000a6c4: 05901100 ldreq r1, [r0, #256] ; 0x100 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
switch (location) {
3000a6c8: 0a00000d beq 3000a704 <rtems_task_variable_delete+0x5c> <== NOT EXECUTED 3000a6cc: ea000011 b 3000a718 <rtems_task_variable_delete+0x70> <== NOT EXECUTED
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
3000a6d0: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED 3000a6d4: e1520004 cmp r2, r4 <== NOT EXECUTED 3000a6d8: 1a000007 bne 3000a6fc <rtems_task_variable_delete+0x54> <== NOT EXECUTED 3000a6dc: e5912000 ldr r2, [r1] <== NOT EXECUTED
if (prev)
3000a6e0: e3530000 cmp r3, #0 <== NOT EXECUTED
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
3000a6e4: 05802100 streq r2, [r0, #256] ; 0x100 <== NOT EXECUTED
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
3000a6e8: 15832000 strne r2, [r3] <== NOT EXECUTED
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
3000a6ec: eb000028 bl 3000a794 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
_Thread_Enable_dispatch();
3000a6f0: eb0007b7 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a6f4: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a6f8: ea000007 b 3000a71c <rtems_task_variable_delete+0x74> <== NOT EXECUTED
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
3000a6fc: e1a03001 mov r3, r1 <== NOT EXECUTED 3000a700: e5911000 ldr r1, [r1] <== NOT EXECUTED
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
3000a704: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a708: 1afffff0 bne 3000a6d0 <rtems_task_variable_delete+0x28> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
3000a70c: eb0007b0 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
3000a710: e3a00009 mov r0, #9 <== NOT EXECUTED 3000a714: ea000000 b 3000a71c <rtems_task_variable_delete+0x74> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a718: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3000a71c: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000a720 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
3000a720: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
3000a724: e2515000 subs r5, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
3000a728: e1a04002 mov r4, r2 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
3000a72c: 0a000014 beq 3000a784 <rtems_task_variable_get+0x64> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !result )
3000a730: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a734: 0a000012 beq 3000a784 <rtems_task_variable_get+0x64> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
3000a738: e1a0100d mov r1, sp <== NOT EXECUTED 3000a73c: eb0007ad bl 3000c5f8 <_Thread_Get> <== NOT EXECUTED
switch (location) {
3000a740: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a744: e3530000 cmp r3, #0 <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
3000a748: 05903100 ldreq r3, [r0, #256] ; 0x100 <== NOT EXECUTED
if ( !result )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
3000a74c: 0a000009 beq 3000a778 <rtems_task_variable_get+0x58> <== NOT EXECUTED 3000a750: ea00000d b 3000a78c <rtems_task_variable_get+0x6c> <== NOT EXECUTED
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
3000a754: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000a758: e1520005 cmp r2, r5 <== NOT EXECUTED 3000a75c: 1a000004 bne 3000a774 <rtems_task_variable_get+0x54> <== NOT EXECUTED
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
3000a760: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 3000a764: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a768: eb000799 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a76c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a770: ea000006 b 3000a790 <rtems_task_variable_get+0x70> <== NOT EXECUTED
}
tvp = (rtems_task_variable_t *)tvp->next;
3000a774: e5933000 ldr r3, [r3] <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
3000a778: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a77c: 1afffff4 bne 3000a754 <rtems_task_variable_get+0x34> <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
3000a780: eb000793 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
3000a784: e3a00009 mov r0, #9 <== NOT EXECUTED 3000a788: ea000000 b 3000a790 <rtems_task_variable_get+0x70> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a78c: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3000a790: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30009954 <rtems_task_wake_after>:
30009954: e59f3074 ldr r3, [pc, #116] ; 300099d0 <rtems_task_wake_after+0x7c>
*/
rtems_status_code rtems_task_wake_after(
rtems_interval ticks
)
{
30009958: e92d4030 push {r4, r5, lr}
3000995c: e5932000 ldr r2, [r3]
30009960: e1a04000 mov r4, r0
30009964: e2822001 add r2, r2, #1
30009968: e5832000 str r2, [r3]
_Thread_Disable_dispatch();
if ( ticks == 0 ) {
3000996c: e3500000 cmp r0, #0
30009970: 1a000003 bne 30009984 <rtems_task_wake_after+0x30>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
30009974: e59f3058 ldr r3, [pc, #88] ; 300099d4 <rtems_task_wake_after+0x80> 30009978: e1a0e00f mov lr, pc 3000997c: e593f00c ldr pc, [r3, #12] 30009980: ea00000f b 300099c4 <rtems_task_wake_after+0x70>
_Scheduler_Yield();
} else {
_Thread_Set_state( _Thread_Executing, STATES_DELAYING );
30009984: e59f504c ldr r5, [pc, #76] ; 300099d8 <rtems_task_wake_after+0x84><== NOT EXECUTED 30009988: e3a01008 mov r1, #8 <== NOT EXECUTED 3000998c: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 30009990: eb000992 bl 3000bfe0 <_Thread_Set_state> <== NOT EXECUTED
_Watchdog_Initialize(
&_Thread_Executing->Timer,
30009994: e5951004 ldr r1, [r5, #4] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30009998: e59f003c ldr r0, [pc, #60] ; 300099dc <rtems_task_wake_after+0x88><== NOT EXECUTED
_Thread_Disable_dispatch();
if ( ticks == 0 ) {
_Scheduler_Yield();
} else {
_Thread_Set_state( _Thread_Executing, STATES_DELAYING );
_Watchdog_Initialize(
3000999c: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
300099a0: e3a03000 mov r3, #0 <== NOT EXECUTED
the_watchdog->routine = routine;
300099a4: e5810064 str r0, [r1, #100] ; 0x64 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
300099a8: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id;
300099ac: e5812068 str r2, [r1, #104] ; 0x68 <== NOT EXECUTED
the_watchdog->user_data = user_data;
300099b0: e581306c str r3, [r1, #108] ; 0x6c <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
300099b4: e5814054 str r4, [r1, #84] ; 0x54 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
300099b8: e59f0020 ldr r0, [pc, #32] ; 300099e0 <rtems_task_wake_after+0x8c><== NOT EXECUTED 300099bc: e2811048 add r1, r1, #72 ; 0x48 <== NOT EXECUTED 300099c0: eb000ad3 bl 3000c514 <_Watchdog_Insert> <== NOT EXECUTED
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
}
_Thread_Enable_dispatch();
300099c4: eb000782 bl 3000b7d4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL; }
300099c8: e3a00000 mov r0, #0
300099cc: e8bd8030 pop {r4, r5, pc}
3000ab88 <rtems_task_wake_when>:
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000ab88: e59f30bc ldr r3, [pc, #188] ; 3000ac4c <rtems_task_wake_when+0xc4>
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
3000ab8c: e92d40f0 push {r4, r5, r6, r7, lr}
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000ab90: e5d33000 ldrb r3, [r3]
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
3000ab94: e1a05000 mov r5, r0
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000ab98: e3530000 cmp r3, #0
return RTEMS_NOT_DEFINED;
3000ab9c: 03a0000b moveq r0, #11
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000aba0: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
3000aba4: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3000aba8: 03a00009 moveq r0, #9
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
3000abac: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
3000abb0: e3a04000 mov r4, #0 3000abb4: e5854018 str r4, [r5, #24]
if ( !_TOD_Validate( time_buffer ) )
3000abb8: ebfffd1a bl 3000a028 <_TOD_Validate> 3000abbc: e1500004 cmp r0, r4
return RTEMS_INVALID_CLOCK;
3000abc0: 03a00014 moveq r0, #20
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
3000abc4: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
3000abc8: e1a00005 mov r0, r5 3000abcc: ebfffcf2 bl 30009f9c <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
3000abd0: e59f6078 ldr r6, [pc, #120] ; 3000ac50 <rtems_task_wake_when+0xc8>
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
3000abd4: e1a05000 mov r5, r0
if ( seconds <= _TOD_Seconds_since_epoch() )
3000abd8: e5963000 ldr r3, [r6] 3000abdc: e1500003 cmp r0, r3
3000abe0: 9a000017 bls 3000ac44 <rtems_task_wake_when+0xbc>
3000abe4: e59f3068 ldr r3, [pc, #104] ; 3000ac54 <rtems_task_wake_when+0xcc> 3000abe8: e5932000 ldr r2, [r3] 3000abec: e2822001 add r2, r2, #1 3000abf0: e5832000 str r2, [r3]
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
3000abf4: e59f705c ldr r7, [pc, #92] ; 3000ac58 <rtems_task_wake_when+0xd0> 3000abf8: e3a01010 mov r1, #16 3000abfc: e5970004 ldr r0, [r7, #4] 3000ac00: eb0009a1 bl 3000d28c <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3000ac04: e5971004 ldr r1, [r7, #4]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000ac08: e59f204c ldr r2, [pc, #76] ; 3000ac5c <rtems_task_wake_when+0xd4>
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
_Watchdog_Initialize(
3000ac0c: e5913008 ldr r3, [r1, #8] 3000ac10: e5812064 str r2, [r1, #100] ; 0x64
the_watchdog->id = id;
3000ac14: e5813068 str r3, [r1, #104] ; 0x68
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
3000ac18: e5963000 ldr r3, [r6]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000ac1c: e59f003c ldr r0, [pc, #60] ; 3000ac60 <rtems_task_wake_when+0xd8> 3000ac20: e0635005 rsb r5, r3, r5
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000ac24: e5814050 str r4, [r1, #80] ; 0x50
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3000ac28: e581406c str r4, [r1, #108] ; 0x6c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000ac2c: e5815054 str r5, [r1, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000ac30: e2811048 add r1, r1, #72 ; 0x48 3000ac34: eb000b09 bl 3000d860 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
3000ac38: eb000790 bl 3000ca80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ac3c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000ac40: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
3000ac44: e3a00014 mov r0, #20 <== NOT EXECUTED
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000ac48: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30008e28 <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30008e28: e3500009 cmp r0, #9 <== NOT EXECUTED 30008e2c: 012fff1e bxeq lr <== NOT EXECUTED 30008e30: ca000016 bgt 30008e90 <rtems_termios_baud_to_index+0x68> <== NOT EXECUTED 30008e34: e3500004 cmp r0, #4 <== NOT EXECUTED 30008e38: 012fff1e bxeq lr <== NOT EXECUTED 30008e3c: ca00000a bgt 30008e6c <rtems_termios_baud_to_index+0x44> <== NOT EXECUTED 30008e40: e3500001 cmp r0, #1 <== NOT EXECUTED 30008e44: 012fff1e bxeq lr <== NOT EXECUTED 30008e48: ca000002 bgt 30008e58 <rtems_termios_baud_to_index+0x30> <== NOT EXECUTED 30008e4c: e3500000 cmp r0, #0 <== NOT EXECUTED 30008e50: 012fff1e bxeq lr <== NOT EXECUTED 30008e54: ea000030 b 30008f1c <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED 30008e58: e3500002 cmp r0, #2 <== NOT EXECUTED 30008e5c: 012fff1e bxeq lr <== NOT EXECUTED 30008e60: e3500003 cmp r0, #3 <== NOT EXECUTED 30008e64: 1a00002c bne 30008f1c <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED 30008e68: e12fff1e bx lr <== NOT EXECUTED 30008e6c: e3500006 cmp r0, #6 <== NOT EXECUTED 30008e70: 012fff1e bxeq lr <== NOT EXECUTED
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
30008e74: b3a00005 movlt r0, #5 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30008e78: b12fff1e bxlt lr <== NOT EXECUTED 30008e7c: e3500007 cmp r0, #7 <== NOT EXECUTED 30008e80: 012fff1e bxeq lr <== NOT EXECUTED 30008e84: e3500008 cmp r0, #8 <== NOT EXECUTED 30008e88: 1a000023 bne 30008f1c <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED 30008e8c: e12fff1e bx lr <== NOT EXECUTED 30008e90: e350000e cmp r0, #14 <== NOT EXECUTED 30008e94: 012fff1e bxeq lr <== NOT EXECUTED 30008e98: ca000008 bgt 30008ec0 <rtems_termios_baud_to_index+0x98> <== NOT EXECUTED 30008e9c: e350000b cmp r0, #11 <== NOT EXECUTED 30008ea0: 012fff1e bxeq lr <== NOT EXECUTED
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
30008ea4: b3a0000a movlt r0, #10 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30008ea8: b12fff1e bxlt lr <== NOT EXECUTED 30008eac: e350000c cmp r0, #12 <== NOT EXECUTED 30008eb0: 012fff1e bxeq lr <== NOT EXECUTED 30008eb4: e350000d cmp r0, #13 <== NOT EXECUTED 30008eb8: 1a000017 bne 30008f1c <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED 30008ebc: e12fff1e bx lr <== NOT EXECUTED 30008ec0: e59f305c ldr r3, [pc, #92] ; 30008f24 <rtems_termios_baud_to_index+0xfc><== NOT EXECUTED 30008ec4: e1500003 cmp r0, r3 <== NOT EXECUTED
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
30008ec8: 03a00011 moveq r0, #17 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30008ecc: 012fff1e bxeq lr <== NOT EXECUTED 30008ed0: ca000005 bgt 30008eec <rtems_termios_baud_to_index+0xc4> <== NOT EXECUTED 30008ed4: e350000f cmp r0, #15 <== NOT EXECUTED 30008ed8: 012fff1e bxeq lr <== NOT EXECUTED 30008edc: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30008ee0: e1500003 cmp r0, r3 <== NOT EXECUTED 30008ee4: 1a00000c bne 30008f1c <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED 30008ee8: ea000007 b 30008f0c <rtems_termios_baud_to_index+0xe4> <== NOT EXECUTED 30008eec: e59f3034 ldr r3, [pc, #52] ; 30008f28 <rtems_termios_baud_to_index+0x100><== NOT EXECUTED 30008ef0: e1500003 cmp r0, r3 <== NOT EXECUTED
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
30008ef4: 03a00012 moveq r0, #18 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30008ef8: 012fff1e bxeq lr <== NOT EXECUTED 30008efc: e2833001 add r3, r3, #1 <== NOT EXECUTED 30008f00: e1500003 cmp r0, r3 <== NOT EXECUTED 30008f04: 1a000004 bne 30008f1c <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED 30008f08: ea000001 b 30008f14 <rtems_termios_baud_to_index+0xec> <== NOT EXECUTED
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
30008f0c: e3a00010 mov r0, #16 <== NOT EXECUTED 30008f10: e12fff1e bx lr <== NOT EXECUTED
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
30008f14: e3a00013 mov r0, #19 <== NOT EXECUTED 30008f18: e12fff1e bx lr <== NOT EXECUTED
default: baud_index = -1; break;
30008f1c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return baud_index;
}
30008f20: e12fff1e bx lr <== NOT EXECUTED
30008f2c <rtems_termios_baud_to_number>:
extern rtems_assoc_t termios_assoc_table[];
int32_t rtems_termios_baud_to_number(
int termios_baud
)
{
30008f2c: e92d4010 push {r4, lr} <== NOT EXECUTED
30008f30: e1a04000 mov r4, r0 <== NOT EXECUTED
int baud;
baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud );
30008f34: e1a01004 mov r1, r4 <== NOT EXECUTED 30008f38: e59f001c ldr r0, [pc, #28] ; 30008f5c <rtems_termios_baud_to_number+0x30><== NOT EXECUTED 30008f3c: eb001a99 bl 3000f9a8 <rtems_assoc_local_by_remote> <== NOT EXECUTED
if ( baud == 0 && termios_baud != 0 )
30008f40: e2703001 rsbs r3, r0, #1 <== NOT EXECUTED 30008f44: 33a03000 movcc r3, #0 <== NOT EXECUTED 30008f48: e3540000 cmp r4, #0 <== NOT EXECUTED 30008f4c: 03a03000 moveq r3, #0 <== NOT EXECUTED 30008f50: e3530000 cmp r3, #0 <== NOT EXECUTED
return -1;
return baud;
}
30008f54: 13e00000 mvnne r0, #0 <== NOT EXECUTED
30008f58: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30007784 <rtems_termios_bufsize>:
int cbufsize,
int raw_input,
int raw_output
)
{
rtems_termios_cbufsize = cbufsize;
30007784: e59f300c ldr r3, [pc, #12] ; 30007798 <rtems_termios_bufsize+0x14><== NOT EXECUTED 30007788: e5830008 str r0, [r3, #8] <== NOT EXECUTED
rtems_termios_raw_input_size = raw_input;
3000778c: e8830006 stm r3, {r1, r2} <== NOT EXECUTED
rtems_termios_raw_output_size = raw_output; return RTEMS_SUCCESSFUL; }
30007790: e3a00000 mov r0, #0 <== NOT EXECUTED 30007794: e12fff1e bx lr <== NOT EXECUTED
300075e4 <rtems_termios_close>:
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
300075e4: e5903000 ldr r3, [r0]
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
300075e8: e92d4030 push {r4, r5, lr}
rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
300075ec: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain(
300075f0: e59f317c ldr r3, [pc, #380] ; 30007774 <rtems_termios_close+0x190> 300075f4: e3a01000 mov r1, #0
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
300075f8: e1a05000 mov r5, r0
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
300075fc: e1a02001 mov r2, r1 30007600: e5930000 ldr r0, [r3] 30007604: eb0007a5 bl 300094a0 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
30007608: e3500000 cmp r0, #0
3000760c: 1a000024 bne 300076a4 <rtems_termios_close+0xc0>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
30007610: e5943008 ldr r3, [r4, #8] 30007614: e2433001 sub r3, r3, #1 30007618: e3530000 cmp r3, #0 3000761c: e5843008 str r3, [r4, #8]
30007620: 1a00004e bne 30007760 <rtems_termios_close+0x17c>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
30007624: e59420cc ldr r2, [r4, #204] ; 0xcc 30007628: e59f3148 ldr r3, [pc, #328] ; 30007778 <rtems_termios_close+0x194> 3000762c: e0833282 add r3, r3, r2, lsl #5 30007630: e5931004 ldr r1, [r3, #4] 30007634: e3510000 cmp r1, #0
30007638: 0a000003 beq 3000764c <rtems_termios_close+0x68>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
3000763c: e1a00004 mov r0, r4 <== NOT EXECUTED 30007640: e1a0e00f mov lr, pc <== NOT EXECUTED 30007644: e12fff11 bx r1 <== NOT EXECUTED 30007648: ea000008 b 30007670 <rtems_termios_close+0x8c> <== NOT EXECUTED
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3000764c: e5940018 ldr r0, [r4, #24] 30007650: e1a02001 mov r2, r1 30007654: eb000791 bl 300094a0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
30007658: e3500000 cmp r0, #0
3000765c: 1a000010 bne 300076a4 <rtems_termios_close+0xc0>
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
30007660: e1a00004 mov r0, r4 30007664: ebfffeb2 bl 30007134 <drainOutput>
rtems_semaphore_release (tty->osem);
30007668: e5940018 ldr r0, [r4, #24] 3000766c: eb0007d1 bl 300095b8 <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30007670: e59430b4 ldr r3, [r4, #180] ; 0xb4 30007674: e3530002 cmp r3, #2
30007678: 1a00000a bne 300076a8 <rtems_termios_close+0xc4>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
3000767c: e59400c4 ldr r0, [r4, #196] ; 0xc4 <== NOT EXECUTED 30007680: e3a01001 mov r1, #1 <== NOT EXECUTED 30007684: eb000673 bl 30009058 <rtems_event_send> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
30007688: e3500000 cmp r0, #0 <== NOT EXECUTED 3000768c: 1a000004 bne 300076a4 <rtems_termios_close+0xc0> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
30007690: e59400c8 ldr r0, [r4, #200] ; 0xc8 <== NOT EXECUTED 30007694: e3a01001 mov r1, #1 <== NOT EXECUTED 30007698: eb00066e bl 30009058 <rtems_event_send> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
3000769c: e3500000 cmp r0, #0 <== NOT EXECUTED 300076a0: 0a000000 beq 300076a8 <rtems_termios_close+0xc4> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
300076a4: eb000917 bl 30009b08 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (tty->device.lastClose)
300076a8: e594309c ldr r3, [r4, #156] ; 0x9c 300076ac: e3530000 cmp r3, #0
(*tty->device.lastClose)(tty->major, tty->minor, arg);
300076b0: 1594000c ldrne r0, [r4, #12] 300076b4: 15941010 ldrne r1, [r4, #16] 300076b8: 11a02005 movne r2, r5 300076bc: 11a0e00f movne lr, pc 300076c0: 112fff13 bxne r3
if (tty->forw == NULL) {
300076c4: e894000c ldm r4, {r2, r3}
300076c8: e3520000 cmp r2, #0
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
300076cc: 15823004 strne r3, [r2, #4]
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
300076d0: 1a000003 bne 300076e4 <rtems_termios_close+0x100>
rtems_termios_ttyTail = tty->back;
300076d4: e59f10a0 ldr r1, [pc, #160] ; 3000777c <rtems_termios_close+0x198>
if ( rtems_termios_ttyTail != NULL ) {
300076d8: e3530000 cmp r3, #0
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
300076dc: e5813000 str r3, [r1]
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
300076e0: 15832000 strne r2, [r3]
}
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
300076e4: e5942004 ldr r2, [r4, #4] 300076e8: e5943000 ldr r3, [r4] 300076ec: e3520000 cmp r2, #0
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
300076f0: 15823000 strne r3, [r2]
}
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
300076f4: 1a000003 bne 30007708 <rtems_termios_close+0x124>
rtems_termios_ttyHead = tty->forw;
300076f8: e59f1080 ldr r1, [pc, #128] ; 30007780 <rtems_termios_close+0x19c>
if ( rtems_termios_ttyHead != NULL ) {
300076fc: e3530000 cmp r3, #0
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
30007700: e5813000 str r3, [r1]
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
30007704: 15832004 strne r2, [r3, #4]
}
} else {
tty->back->forw = tty->forw;
}
rtems_semaphore_delete (tty->isem);
30007708: e5940014 ldr r0, [r4, #20] 3000770c: eb00073c bl 30009404 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
30007710: e5940018 ldr r0, [r4, #24] 30007714: eb00073a bl 30009404 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
30007718: e594008c ldr r0, [r4, #140] ; 0x8c 3000771c: eb000738 bl 30009404 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
30007720: e59430a0 ldr r3, [r4, #160] ; 0xa0 30007724: e3530000 cmp r3, #0
30007728: 0a000002 beq 30007738 <rtems_termios_close+0x154>
3000772c: e59430b4 ldr r3, [r4, #180] ; 0xb4 30007730: e3530002 cmp r3, #2
30007734: 1a000001 bne 30007740 <rtems_termios_close+0x15c>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
30007738: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED 3000773c: eb000730 bl 30009404 <rtems_semaphore_delete> <== NOT EXECUTED
free (tty->rawInBuf.theBuf);
30007740: e5940058 ldr r0, [r4, #88] ; 0x58 30007744: ebfffad6 bl 300062a4 <free>
free (tty->rawOutBuf.theBuf);
30007748: e594007c ldr r0, [r4, #124] ; 0x7c 3000774c: ebfffad4 bl 300062a4 <free>
free (tty->cbuf);
30007750: e594001c ldr r0, [r4, #28] 30007754: ebfffad2 bl 300062a4 <free>
free (tty);
30007758: e1a00004 mov r0, r4 3000775c: ebfffad0 bl 300062a4 <free>
} rtems_semaphore_release (rtems_termios_ttyMutex);
30007760: e59f300c ldr r3, [pc, #12] ; 30007774 <rtems_termios_close+0x190> 30007764: e5930000 ldr r0, [r3] 30007768: eb000792 bl 300095b8 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
3000776c: e3a00000 mov r0, #0
30007770: e8bd8030 pop {r4, r5, pc}
30008b00 <rtems_termios_dequeue_characters>:
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
30008b00: e5902090 ldr r2, [r0, #144] ; 0x90 <== NOT EXECUTED
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
30008b04: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
30008b08: e0822001 add r2, r2, r1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30008b0c: e59010b4 ldr r1, [r0, #180] ; 0xb4 <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
30008b10: e5802090 str r2, [r0, #144] ; 0x90 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30008b14: e3510002 cmp r1, #2 <== NOT EXECUTED 30008b18: 1a000004 bne 30008b30 <rtems_termios_dequeue_characters+0x30><== NOT EXECUTED
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
30008b1c: e59000c8 ldr r0, [r0, #200] ; 0xc8 <== NOT EXECUTED 30008b20: eb00014c bl 30009058 <rtems_event_send> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
30008b24: e2503000 subs r3, r0, #0 <== NOT EXECUTED 30008b28: 0a00000d beq 30008b64 <rtems_termios_dequeue_characters+0x64><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
30008b2c: eb0003f5 bl 30009b08 <rtems_fatal_error_occurred> <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
30008b30: e59030cc ldr r3, [r0, #204] ; 0xcc <== NOT EXECUTED 30008b34: e3530005 cmp r3, #5 <== NOT EXECUTED 30008b38: 1a000007 bne 30008b5c <rtems_termios_dequeue_characters+0x5c><== NOT EXECUTED
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
30008b3c: e59f3028 ldr r3, [pc, #40] ; 30008b6c <rtems_termios_dequeue_characters+0x6c><== NOT EXECUTED 30008b40: e59330b4 ldr r3, [r3, #180] ; 0xb4 <== NOT EXECUTED 30008b44: e3530000 cmp r3, #0 <== NOT EXECUTED 30008b48: 0a000005 beq 30008b64 <rtems_termios_dequeue_characters+0x64><== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
30008b4c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008b50: e12fff13 bx r3 <== NOT EXECUTED
}
return 0; /* nothing to output in IRQ... */
30008b54: e3a03000 mov r3, #0 <== NOT EXECUTED 30008b58: ea000001 b 30008b64 <rtems_termios_dequeue_characters+0x64><== NOT EXECUTED
}
return rtems_termios_refill_transmitter(tty);
}
30008b5c: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
30008b60: eaffff5a b 300088d0 <rtems_termios_refill_transmitter> <== NOT EXECUTED
}
30008b64: e1a00003 mov r0, r3 <== NOT EXECUTED
30008b68: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300085cc <rtems_termios_enqueue_raw_characters>:
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
300085cc: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
300085d0: e59030cc ldr r3, [r0, #204] ; 0xcc <== NOT EXECUTED 300085d4: e59f7288 ldr r7, [pc, #648] ; 30008864 <rtems_termios_enqueue_raw_characters+0x298><== NOT EXECUTED
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
300085d8: e1a04000 mov r4, r0 <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
300085dc: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED 300085e0: e5939010 ldr r9, [r3, #16] <== NOT EXECUTED
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
300085e4: e1a06001 mov r6, r1 <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
300085e8: e3590000 cmp r9, #0 <== NOT EXECUTED 300085ec: 11a05002 movne r5, r2 <== NOT EXECUTED 300085f0: 1a00000d bne 3000862c <rtems_termios_enqueue_raw_characters+0x60><== 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);
300085f4: e2803030 add r3, r0, #48 ; 0x30 <== NOT EXECUTED 300085f8: e58d3000 str r3, [sp] <== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
300085fc: e280304a add r3, r0, #74 ; 0x4a <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
30008600: e1a08002 mov r8, r2 <== NOT EXECUTED 30008604: e1a05009 mov r5, r9 <== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
30008608: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000860c: ea00008b b 30008840 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
30008610: e59430cc ldr r3, [r4, #204] ; 0xcc <== NOT EXECUTED 30008614: e4d60001 ldrb r0, [r6], #1 <== NOT EXECUTED 30008618: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED 3000861c: e1a01004 mov r1, r4 <== NOT EXECUTED 30008620: e1a0e00f mov lr, pc <== NOT EXECUTED 30008624: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED 30008628: e2455001 sub r5, r5, #1 <== NOT EXECUTED
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
3000862c: e3550000 cmp r5, #0 <== NOT EXECUTED 30008630: 1afffff6 bne 30008610 <rtems_termios_enqueue_raw_characters+0x44><== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008634: e59430e4 ldr r3, [r4, #228] ; 0xe4 <== NOT EXECUTED 30008638: e3530000 cmp r3, #0 <== NOT EXECUTED 3000863c: 1a000086 bne 3000885c <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED 30008640: e59430dc ldr r3, [r4, #220] ; 0xdc <== NOT EXECUTED 30008644: e3530000 cmp r3, #0 <== NOT EXECUTED 30008648: 0a000083 beq 3000885c <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
3000864c: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 30008650: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED 30008654: e1a0e00f mov lr, pc <== NOT EXECUTED 30008658: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
3000865c: e3a03001 mov r3, #1 <== NOT EXECUTED 30008660: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED 30008664: ea00007c b 3000885c <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
30008668: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
3000866c: e4d6a001 ldrb sl, [r6], #1 <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
30008670: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED 30008674: 0a00000f beq 300086b8 <rtems_termios_enqueue_raw_characters+0xec><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
30008678: e5d4204a ldrb r2, [r4, #74] ; 0x4a <== NOT EXECUTED 3000867c: e5d43049 ldrb r3, [r4, #73] ; 0x49 <== NOT EXECUTED 30008680: e152000a cmp r2, sl <== NOT EXECUTED 30008684: 1a000007 bne 300086a8 <rtems_termios_enqueue_raw_characters+0xdc><== NOT EXECUTED
if (c == tty->termios.c_cc[VSTART]) {
30008688: e1530002 cmp r3, r2 <== NOT EXECUTED
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
3000868c: 059430b8 ldreq r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
30008690: 159430b8 ldrne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
30008694: 02233010 eoreq r3, r3, #16 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
30008698: 13833010 orrne r3, r3, #16 <== NOT EXECUTED 3000869c: 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, char *buf, int len)
{
300086a0: e3a09001 mov r9, #1 <== NOT EXECUTED 300086a4: ea000005 b 300086c0 <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
300086a8: e153000a cmp r3, sl <== NOT EXECUTED
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
300086ac: 059430b8 ldreq r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300086b0: 03c33010 biceq r3, r3, #16 <== NOT EXECUTED
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
300086b4: 0afffff8 beq 3000869c <rtems_termios_enqueue_raw_characters+0xd0><== NOT EXECUTED
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
300086b8: e3590000 cmp r9, #0 <== NOT EXECUTED 300086bc: 0a000014 beq 30008714 <rtems_termios_enqueue_raw_characters+0x148><== NOT EXECUTED
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
300086c0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300086c4: e2033030 and r3, r3, #48 ; 0x30 <== NOT EXECUTED 300086c8: e3530020 cmp r3, #32 <== NOT EXECUTED 300086cc: 1a00005a bne 3000883c <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
300086d0: ebfffa93 bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED 300086d4: e1a07000 mov r7, r0 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
300086d8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300086dc: e3c33020 bic r3, r3, #32 <== NOT EXECUTED 300086e0: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
300086e4: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED 300086e8: e3530000 cmp r3, #0 <== NOT EXECUTED 300086ec: 0a000006 beq 3000870c <rtems_termios_enqueue_raw_characters+0x140><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
300086f0: 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)(
300086f4: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED 300086f8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 300086fc: e0811003 add r1, r1, r3 <== NOT EXECUTED 30008700: e3a02001 mov r2, #1 <== NOT EXECUTED 30008704: e1a0e00f mov lr, pc <== NOT EXECUTED 30008708: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 3000870c: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED 30008710: ea000049 b 3000883c <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
30008714: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 30008718: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED 3000871c: e2800001 add r0, r0, #1 <== NOT EXECUTED 30008720: eb002d20 bl 30013ba8 <__umodsi3> <== NOT EXECUTED 30008724: e1a07000 mov r7, r0 <== NOT EXECUTED
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
30008728: ebfffa7d bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED 3000872c: e1a0b000 mov fp, r0 <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
30008730: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED 30008734: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
% tty->rawInBuf.Size) > tty->highwater) &&
30008738: e5941064 ldr r1, [r4, #100] ; 0x64 <== 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)
3000873c: e0630000 rsb r0, r3, r0 <== NOT EXECUTED
% tty->rawInBuf.Size) > tty->highwater) &&
30008740: e0800007 add r0, r0, r7 <== NOT EXECUTED 30008744: eb002d17 bl 30013ba8 <__umodsi3> <== 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)
30008748: e59430c0 ldr r3, [r4, #192] ; 0xc0 <== NOT EXECUTED 3000874c: e1500003 cmp r0, r3 <== NOT EXECUTED 30008750: 9a000025 bls 300087ec <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
30008754: 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) &&
30008758: e3130001 tst r3, #1 <== NOT EXECUTED 3000875c: 1a000022 bne 300087ec <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
30008760: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008764: e3833001 orr r3, r3, #1 <== NOT EXECUTED 30008768: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
3000876c: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008770: e59f30f0 ldr r3, [pc, #240] ; 30008868 <rtems_termios_enqueue_raw_characters+0x29c><== NOT EXECUTED 30008774: e0023003 and r3, r2, r3 <== NOT EXECUTED 30008778: e3530b01 cmp r3, #1024 ; 0x400 <== NOT EXECUTED 3000877c: 1a00000e bne 300087bc <rtems_termios_enqueue_raw_characters+0x1f0><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
30008780: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008784: e3130020 tst r3, #32 <== NOT EXECUTED 30008788: 1a000002 bne 30008798 <rtems_termios_enqueue_raw_characters+0x1cc><== NOT EXECUTED 3000878c: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED 30008790: e3530000 cmp r3, #0 <== NOT EXECUTED 30008794: 1a000014 bne 300087ec <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
30008798: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
3000879c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
== (FL_MDXOF ) ) {
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;
300087a0: e3833002 orr r3, r3, #2 <== NOT EXECUTED 300087a4: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
300087a8: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 300087ac: e3a02001 mov r2, #1 <== NOT EXECUTED 300087b0: e1a0e00f mov lr, pc <== NOT EXECUTED 300087b4: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 300087b8: ea00000b b 300087ec <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
300087bc: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300087c0: e2033f41 and r3, r3, #260 ; 0x104 <== NOT EXECUTED 300087c4: e3530c01 cmp r3, #256 ; 0x100 <== NOT EXECUTED 300087c8: 1a000007 bne 300087ec <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
300087cc: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300087d0: e3833004 orr r3, r3, #4 <== NOT EXECUTED 300087d4: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
300087d8: e59430ac ldr r3, [r4, #172] ; 0xac <== NOT EXECUTED 300087dc: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
300087e0: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED 300087e4: 11a0e00f movne lr, pc <== NOT EXECUTED 300087e8: 112fff13 bxne r3 <== NOT EXECUTED 300087ec: e129f00b msr CPSR_fc, fp <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
300087f0: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED 300087f4: e1570003 cmp r7, r3 <== NOT EXECUTED
dropped++;
300087f8: 02855001 addeq r5, r5, #1 <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
300087fc: 0a00000e beq 3000883c <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
30008800: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED 30008804: e7c3a007 strb sl, [r3, r7] <== NOT EXECUTED
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008808: e59430e4 ldr r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
3000880c: e5847060 str r7, [r4, #96] ; 0x60 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008810: e3530000 cmp r3, #0 <== NOT EXECUTED 30008814: 1a000008 bne 3000883c <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED 30008818: e59430dc ldr r3, [r4, #220] ; 0xdc <== NOT EXECUTED 3000881c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008820: 0a000005 beq 3000883c <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
30008824: e59d0000 ldr r0, [sp] <== NOT EXECUTED 30008828: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED 3000882c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008830: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
30008834: e3a03001 mov r3, #1 <== NOT EXECUTED 30008838: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED 3000883c: e2488001 sub r8, r8, #1 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
30008840: e3580000 cmp r8, #0 <== NOT EXECUTED 30008844: 1affff87 bne 30008668 <rtems_termios_enqueue_raw_characters+0x9c><== NOT EXECUTED
}
}
}
}
tty->rawInBufDropped += dropped;
30008848: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
3000884c: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
}
}
}
}
tty->rawInBufDropped += dropped;
30008850: e0833005 add r3, r3, r5 <== NOT EXECUTED 30008854: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
30008858: eb000356 bl 300095b8 <rtems_semaphore_release> <== NOT EXECUTED
return dropped; }
3000885c: e1a00005 mov r0, r5 <== NOT EXECUTED
30008860: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000779c <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;
3000779c: e5903000 ldr r3, [r0]
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
300077a0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
300077a4: e5934034 ldr r4, [r3, #52] ; 0x34
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
300077a8: e3a01000 mov r1, #0
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
300077ac: e5907008 ldr r7, [r0, #8]
rtems_status_code sc;
args->ioctl_return = 0;
300077b0: e580100c str r1, [r0, #12]
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
300077b4: e1a05000 mov r5, r0
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
300077b8: e1a02001 mov r2, r1 300077bc: e5940018 ldr r0, [r4, #24] 300077c0: eb000736 bl 300094a0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
300077c4: e2506000 subs r6, r0, #0
300077c8: 1a0000d4 bne 30007b20 <rtems_termios_ioctl+0x384>
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
300077cc: e5953004 ldr r3, [r5, #4] 300077d0: e3530004 cmp r3, #4
300077d4: 0a0000a8 beq 30007a7c <rtems_termios_ioctl+0x2e0> 300077d8: 8a000005 bhi 300077f4 <rtems_termios_ioctl+0x58>
300077dc: e3530002 cmp r3, #2
300077e0: 0a000029 beq 3000788c <rtems_termios_ioctl+0xf0> 300077e4: 8a00009d bhi 30007a60 <rtems_termios_ioctl+0x2c4>
300077e8: e3530001 cmp r3, #1 <== NOT EXECUTED 300077ec: 1a000010 bne 30007834 <rtems_termios_ioctl+0x98> <== NOT EXECUTED 300077f0: ea00001b b 30007864 <rtems_termios_ioctl+0xc8> <== NOT EXECUTED 300077f4: e59f2330 ldr r2, [pc, #816] ; 30007b2c <rtems_termios_ioctl+0x390><== NOT EXECUTED 300077f8: e1530002 cmp r3, r2 <== NOT EXECUTED 300077fc: 0a0000ba beq 30007aec <rtems_termios_ioctl+0x350> <== NOT EXECUTED 30007800: 8a000002 bhi 30007810 <rtems_termios_ioctl+0x74> <== NOT EXECUTED 30007804: e3530005 cmp r3, #5 <== NOT EXECUTED 30007808: 1a000009 bne 30007834 <rtems_termios_ioctl+0x98> <== NOT EXECUTED 3000780c: ea000096 b 30007a6c <rtems_termios_ioctl+0x2d0> <== NOT EXECUTED 30007810: e59f2318 ldr r2, [pc, #792] ; 30007b30 <rtems_termios_ioctl+0x394><== NOT EXECUTED 30007814: e1530002 cmp r3, r2 <== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
30007818: 05953008 ldreq r3, [r5, #8] <== NOT EXECUTED 3000781c: 059420cc ldreq r2, [r4, #204] ; 0xcc <== NOT EXECUTED 30007820: 05832000 streq r2, [r3] <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
30007824: 0a0000bb beq 30007b18 <rtems_termios_ioctl+0x37c> <== NOT EXECUTED 30007828: e2822105 add r2, r2, #1073741825 ; 0x40000001 <== NOT EXECUTED 3000782c: e1530002 cmp r3, r2 <== NOT EXECUTED 30007830: 0a000095 beq 30007a8c <rtems_termios_ioctl+0x2f0> <== NOT EXECUTED
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
30007834: e59420cc ldr r2, [r4, #204] ; 0xcc <== NOT EXECUTED 30007838: e59f32f4 ldr r3, [pc, #756] ; 30007b34 <rtems_termios_ioctl+0x398><== NOT EXECUTED 3000783c: e0833282 add r3, r3, r2, lsl #5 <== NOT EXECUTED 30007840: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED 30007844: e3530000 cmp r3, #0 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
30007848: 03a0600a moveq r6, #10 <== NOT EXECUTED
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
3000784c: 0a0000b1 beq 30007b18 <rtems_termios_ioctl+0x37c> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
30007850: e1a00004 mov r0, r4 <== NOT EXECUTED 30007854: e1a01005 mov r1, r5 <== NOT EXECUTED 30007858: e1a0e00f mov lr, pc <== NOT EXECUTED 3000785c: e12fff13 bx r3 <== NOT EXECUTED 30007860: ea00009f b 30007ae4 <rtems_termios_ioctl+0x348> <== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
30007864: e5957008 ldr r7, [r5, #8] <== NOT EXECUTED
30007868: e284c030 add ip, r4, #48 ; 0x30 <== NOT EXECUTED
3000786c: e1a0e007 mov lr, r7 <== NOT EXECUTED
30007870: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30007874: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007878: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000787c: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007880: e59c3000 ldr r3, [ip] <== NOT EXECUTED
30007884: e58e3000 str r3, [lr] <== NOT EXECUTED
break;
30007888: ea0000a2 b 30007b18 <rtems_termios_ioctl+0x37c> <== NOT EXECUTED
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
3000788c: e595e008 ldr lr, [r5, #8] <== NOT EXECUTED
30007890: e284c030 add ip, r4, #48 ; 0x30 <== NOT EXECUTED
30007894: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007898: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000789c: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
300078a0: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
300078a4: e59e3000 ldr r3, [lr] <== NOT EXECUTED
300078a8: e58c3000 str r3, [ip] <== NOT EXECUTED
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
300078ac: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300078b0: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED 300078b4: 0a000018 beq 3000791c <rtems_termios_ioctl+0x180> <== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
300078b8: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
300078bc: e3130b01 tst r3, #1024 ; 0x400 <== NOT EXECUTED 300078c0: 1a000015 bne 3000791c <rtems_termios_ioctl+0x180> <== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
300078c4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300078c8: e3c33e21 bic r3, r3, #528 ; 0x210 <== NOT EXECUTED 300078cc: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
300078d0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300078d4: e3130020 tst r3, #32 <== NOT EXECUTED 300078d8: 0a00000f beq 3000791c <rtems_termios_ioctl+0x180> <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
300078dc: ebfffe10 bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED 300078e0: e1a07000 mov r7, r0 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
300078e4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300078e8: e3c33020 bic r3, r3, #32 <== NOT EXECUTED 300078ec: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
300078f0: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED 300078f4: e3530000 cmp r3, #0 <== NOT EXECUTED 300078f8: 0a000006 beq 30007918 <rtems_termios_ioctl+0x17c> <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
300078fc: 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)(
30007900: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED 30007904: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30007908: e0811003 add r1, r1, r3 <== NOT EXECUTED 3000790c: e3a02001 mov r2, #1 <== NOT EXECUTED 30007910: e1a0e00f mov lr, pc <== NOT EXECUTED 30007914: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 30007918: 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)) {
3000791c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007920: e3130b01 tst r3, #1024 ; 0x400 <== NOT EXECUTED 30007924: 0a000008 beq 3000794c <rtems_termios_ioctl+0x1b0> <== NOT EXECUTED 30007928: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED 3000792c: e3130a01 tst r3, #4096 ; 0x1000 <== NOT EXECUTED 30007930: 1a000005 bne 3000794c <rtems_termios_ioctl+0x1b0> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
30007934: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007938: e3c33b01 bic r3, r3, #1024 ; 0x400 <== NOT EXECUTED 3000793c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
30007940: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007944: e3c33002 bic r3, r3, #2 <== NOT EXECUTED 30007948: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
3000794c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007950: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007954: 0a000010 beq 3000799c <rtems_termios_ioctl+0x200> <== NOT EXECUTED 30007958: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 3000795c: e3530000 cmp r3, #0 <== NOT EXECUTED 30007960: ba00000d blt 3000799c <rtems_termios_ioctl+0x200> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
30007964: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007968: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED 3000796c: 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)) {
30007970: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007974: e3130004 tst r3, #4 <== NOT EXECUTED 30007978: 0a000004 beq 30007990 <rtems_termios_ioctl+0x1f4> <== NOT EXECUTED 3000797c: e59430b0 ldr r3, [r4, #176] ; 0xb0 <== NOT EXECUTED 30007980: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
30007984: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED 30007988: 11a0e00f movne lr, pc <== NOT EXECUTED 3000798c: 112fff13 bxne r3 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
30007990: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007994: e3c33004 bic r3, r3, #4 <== NOT EXECUTED 30007998: 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) {
3000799c: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED
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) {
300079a0: e594703c ldr r7, [r4, #60] ; 0x3c <== 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) {
300079a4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
300079a8: b59430b8 ldrlt r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300079ac: b3833c01 orrlt r3, r3, #256 ; 0x100 <== NOT EXECUTED 300079b0: b58430b8 strlt r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
300079b4: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED 300079b8: e3130a01 tst r3, #4096 ; 0x1000 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDXOF;
300079bc: 159420b8 ldrne r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 300079c0: 13822b01 orrne r2, r2, #1024 ; 0x400 <== NOT EXECUTED 300079c4: 158420b8 strne r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
300079c8: e3130b01 tst r3, #1024 ; 0x400 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDXON;
300079cc: 159430b8 ldrne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300079d0: 13833c02 orrne r3, r3, #512 ; 0x200 <== NOT EXECUTED 300079d4: 158430b8 strne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
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) {
300079d8: e2177002 ands r7, r7, #2 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
300079dc: 13a03000 movne r3, #0 <== NOT EXECUTED
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) {
300079e0: 1a000013 bne 30007a34 <rtems_termios_ioctl+0x298> <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
300079e4: e5d48046 ldrb r8, [r4, #70] ; 0x46 <== NOT EXECUTED
rtems_clock_get_ticks_per_second() / 10;
300079e8: eb000519 bl 30008e54 <rtems_clock_get_ticks_per_second> <== NOT EXECUTED 300079ec: e3a0100a mov r1, #10 <== NOT EXECUTED 300079f0: e0000098 mul r0, r8, r0 <== NOT EXECUTED 300079f4: eb002fd3 bl 30013948 <__aeabi_uidiv> <== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
300079f8: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED
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] *
300079fc: e5840054 str r0, [r4, #84] ; 0x54 <== NOT EXECUTED
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
30007a00: e3530000 cmp r3, #0 <== NOT EXECUTED 30007a04: e5d42047 ldrb r2, [r4, #71] ; 0x47 <== NOT EXECUTED 30007a08: 0a000005 beq 30007a24 <rtems_termios_ioctl+0x288> <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007a0c: e3520000 cmp r2, #0 <== NOT EXECUTED
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
30007a10: e5840070 str r0, [r4, #112] ; 0x70 <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007a14: 13a00000 movne r0, #0 <== NOT EXECUTED
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;
30007a18: e584706c str r7, [r4, #108] ; 0x6c <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007a1c: e5840074 str r0, [r4, #116] ; 0x74 <== NOT EXECUTED 30007a20: ea000006 b 30007a40 <rtems_termios_ioctl+0x2a4> <== NOT EXECUTED
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
30007a24: e3520000 cmp r2, #0 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
30007a28: 03a03001 moveq r3, #1 <== NOT EXECUTED 30007a2c: 0584306c streq r3, [r4, #108] ; 0x6c <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
30007a30: 0a000002 beq 30007a40 <rtems_termios_ioctl+0x2a4> <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
30007a34: e584306c str r3, [r4, #108] ; 0x6c <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
30007a38: e5843070 str r3, [r4, #112] ; 0x70 <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007a3c: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
30007a40: e59430a8 ldr r3, [r4, #168] ; 0xa8 <== NOT EXECUTED 30007a44: e3530000 cmp r3, #0 <== NOT EXECUTED 30007a48: 0a000032 beq 30007b18 <rtems_termios_ioctl+0x37c> <== NOT EXECUTED
(*tty->device.setAttributes)(tty->minor, &tty->termios);
30007a4c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30007a50: e2841030 add r1, r4, #48 ; 0x30 <== NOT EXECUTED 30007a54: e1a0e00f mov lr, pc <== NOT EXECUTED 30007a58: e12fff13 bx r3 <== NOT EXECUTED 30007a5c: ea00002d b 30007b18 <rtems_termios_ioctl+0x37c> <== NOT EXECUTED
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
30007a60: e1a00004 mov r0, r4 30007a64: ebfffdb2 bl 30007134 <drainOutput>
break;
30007a68: ea00002a b 30007b18 <rtems_termios_ioctl+0x37c>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
30007a6c: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
30007a70: e58420d4 str r2, [r4, #212] ; 0xd4 <== NOT EXECUTED
30007a74: e58430d8 str r3, [r4, #216] ; 0xd8 <== NOT EXECUTED
break;
30007a78: ea000026 b 30007b18 <rtems_termios_ioctl+0x37c> <== NOT EXECUTED
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
30007a7c: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
30007a80: e58420dc str r2, [r4, #220] ; 0xdc <== NOT EXECUTED
30007a84: e58430e0 str r3, [r4, #224] ; 0xe0 <== NOT EXECUTED
break;
30007a88: ea000022 b 30007b18 <rtems_termios_ioctl+0x37c> <== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
30007a8c: e59420cc ldr r2, [r4, #204] ; 0xcc <== NOT EXECUTED 30007a90: e59f309c ldr r3, [pc, #156] ; 30007b34 <rtems_termios_ioctl+0x398><== NOT EXECUTED 30007a94: e0833282 add r3, r3, r2, lsl #5 <== NOT EXECUTED 30007a98: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30007a9c: e3530000 cmp r3, #0 <== NOT EXECUTED 30007aa0: 0a000003 beq 30007ab4 <rtems_termios_ioctl+0x318> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
30007aa4: e1a00004 mov r0, r4 <== NOT EXECUTED 30007aa8: e1a0e00f mov lr, pc <== NOT EXECUTED 30007aac: e12fff13 bx r3 <== NOT EXECUTED 30007ab0: e1a06000 mov r6, r0 <== NOT EXECUTED
}
tty->t_line=*(int*)(args->buffer);
30007ab4: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
30007ab8: e3a02000 mov r2, #0 <== NOT EXECUTED
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
30007abc: e5933000 ldr r3, [r3] <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
30007ac0: e58420d0 str r2, [r4, #208] ; 0xd0 <== NOT EXECUTED
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
30007ac4: e59f2068 ldr r2, [pc, #104] ; 30007b34 <rtems_termios_ioctl+0x398><== NOT EXECUTED
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
30007ac8: e58430cc str r3, [r4, #204] ; 0xcc <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
30007acc: e7923283 ldr r3, [r2, r3, lsl #5] <== NOT EXECUTED 30007ad0: e3530000 cmp r3, #0 <== NOT EXECUTED 30007ad4: 0a00000f beq 30007b18 <rtems_termios_ioctl+0x37c> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
30007ad8: e1a00004 mov r0, r4 <== NOT EXECUTED 30007adc: e1a0e00f mov lr, pc <== NOT EXECUTED 30007ae0: e12fff13 bx r3 <== NOT EXECUTED 30007ae4: e1a06000 mov r6, r0 <== NOT EXECUTED 30007ae8: ea00000a b 30007b18 <rtems_termios_ioctl+0x37c> <== NOT EXECUTED
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
30007aec: e5942060 ldr r2, [r4, #96] ; 0x60 <== NOT EXECUTED 30007af0: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
30007af4: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
30007af8: e0523003 subs r3, r2, r3 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
30007afc: 45942064 ldrmi r2, [r4, #100] ; 0x64 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
30007b00: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
30007b04: 40833002 addmi r3, r3, r2 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
30007b08: e0611000 rsb r1, r1, r0 <== NOT EXECUTED 30007b0c: e5952008 ldr r2, [r5, #8] <== NOT EXECUTED 30007b10: e0813003 add r3, r1, r3 <== NOT EXECUTED 30007b14: e5823000 str r3, [r2] <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
30007b18: e5940018 ldr r0, [r4, #24] 30007b1c: eb0006a5 bl 300095b8 <rtems_semaphore_release>
args->ioctl_return = sc;
30007b20: e585600c str r6, [r5, #12]
return sc; }
30007b24: e1a00006 mov r0, r6
30007b28: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
30008f9c <rtems_termios_number_to_baud>:
extern rtems_assoc_t termios_assoc_table[];
int rtems_termios_number_to_baud(
int32_t baud
)
{
30008f9c: e92d4010 push {r4, lr} <== NOT EXECUTED
30008fa0: e1a04000 mov r4, r0 <== NOT EXECUTED
int termios_baud;
termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud );
30008fa4: e1a01004 mov r1, r4 <== NOT EXECUTED 30008fa8: e59f001c ldr r0, [pc, #28] ; 30008fcc <rtems_termios_number_to_baud+0x30><== NOT EXECUTED 30008fac: eb001abc bl 3000faa4 <rtems_assoc_remote_by_local> <== NOT EXECUTED
if ( termios_baud == 0 && baud != 0 )
30008fb0: e2703001 rsbs r3, r0, #1 <== NOT EXECUTED 30008fb4: 33a03000 movcc r3, #0 <== NOT EXECUTED 30008fb8: e3540000 cmp r4, #0 <== NOT EXECUTED 30008fbc: 03a03000 moveq r3, #0 <== NOT EXECUTED 30008fc0: e3530000 cmp r3, #0 <== NOT EXECUTED
return -1;
return termios_baud;
}
30008fc4: 13e00000 mvnne r0, #0 <== NOT EXECUTED
30008fc8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30007190 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
30007190: e92d4fff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
30007194: e58d300c str r3, [sp, #12]
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
30007198: e59f3404 ldr r3, [pc, #1028] ; 300075a4 <rtems_termios_open+0x414>
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
3000719c: e1a0a001 mov sl, r1
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
300071a0: e3a01000 mov r1, #0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
300071a4: e1a09000 mov r9, r0 300071a8: e1a08002 mov r8, r2
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
300071ac: e5930000 ldr r0, [r3] 300071b0: e1a02001 mov r2, r1 300071b4: eb0008b9 bl 300094a0 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
300071b8: e2506000 subs r6, r0, #0
300071bc: 1a0000ee bne 3000757c <rtems_termios_open+0x3ec>
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
300071c0: e59f33e0 ldr r3, [pc, #992] ; 300075a8 <rtems_termios_open+0x418> 300071c4: e5937000 ldr r7, [r3] 300071c8: e1a05007 mov r5, r7 300071cc: ea000006 b 300071ec <rtems_termios_open+0x5c>
if ((tty->major == major) && (tty->minor == minor))
300071d0: e595300c ldr r3, [r5, #12] 300071d4: e1530009 cmp r3, r9
300071d8: 1a000002 bne 300071e8 <rtems_termios_open+0x58>
300071dc: e5953010 ldr r3, [r5, #16] 300071e0: e153000a cmp r3, sl
300071e4: 0a0000c3 beq 300074f8 <rtems_termios_open+0x368>
sc = rtems_semaphore_obtain(
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
300071e8: e5955000 ldr r5, [r5] <== NOT EXECUTED
300071ec: e3550000 cmp r5, #0
300071f0: 1afffff6 bne 300071d0 <rtems_termios_open+0x40>
300071f4: ea0000e3 b 30007588 <rtems_termios_open+0x3f8>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
300071f8: e59f23ac ldr r2, [pc, #940] ; 300075ac <rtems_termios_open+0x41c> 300071fc: e5923000 ldr r3, [r2] 30007200: e5853064 str r3, [r5, #100] ; 0x64
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
30007204: e5950064 ldr r0, [r5, #100] ; 0x64 30007208: e58d2008 str r2, [sp, #8] 3000720c: ebfffcf3 bl 300065e0 <malloc>
if (tty->rawInBuf.theBuf == NULL) {
30007210: e3500000 cmp r0, #0
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
30007214: e1a0b000 mov fp, r0 30007218: e5850058 str r0, [r5, #88] ; 0x58
if (tty->rawInBuf.theBuf == NULL) {
3000721c: e59d2008 ldr r2, [sp, #8]
30007220: 1a000006 bne 30007240 <rtems_termios_open+0xb0>
free(tty);
30007224: e1a00005 mov r0, r5 <== NOT EXECUTED 30007228: ebfffc1d bl 300062a4 <free> <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
3000722c: e59f3370 ldr r3, [pc, #880] ; 300075a4 <rtems_termios_open+0x414><== NOT EXECUTED
return RTEMS_NO_MEMORY;
30007230: e3a0601a mov r6, #26 <== NOT EXECUTED
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
rtems_semaphore_release (rtems_termios_ttyMutex);
30007234: e5930000 ldr r0, [r3] <== NOT EXECUTED 30007238: eb0008de bl 300095b8 <rtems_semaphore_release> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
3000723c: ea0000ce b 3000757c <rtems_termios_open+0x3ec> <== NOT EXECUTED
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
30007240: e5923004 ldr r3, [r2, #4] 30007244: e5853088 str r3, [r5, #136] ; 0x88
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
30007248: e5950088 ldr r0, [r5, #136] ; 0x88 3000724c: e58d2008 str r2, [sp, #8] 30007250: ebfffce2 bl 300065e0 <malloc>
if (tty->rawOutBuf.theBuf == NULL) {
30007254: e3500000 cmp r0, #0
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
30007258: e1a03000 mov r3, r0 3000725c: e585007c str r0, [r5, #124] ; 0x7c
if (tty->rawOutBuf.theBuf == NULL) {
30007260: e59d2008 ldr r2, [sp, #8]
30007264: 0a000008 beq 3000728c <rtems_termios_open+0xfc>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
30007268: e5920008 ldr r0, [r2, #8] 3000726c: e58d3008 str r3, [sp, #8] 30007270: ebfffcda bl 300065e0 <malloc>
if (tty->cbuf == NULL) {
30007274: e3500000 cmp r0, #0
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
30007278: e585001c str r0, [r5, #28]
if (tty->cbuf == NULL) {
3000727c: e59d3008 ldr r3, [sp, #8]
30007280: 1a000004 bne 30007298 <rtems_termios_open+0x108>
free((void *)(tty->rawOutBuf.theBuf));
30007284: e1a00003 mov r0, r3 <== NOT EXECUTED 30007288: ebfffc05 bl 300062a4 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
3000728c: e1a0000b mov r0, fp <== NOT EXECUTED 30007290: ebfffc03 bl 300062a4 <free> <== NOT EXECUTED 30007294: eaffffe2 b 30007224 <rtems_termios_open+0x94> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
30007298: e3a03000 mov r3, #0
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
3000729c: e5853004 str r3, [r5, #4]
if (rtems_termios_ttyHead != NULL)
300072a0: e1570003 cmp r7, r3
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
300072a4: e58530d4 str r3, [r5, #212] ; 0xd4
tty->tty_snd.sw_arg = NULL;
300072a8: e58530d8 str r3, [r5, #216] ; 0xd8
tty->tty_rcv.sw_pfn = NULL;
300072ac: e58530dc str r3, [r5, #220] ; 0xdc
tty->tty_rcv.sw_arg = NULL;
300072b0: e58530e0 str r3, [r5, #224] ; 0xe0
tty->tty_rcvwakeup = 0;
300072b4: e58530e4 str r3, [r5, #228] ; 0xe4
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
300072b8: e59f32e8 ldr r3, [pc, #744] ; 300075a8 <rtems_termios_open+0x418>
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
300072bc: 15875004 strne r5, [r7, #4]
rtems_termios_ttyHead = tty;
300072c0: e5834000 str r4, [r3]
if (rtems_termios_ttyTail == NULL)
300072c4: e59f32e4 ldr r3, [pc, #740] ; 300075b0 <rtems_termios_open+0x420>
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
300072c8: e5857000 str r7, [r5]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
300072cc: e5932000 ldr r2, [r3]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
300072d0: e59f72d4 ldr r7, [pc, #724] ; 300075ac <rtems_termios_open+0x41c>
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)
300072d4: e3520000 cmp r2, #0
rtems_termios_ttyTail = tty;
300072d8: 05834000 streq r4, [r3]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
300072dc: e59f02d0 ldr r0, [pc, #720] ; 300075b4 <rtems_termios_open+0x424>
rtems_build_name ('T', 'R', 'i', c),
300072e0: e5d7300c ldrb r3, [r7, #12]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
300072e4: e2842014 add r2, r4, #20
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
300072e8: e584a010 str sl, [r4, #16]
tty->major = major;
300072ec: e584900c str r9, [r4, #12]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
300072f0: e1830000 orr r0, r3, r0 300072f4: e58d2000 str r2, [sp] 300072f8: e3a03000 mov r3, #0 300072fc: e3a01001 mov r1, #1 30007300: e3a02054 mov r2, #84 ; 0x54 30007304: eb0007d3 bl 30009258 <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)
30007308: e2503000 subs r3, r0, #0
3000730c: 1a000096 bne 3000756c <rtems_termios_open+0x3dc>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
30007310: e5d7200c ldrb r2, [r7, #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 (
30007314: e59f029c ldr r0, [pc, #668] ; 300075b8 <rtems_termios_open+0x428> 30007318: e2841018 add r1, r4, #24 3000731c: e58d1000 str r1, [sp] 30007320: e1820000 orr r0, r2, r0 30007324: e3a01001 mov r1, #1 30007328: e3a02054 mov r2, #84 ; 0x54 3000732c: eb0007c9 bl 30009258 <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)
30007330: e2501000 subs r1, r0, #0
30007334: 1a00008c bne 3000756c <rtems_termios_open+0x3dc>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
30007338: e5d7300c ldrb r3, [r7, #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 (
3000733c: e59f0278 ldr r0, [pc, #632] ; 300075bc <rtems_termios_open+0x42c> 30007340: e284208c add r2, r4, #140 ; 0x8c 30007344: e58d2000 str r2, [sp] 30007348: e1830000 orr r0, r3, r0 3000734c: e3a02020 mov r2, #32 30007350: e1a03001 mov r3, r1 30007354: eb0007bf bl 30009258 <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)
30007358: e250b000 subs fp, r0, #0
3000735c: 1a000082 bne 3000756c <rtems_termios_open+0x3dc>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
30007360: e59de00c ldr lr, [sp, #12]
30007364: e284c098 add ip, r4, #152 ; 0x98
30007368: e8be000f ldm lr!, {r0, r1, r2, r3}
3000736c: e8ac000f stmia ip!, {r0, r1, r2, r3}
30007370: e89e000f ldm lr, {r0, r1, r2, r3}
30007374: e88c000f stm ip, {r0, r1, r2, r3}
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30007378: e59430b4 ldr r3, [r4, #180] ; 0xb4
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;
3000737c: e584b094 str fp, [r4, #148] ; 0x94
tty->device = *callbacks;
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30007380: e3530002 cmp r3, #2
30007384: 1a000017 bne 300073e8 <rtems_termios_open+0x258>
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
30007388: e5d7300c ldrb r3, [r7, #12] <== NOT EXECUTED
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
3000738c: e59f022c ldr r0, [pc, #556] ; 300075c0 <rtems_termios_open+0x430><== NOT EXECUTED 30007390: e28420c8 add r2, r4, #200 ; 0xc8 <== NOT EXECUTED 30007394: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 30007398: e1830000 orr r0, r3, r0 <== NOT EXECUTED 3000739c: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED 300073a0: e3a0100a mov r1, #10 <== NOT EXECUTED 300073a4: e3a03c05 mov r3, #1280 ; 0x500 <== NOT EXECUTED 300073a8: e58db000 str fp, [sp] <== NOT EXECUTED 300073ac: eb0008a8 bl 30009654 <rtems_task_create> <== NOT EXECUTED
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
300073b0: e2502000 subs r2, r0, #0 <== NOT EXECUTED 300073b4: 1a00006c bne 3000756c <rtems_termios_open+0x3dc> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
300073b8: e5d7300c ldrb r3, [r7, #12] <== NOT EXECUTED
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
300073bc: e59f0200 ldr r0, [pc, #512] ; 300075c4 <rtems_termios_open+0x434><== NOT EXECUTED 300073c0: e58d2000 str r2, [sp] <== NOT EXECUTED 300073c4: e28420c4 add r2, r4, #196 ; 0xc4 <== NOT EXECUTED 300073c8: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 300073cc: e1830000 orr r0, r3, r0 <== NOT EXECUTED 300073d0: e3a01009 mov r1, #9 <== NOT EXECUTED 300073d4: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED 300073d8: e3a03c05 mov r3, #1280 ; 0x500 <== NOT EXECUTED 300073dc: eb00089c bl 30009654 <rtems_task_create> <== NOT EXECUTED
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
300073e0: e3500000 cmp r0, #0 <== NOT EXECUTED 300073e4: 1a000060 bne 3000756c <rtems_termios_open+0x3dc> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
300073e8: e59430a0 ldr r3, [r4, #160] ; 0xa0 300073ec: e3530000 cmp r3, #0
300073f0: 0a000002 beq 30007400 <rtems_termios_open+0x270>
300073f4: e59430b4 ldr r3, [r4, #180] ; 0xb4 300073f8: e3530002 cmp r3, #2
300073fc: 1a00000b bne 30007430 <rtems_termios_open+0x2a0>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
30007400: e59f31a4 ldr r3, [pc, #420] ; 300075ac <rtems_termios_open+0x41c><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
30007404: e59f01bc ldr r0, [pc, #444] ; 300075c8 <rtems_termios_open+0x438><== NOT EXECUTED
rtems_build_name ('T', 'R', 'r', c),
30007408: e5d3300c ldrb r3, [r3, #12] <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
3000740c: e2842068 add r2, r4, #104 ; 0x68 <== NOT EXECUTED 30007410: e3a01000 mov r1, #0 <== NOT EXECUTED 30007414: e58d2000 str r2, [sp] <== NOT EXECUTED 30007418: e1830000 orr r0, r3, r0 <== NOT EXECUTED 3000741c: e3a02024 mov r2, #36 ; 0x24 <== NOT EXECUTED 30007420: e1a03001 mov r3, r1 <== NOT EXECUTED 30007424: eb00078b bl 30009258 <rtems_semaphore_create> <== NOT EXECUTED
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
30007428: e3500000 cmp r0, #0 <== NOT EXECUTED 3000742c: 1a00004e bne 3000756c <rtems_termios_open+0x3dc> <== NOT EXECUTED
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
30007430: e59f3194 ldr r3, [pc, #404] ; 300075cc <rtems_termios_open+0x43c>
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';
30007434: e3a02011 mov r2, #17
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
30007438: e5843030 str r3, [r4, #48] ; 0x30
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
3000743c: e59f318c ldr r3, [pc, #396] ; 300075d0 <rtems_termios_open+0x440>
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';
30007440: e5c42049 strb r2, [r4, #73] ; 0x49
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
30007444: e5843034 str r3, [r4, #52] ; 0x34
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
30007448: e59f3184 ldr r3, [pc, #388] ; 300075d4 <rtems_termios_open+0x444>
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';
3000744c: e2822002 add r2, r2, #2
/*
* 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;
30007450: e5843038 str r3, [r4, #56] ; 0x38
tty->termios.c_lflag =
30007454: e59f317c ldr r3, [pc, #380] ; 300075d8 <rtems_termios_open+0x448>
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';
30007458: e5c4204a strb r2, [r4, #74] ; 0x4a
* 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 =
3000745c: e584303c str r3, [r4, #60] ; 0x3c
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
30007460: e3a03003 mov r3, #3 30007464: e5c43041 strb r3, [r4, #65] ; 0x41
tty->termios.c_cc[VQUIT] = '\034';
30007468: e2833019 add r3, r3, #25 3000746c: e5c43042 strb r3, [r4, #66] ; 0x42
tty->termios.c_cc[VERASE] = '\177';
30007470: e2833063 add r3, r3, #99 ; 0x63 30007474: e5c43043 strb r3, [r4, #67] ; 0x43
tty->termios.c_cc[VKILL] = '\025';
30007478: e3a03015 mov r3, #21 3000747c: e5c43044 strb r3, [r4, #68] ; 0x44
tty->termios.c_cc[VEOF] = '\004';
30007480: e3a03004 mov r3, #4 30007484: e5c43045 strb r3, [r4, #69] ; 0x45
tty->termios.c_cc[VEOL] = '\000';
30007488: 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;
3000748c: e58430b8 str r3, [r4, #184] ; 0xb8
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';
30007490: e5c4304c strb r3, [r4, #76] ; 0x4c
tty->termios.c_cc[VEOL2] = '\000';
30007494: e5c43051 strb r3, [r4, #81] ; 0x51
/* 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;
30007498: e5943064 ldr r3, [r4, #100] ; 0x64
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';
3000749c: e2822007 add r2, r2, #7
/* 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;
300074a0: e1a030a3 lsr r3, r3, #1 300074a4: e58430bc str r3, [r4, #188] ; 0xbc
tty->highwater = tty->rawInBuf.Size * 3/4;
300074a8: e5943064 ldr r3, [r4, #100] ; 0x64
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';
300074ac: e5c4204b strb r2, [r4, #75] ; 0x4b
tty->termios.c_cc[VREPRINT] = '\022';
300074b0: e3a02012 mov r2, #18 300074b4: e5c4204d strb r2, [r4, #77] ; 0x4d
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;
300074b8: e0833083 add r3, r3, r3, lsl #1
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';
300074bc: e3a0200f mov r2, #15 300074c0: e5c4204e strb r2, [r4, #78] ; 0x4e
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;
300074c4: e1a03123 lsr r3, r3, #2
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';
300074c8: e2822008 add r2, r2, #8 300074cc: e5c4204f strb r2, [r4, #79] ; 0x4f
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;
300074d0: e58430c0 str r3, [r4, #192] ; 0xc0
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';
300074d4: e3a02016 mov r2, #22
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
300074d8: e59f30cc ldr r3, [pc, #204] ; 300075ac <rtems_termios_open+0x41c>
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';
300074dc: e5c42050 strb r2, [r4, #80] ; 0x50
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
300074e0: e5d3200c ldrb r2, [r3, #12] 300074e4: e352007a cmp r2, #122 ; 0x7a 300074e8: e2821001 add r1, r2, #1
c = 'a';
300074ec: 03a02061 moveq r2, #97 ; 0x61
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
300074f0: e5c3100c strb r1, [r3, #12]
c = 'a';
300074f4: 05c3200c strbeq r2, [r3, #12]
}
args->iop->data1 = tty;
300074f8: e5983000 ldr r3, [r8] 300074fc: e5835034 str r5, [r3, #52] ; 0x34
if (!tty->refcount++) {
30007500: e5953008 ldr r3, [r5, #8] 30007504: e2832001 add r2, r3, #1 30007508: e3530000 cmp r3, #0 3000750c: e5852008 str r2, [r5, #8]
30007510: 1a000016 bne 30007570 <rtems_termios_open+0x3e0>
if (tty->device.firstOpen)
30007514: e5953098 ldr r3, [r5, #152] ; 0x98 30007518: e3530000 cmp r3, #0
(*tty->device.firstOpen)(major, minor, arg);
3000751c: 11a00009 movne r0, r9 30007520: 11a0100a movne r1, sl 30007524: 11a02008 movne r2, r8 30007528: 11a0e00f movne lr, pc 3000752c: 112fff13 bxne r3
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30007530: e59530b4 ldr r3, [r5, #180] ; 0xb4 30007534: e3530002 cmp r3, #2
30007538: 1a00000c bne 30007570 <rtems_termios_open+0x3e0>
sc = rtems_task_start(
3000753c: e59500c4 ldr r0, [r5, #196] ; 0xc4 <== NOT EXECUTED 30007540: e59f1094 ldr r1, [pc, #148] ; 300075dc <rtems_termios_open+0x44c><== NOT EXECUTED 30007544: e1a02005 mov r2, r5 <== NOT EXECUTED 30007548: eb0008e9 bl 300098f4 <rtems_task_start> <== NOT EXECUTED
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
3000754c: e3500000 cmp r0, #0 <== NOT EXECUTED 30007550: 1a000005 bne 3000756c <rtems_termios_open+0x3dc> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
30007554: e59500c8 ldr r0, [r5, #200] ; 0xc8 <== NOT EXECUTED 30007558: e59f1080 ldr r1, [pc, #128] ; 300075e0 <rtems_termios_open+0x450><== NOT EXECUTED 3000755c: e1a02005 mov r2, r5 <== NOT EXECUTED 30007560: eb0008e3 bl 300098f4 <rtems_task_start> <== NOT EXECUTED
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
30007564: e3500000 cmp r0, #0 <== NOT EXECUTED 30007568: 0a000000 beq 30007570 <rtems_termios_open+0x3e0> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
3000756c: eb000965 bl 30009b08 <rtems_fatal_error_occurred>
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
30007570: e59f302c ldr r3, [pc, #44] ; 300075a4 <rtems_termios_open+0x414> 30007574: e5930000 ldr r0, [r3] 30007578: eb00080e bl 300095b8 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
3000757c: e1a00006 mov r0, r6
30007580: e28dd010 add sp, sp, #16
30007584: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
30007588: e3a00001 mov r0, #1 3000758c: e3a010e8 mov r1, #232 ; 0xe8 30007590: ebfffadf bl 30006114 <calloc>
if (tty == NULL) {
30007594: e2504000 subs r4, r0, #0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
30007598: e1a05000 mov r5, r0
if (tty == NULL) {
3000759c: 1affff15 bne 300071f8 <rtems_termios_open+0x68>
300075a0: eaffff21 b 3000722c <rtems_termios_open+0x9c> <== NOT EXECUTED
30007b38 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
30007b38: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
30007b3c: e1a04002 mov r4, r2
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30007b40: e59220b4 ldr r2, [r2, #180] ; 0xb4
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
30007b44: e1a03000 mov r3, r0
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30007b48: e3520000 cmp r2, #0
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
30007b4c: e1a06001 mov r6, r1
const unsigned char *buf = _buf;
30007b50: e1a08000 mov r8, r0
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
30007b54: 15945080 ldrne r5, [r4, #128] ; 0x80
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
30007b58: 13a0a002 movne sl, #2
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
30007b5c: 13a09001 movne r9, #1
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30007b60: 1a000031 bne 30007c2c <rtems_termios_puts+0xf4>
(*tty->device.write)(tty->minor, (void *)buf, len);
30007b64: e5940010 ldr r0, [r4, #16] 30007b68: e1a01003 mov r1, r3 30007b6c: e1a02006 mov r2, r6 30007b70: e1a0e00f mov lr, pc 30007b74: e594f0a4 ldr pc, [r4, #164] ; 0xa4
return;
30007b78: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
30007b7c: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED 30007b80: e2850001 add r0, r5, #1 <== NOT EXECUTED 30007b84: eb003007 bl 30013ba8 <__umodsi3> <== NOT EXECUTED 30007b88: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_interrupt_disable (level);
30007b8c: ebfffd64 bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED 30007b90: e1a07000 mov r7, r0 <== NOT EXECUTED
while (newHead == tty->rawOutBuf.Tail) {
30007b94: ea000009 b 30007bc0 <rtems_termios_puts+0x88> <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
30007b98: e584a094 str sl, [r4, #148] ; 0x94 <== NOT EXECUTED 30007b9c: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
30007ba0: e3a01000 mov r1, #0 <== NOT EXECUTED 30007ba4: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED 30007ba8: e1a02001 mov r2, r1 <== NOT EXECUTED 30007bac: eb00063b bl 300094a0 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
30007bb0: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
30007bb4: 1b0007d3 blne 30009b08 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
30007bb8: ebfffd59 bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED 30007bbc: e1a07000 mov r7, r0 <== NOT EXECUTED
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
30007bc0: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED 30007bc4: e1550003 cmp r5, r3 <== NOT EXECUTED 30007bc8: 0afffff2 beq 30007b98 <rtems_termios_puts+0x60> <== NOT EXECUTED
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++;
30007bcc: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED 30007bd0: e4d81001 ldrb r1, [r8], #1 <== NOT EXECUTED 30007bd4: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED 30007bd8: e7c21003 strb r1, [r2, r3] <== NOT EXECUTED
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
30007bdc: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
30007be0: e5845080 str r5, [r4, #128] ; 0x80 <== NOT EXECUTED
if (tty->rawOutBufState == rob_idle) {
30007be4: e3530000 cmp r3, #0 <== NOT EXECUTED 30007be8: 1a00000d bne 30007c24 <rtems_termios_puts+0xec> <== NOT EXECUTED
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
30007bec: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007bf0: e3130010 tst r3, #16 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
30007bf4: 159430b8 ldrne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007bf8: 13833020 orrne r3, r3, #32 <== NOT EXECUTED 30007bfc: 158430b8 strne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
30007c00: 1a000006 bne 30007c20 <rtems_termios_puts+0xe8> <== NOT EXECUTED
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
30007c04: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
30007c08: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED 30007c0c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30007c10: e0811003 add r1, r1, r3 <== NOT EXECUTED 30007c14: e3a02001 mov r2, #1 <== NOT EXECUTED 30007c18: e1a0e00f mov lr, pc <== NOT EXECUTED 30007c1c: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
30007c20: e5849094 str r9, [r4, #148] ; 0x94 <== NOT EXECUTED 30007c24: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
}
rtems_interrupt_enable (level);
len--;
30007c28: e2466001 sub r6, r6, #1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
30007c2c: e3560000 cmp r6, #0 <== NOT EXECUTED
30007c30: 1affffd1 bne 30007b7c <rtems_termios_puts+0x44> <== NOT EXECUTED
30007c34: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
30008280 <rtems_termios_read>:
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
30008280: e5903000 ldr r3, [r0] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
30008284: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
30008288: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3000828c: e3a01000 mov r1, #0 <== NOT EXECUTED
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;
30008290: e5908010 ldr r8, [r0, #16] <== NOT EXECUTED
char *buffer = args->buffer;
30008294: e590b00c ldr fp, [r0, #12] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
30008298: e1a05000 mov r5, r0 <== NOT EXECUTED
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);
3000829c: e1a02001 mov r2, r1 <== NOT EXECUTED 300082a0: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED 300082a4: eb00047d bl 300094a0 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
300082a8: e2507000 subs r7, r0, #0 <== NOT EXECUTED 300082ac: 1a0000be bne 300085ac <rtems_termios_read+0x32c> <== NOT EXECUTED
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
300082b0: e59420cc ldr r2, [r4, #204] ; 0xcc <== NOT EXECUTED 300082b4: e59f32f8 ldr r3, [pc, #760] ; 300085b4 <rtems_termios_read+0x334><== NOT EXECUTED 300082b8: e0833282 add r3, r3, r2, lsl #5 <== NOT EXECUTED 300082bc: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 300082c0: e3530000 cmp r3, #0 <== NOT EXECUTED 300082c4: 0a000005 beq 300082e0 <rtems_termios_read+0x60> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
300082c8: e1a00004 mov r0, r4 <== NOT EXECUTED 300082cc: e1a01005 mov r1, r5 <== NOT EXECUTED 300082d0: e1a0e00f mov lr, pc <== NOT EXECUTED 300082d4: e12fff13 bx r3 <== NOT EXECUTED 300082d8: e1a07000 mov r7, r0 <== NOT EXECUTED 300082dc: ea0000ae b 3000859c <rtems_termios_read+0x31c> <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
300082e0: e5942024 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED 300082e4: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 300082e8: e1520003 cmp r2, r3 <== NOT EXECUTED 300082ec: 1a0000a1 bne 30008578 <rtems_termios_read+0x2f8> <== NOT EXECUTED
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
300082f0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
300082f4: e5847020 str r7, [r4, #32] <== NOT EXECUTED
tty->read_start_column = tty->column;
300082f8: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
if (tty->device.pollRead != NULL &&
300082fc: e59430a0 ldr r3, [r4, #160] ; 0xa0 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
30008300: e5847024 str r7, [r4, #36] ; 0x24 <== NOT EXECUTED
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
30008304: e3530000 cmp r3, #0 <== NOT EXECUTED 30008308: 0a00003b beq 300083fc <rtems_termios_read+0x17c> <== NOT EXECUTED 3000830c: e59430b4 ldr r3, [r4, #180] ; 0xb4 <== NOT EXECUTED 30008310: e3530000 cmp r3, #0 <== NOT EXECUTED 30008314: 1a000038 bne 300083fc <rtems_termios_read+0x17c> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
30008318: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 3000831c: e3130002 tst r3, #2 <== NOT EXECUTED 30008320: 0a00000d beq 3000835c <rtems_termios_read+0xdc> <== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
30008324: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008328: e1a0e00f mov lr, pc <== NOT EXECUTED 3000832c: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (n < 0) {
30008330: e3500000 cmp r0, #0 <== NOT EXECUTED 30008334: aa000002 bge 30008344 <rtems_termios_read+0xc4> <== NOT EXECUTED
rtems_task_wake_after (1);
30008338: e3a00001 mov r0, #1 <== NOT EXECUTED 3000833c: eb000584 bl 30009954 <rtems_task_wake_after> <== NOT EXECUTED 30008340: eafffff7 b 30008324 <rtems_termios_read+0xa4> <== NOT EXECUTED
} else {
if (siproc (n, tty))
30008344: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 30008348: e1a01004 mov r1, r4 <== NOT EXECUTED 3000834c: ebffff86 bl 3000816c <siproc> <== NOT EXECUTED 30008350: e3500000 cmp r0, #0 <== NOT EXECUTED 30008354: 0afffff2 beq 30008324 <rtems_termios_read+0xa4> <== NOT EXECUTED 30008358: ea000086 b 30008578 <rtems_termios_read+0x2f8> <== NOT EXECUTED
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
3000835c: eb0002c4 bl 30008e74 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED 30008360: e1a06000 mov r6, r0 <== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
30008364: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008368: e1a0e00f mov lr, pc <== NOT EXECUTED 3000836c: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (n < 0) {
30008370: e3500000 cmp r0, #0 <== NOT EXECUTED 30008374: aa000013 bge 300083c8 <rtems_termios_read+0x148> <== NOT EXECUTED
if (tty->termios.c_cc[VMIN]) {
30008378: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED 3000837c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008380: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED 30008384: 0a000005 beq 300083a0 <rtems_termios_read+0x120> <== NOT EXECUTED
if (tty->termios.c_cc[VTIME] && tty->ccount) {
30008388: e3530000 cmp r3, #0 <== NOT EXECUTED 3000838c: 0a00000a beq 300083bc <rtems_termios_read+0x13c> <== NOT EXECUTED 30008390: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 30008394: e3530000 cmp r3, #0 <== NOT EXECUTED 30008398: 0a000007 beq 300083bc <rtems_termios_read+0x13c> <== NOT EXECUTED 3000839c: ea000001 b 300083a8 <rtems_termios_read+0x128> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
300083a0: e3530000 cmp r3, #0 <== NOT EXECUTED 300083a4: 0a000073 beq 30008578 <rtems_termios_read+0x2f8> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
300083a8: eb0002b1 bl 30008e74 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
300083ac: e5943054 ldr r3, [r4, #84] ; 0x54 <== NOT EXECUTED 300083b0: e0660000 rsb r0, r6, r0 <== NOT EXECUTED 300083b4: e1500003 cmp r0, r3 <== NOT EXECUTED 300083b8: 8a00006e bhi 30008578 <rtems_termios_read+0x2f8> <== NOT EXECUTED
break;
}
}
rtems_task_wake_after (1);
300083bc: e3a00001 mov r0, #1 <== NOT EXECUTED 300083c0: eb000563 bl 30009954 <rtems_task_wake_after> <== NOT EXECUTED 300083c4: eaffffe6 b 30008364 <rtems_termios_read+0xe4> <== NOT EXECUTED
} else {
siproc (n, tty);
300083c8: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 300083cc: e1a01004 mov r1, r4 <== NOT EXECUTED 300083d0: ebffff65 bl 3000816c <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
300083d4: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED 300083d8: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED 300083dc: e1520003 cmp r2, r3 <== NOT EXECUTED 300083e0: aa000064 bge 30008578 <rtems_termios_read+0x2f8> <== NOT EXECUTED
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
300083e4: e3530000 cmp r3, #0 <== NOT EXECUTED 300083e8: 0affffdd beq 30008364 <rtems_termios_read+0xe4> <== NOT EXECUTED 300083ec: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED 300083f0: e3530000 cmp r3, #0 <== NOT EXECUTED 300083f4: 0affffda beq 30008364 <rtems_termios_read+0xe4> <== NOT EXECUTED 300083f8: eaffffd7 b 3000835c <rtems_termios_read+0xdc> <== NOT EXECUTED
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
300083fc: e2842049 add r2, r4, #73 ; 0x49 <== NOT EXECUTED
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
30008400: e594a074 ldr sl, [r4, #116] ; 0x74 <== NOT EXECUTED
rtems_status_code sc; int wait = (int)1;
30008404: e3a06001 mov r6, #1 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
30008408: e59f91a8 ldr r9, [pc, #424] ; 300085b8 <rtems_termios_read+0x338><== NOT EXECUTED
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
3000840c: e58d2000 str r2, [sp] <== NOT EXECUTED 30008410: ea000040 b 30008518 <rtems_termios_read+0x298> <== NOT EXECUTED
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
30008414: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 30008418: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED 3000841c: e2800001 add r0, r0, #1 <== NOT EXECUTED 30008420: eb002de0 bl 30013ba8 <__umodsi3> <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
30008424: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED 30008428: e7d3a000 ldrb sl, [r3, r0] <== NOT EXECUTED
tty->rawInBuf.Head = newHead;
3000842c: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
30008430: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED 30008434: e5942064 ldr r2, [r4, #100] ; 0x64 <== NOT EXECUTED
% tty->rawInBuf.Size)
30008438: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
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)
3000843c: e0823003 add r3, r2, r3 <== NOT EXECUTED
% tty->rawInBuf.Size)
30008440: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 30008444: eb002dd7 bl 30013ba8 <__umodsi3> <== NOT EXECUTED
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)
30008448: e59430bc ldr r3, [r4, #188] ; 0xbc <== NOT EXECUTED 3000844c: e1500003 cmp r0, r3 <== NOT EXECUTED 30008450: 2a00001f bcs 300084d4 <rtems_termios_read+0x254> <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
30008454: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008458: e3c33001 bic r3, r3, #1 <== NOT EXECUTED 3000845c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
30008460: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008464: e59f3150 ldr r3, [pc, #336] ; 300085bc <rtems_termios_read+0x33c><== NOT EXECUTED 30008468: e0023003 and r3, r2, r3 <== NOT EXECUTED 3000846c: e59f2148 ldr r2, [pc, #328] ; 300085bc <rtems_termios_read+0x33c><== NOT EXECUTED 30008470: e1530002 cmp r3, r2 <== NOT EXECUTED 30008474: 1a00000b bne 300084a8 <rtems_termios_read+0x228> <== NOT EXECUTED
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
30008478: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED 3000847c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008480: 0a000002 beq 30008490 <rtems_termios_read+0x210> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
30008484: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008488: e3130020 tst r3, #32 <== NOT EXECUTED 3000848c: 0a000005 beq 300084a8 <rtems_termios_read+0x228> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
30008490: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008494: e59d1000 ldr r1, [sp] <== NOT EXECUTED 30008498: e3a02001 mov r2, #1 <== NOT EXECUTED 3000849c: e1a0e00f mov lr, pc <== NOT EXECUTED 300084a0: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 300084a4: ea00000a b 300084d4 <rtems_termios_read+0x254> <== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
300084a8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300084ac: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300084b0: 0a000007 beq 300084d4 <rtems_termios_read+0x254> <== NOT EXECUTED
tty->flow_ctrl &= ~FL_IRTSOFF;
300084b4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300084b8: e3c33004 bic r3, r3, #4 <== NOT EXECUTED 300084bc: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
300084c0: e59430b0 ldr r3, [r4, #176] ; 0xb0 <== NOT EXECUTED 300084c4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
300084c8: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED 300084cc: 11a0e00f movne lr, pc <== NOT EXECUTED 300084d0: 112fff13 bxne r3 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
300084d4: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 300084d8: e3130002 tst r3, #2 <== NOT EXECUTED 300084dc: 0a000005 beq 300084f8 <rtems_termios_read+0x278> <== NOT EXECUTED
if (siproc (c, tty))
300084e0: e1a0000a mov r0, sl <== NOT EXECUTED 300084e4: e1a01004 mov r1, r4 <== NOT EXECUTED 300084e8: ebffff1f bl 3000816c <siproc> <== NOT EXECUTED
wait = 0;
300084ec: e3500000 cmp r0, #0 <== NOT EXECUTED 300084f0: 13a06000 movne r6, #0 <== NOT EXECUTED 300084f4: ea000006 b 30008514 <rtems_termios_read+0x294> <== NOT EXECUTED
} else {
siproc (c, tty);
300084f8: e1a0000a mov r0, sl <== NOT EXECUTED 300084fc: e1a01004 mov r1, r4 <== NOT EXECUTED 30008500: ebffff19 bl 3000816c <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
30008504: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED 30008508: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
wait = 0;
3000850c: e1520003 cmp r2, r3 <== NOT EXECUTED 30008510: a3a06000 movge r6, #0 <== NOT EXECUTED
}
timeout = tty->rawInBufSemaphoreTimeout;
30008514: e594a070 ldr sl, [r4, #112] ; 0x70 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008518: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED 3000851c: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED 30008520: e1520003 cmp r2, r3 <== NOT EXECUTED 30008524: 0a000004 beq 3000853c <rtems_termios_read+0x2bc> <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
30008528: e5993008 ldr r3, [r9, #8] <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
3000852c: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
30008530: e2433001 sub r3, r3, #1 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008534: e1520003 cmp r2, r3 <== NOT EXECUTED 30008538: baffffb5 blt 30008414 <rtems_termios_read+0x194> <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
3000853c: e3560000 cmp r6, #0 <== NOT EXECUTED 30008540: 0a00000c beq 30008578 <rtems_termios_read+0x2f8> <== NOT EXECUTED
sc = rtems_semaphore_obtain(
30008544: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED 30008548: e594106c ldr r1, [r4, #108] ; 0x6c <== NOT EXECUTED 3000854c: e1a0200a mov r2, sl <== NOT EXECUTED 30008550: eb0003d2 bl 300094a0 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
30008554: e3500000 cmp r0, #0 <== NOT EXECUTED 30008558: 0affffee beq 30008518 <rtems_termios_read+0x298> <== NOT EXECUTED 3000855c: ea000005 b 30008578 <rtems_termios_read+0x2f8> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
30008560: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
count--;
30008564: e2488001 sub r8, r8, #1 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
30008568: e7d22003 ldrb r2, [r2, r3] <== NOT EXECUTED 3000856c: e2833001 add r3, r3, #1 <== NOT EXECUTED 30008570: e4cb2001 strb r2, [fp], #1 <== NOT EXECUTED 30008574: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
30008578: e3580000 cmp r8, #0 <== NOT EXECUTED 3000857c: 0a000003 beq 30008590 <rtems_termios_read+0x310> <== NOT EXECUTED 30008580: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 30008584: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED 30008588: e1530002 cmp r3, r2 <== NOT EXECUTED 3000858c: bafffff3 blt 30008560 <rtems_termios_read+0x2e0> <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
30008590: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED 30008594: e0688003 rsb r8, r8, r3 <== NOT EXECUTED 30008598: e5858018 str r8, [r5, #24] <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
3000859c: e3a03000 mov r3, #0 <== NOT EXECUTED 300085a0: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
300085a4: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED 300085a8: eb000402 bl 300095b8 <rtems_semaphore_release> <== NOT EXECUTED
return sc; }
300085ac: e1a00007 mov r0, r7 <== NOT EXECUTED
300085b0: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
300088d0 <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))
300088d0: e59020b8 ldr r2, [r0, #184] ; 0xb8 <== NOT EXECUTED 300088d4: e59f31b8 ldr r3, [pc, #440] ; 30008a94 <rtems_termios_refill_transmitter+0x1c4><== NOT EXECUTED
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
300088d8: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
300088dc: e0023003 and r3, r2, r3 <== NOT EXECUTED 300088e0: e59f21b0 ldr r2, [pc, #432] ; 30008a98 <rtems_termios_refill_transmitter+0x1c8><== NOT EXECUTED
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
300088e4: e1a04000 mov r4, r0 <== NOT EXECUTED
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
300088e8: e1530002 cmp r3, r2 <== NOT EXECUTED 300088ec: 1a00000c bne 30008924 <rtems_termios_refill_transmitter+0x54><== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
300088f0: e284104a add r1, r4, #74 ; 0x4a <== NOT EXECUTED 300088f4: e2422b01 sub r2, r2, #1024 ; 0x400 <== NOT EXECUTED 300088f8: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED 300088fc: e1a0e00f mov lr, pc <== NOT EXECUTED 30008900: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
rtems_interrupt_disable(level);
30008904: ebfffa06 bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED
tty->t_dqlen--;
30008908: e5943090 ldr r3, [r4, #144] ; 0x90 <== NOT EXECUTED 3000890c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30008910: e5843090 str r3, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
30008914: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008918: e3833002 orr r3, r3, #2 <== NOT EXECUTED 3000891c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
rtems_interrupt_enable(level);
30008920: ea00000f b 30008964 <rtems_termios_refill_transmitter+0x94><== NOT EXECUTED
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
30008924: e59030b8 ldr r3, [r0, #184] ; 0xb8 <== NOT EXECUTED 30008928: e2033003 and r3, r3, #3 <== NOT EXECUTED 3000892c: e3530002 cmp r3, #2 <== NOT EXECUTED 30008930: 1a00000e bne 30008970 <rtems_termios_refill_transmitter+0xa0><== 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);
30008934: e2841049 add r1, r4, #73 ; 0x49 <== NOT EXECUTED 30008938: e3a02001 mov r2, #1 <== NOT EXECUTED 3000893c: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED 30008940: e1a0e00f mov lr, pc <== NOT EXECUTED 30008944: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
rtems_interrupt_disable(level);
30008948: ebfff9f5 bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED
tty->t_dqlen--;
3000894c: e5943090 ldr r3, [r4, #144] ; 0x90 <== NOT EXECUTED 30008950: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30008954: e5843090 str r3, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
30008958: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 3000895c: e3c33002 bic r3, r3, #2 <== NOT EXECUTED 30008960: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008964: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
30008968: e3a05001 mov r5, #1 <== NOT EXECUTED 3000896c: ea000046 b 30008a8c <rtems_termios_refill_transmitter+0x1bc><== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
30008970: e5902080 ldr r2, [r0, #128] ; 0x80 <== NOT EXECUTED 30008974: e5903084 ldr r3, [r0, #132] ; 0x84 <== NOT EXECUTED 30008978: e1520003 cmp r2, r3 <== NOT EXECUTED 3000897c: 1a000005 bne 30008998 <rtems_termios_refill_transmitter+0xc8><== NOT EXECUTED
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
30008980: e5903094 ldr r3, [r0, #148] ; 0x94 <== NOT EXECUTED 30008984: e3530002 cmp r3, #2 <== NOT EXECUTED 30008988: 1a00003e bne 30008a88 <rtems_termios_refill_transmitter+0x1b8><== NOT EXECUTED
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
3000898c: e590008c ldr r0, [r0, #140] ; 0x8c <== NOT EXECUTED 30008990: eb000308 bl 300095b8 <rtems_semaphore_release> <== NOT EXECUTED 30008994: ea00003b b 30008a88 <rtems_termios_refill_transmitter+0x1b8><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
30008998: ebfff9e1 bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED
len = tty->t_dqlen;
tty->t_dqlen = 0;
3000899c: e3a03000 mov r3, #0 <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
300089a0: e5942090 ldr r2, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->t_dqlen = 0;
300089a4: e5843090 str r3, [r4, #144] ; 0x90 <== NOT EXECUTED 300089a8: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
300089ac: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED 300089b0: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED 300089b4: e0820003 add r0, r2, r3 <== NOT EXECUTED 300089b8: eb002c7a bl 30013ba8 <__umodsi3> <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
300089bc: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
300089c0: e1a06000 mov r6, r0 <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
300089c4: e3530002 cmp r3, #2 <== NOT EXECUTED
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
tty->rawOutBuf.Tail = newTail;
300089c8: e5840084 str r0, [r4, #132] ; 0x84 <== NOT EXECUTED
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
300089cc: 0594008c ldreq r0, [r4, #140] ; 0x8c <== NOT EXECUTED 300089d0: 0b0002f8 bleq 300095b8 <rtems_semaphore_release> <== NOT EXECUTED
}
if (newTail == tty->rawOutBuf.Head) {
300089d4: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED 300089d8: e1560003 cmp r6, r3 <== NOT EXECUTED 300089dc: 1a00000a bne 30008a0c <rtems_termios_refill_transmitter+0x13c><== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
300089e0: e59430d4 ldr r3, [r4, #212] ; 0xd4 <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
300089e4: e3a05000 mov r5, #0 <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
300089e8: e1530005 cmp r3, r5 <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
300089ec: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
nToSend = 0;
300089f0: 01a05003 moveq r5, r3 <== NOT EXECUTED
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
300089f4: 0a000021 beq 30008a80 <rtems_termios_refill_transmitter+0x1b0><== NOT EXECUTED
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
300089f8: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 300089fc: e59410d8 ldr r1, [r4, #216] ; 0xd8 <== NOT EXECUTED 30008a00: e1a0e00f mov lr, pc <== NOT EXECUTED 30008a04: e12fff13 bx r3 <== NOT EXECUTED 30008a08: ea00001c b 30008a80 <rtems_termios_refill_transmitter+0x1b0><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
30008a0c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008a10: e2033e21 and r3, r3, #528 ; 0x210 <== NOT EXECUTED 30008a14: e3530e21 cmp r3, #528 ; 0x210 <== NOT EXECUTED 30008a18: 1a000008 bne 30008a40 <rtems_termios_refill_transmitter+0x170><== NOT EXECUTED
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
30008a1c: ebfff9c0 bl 30007124 <arm_interrupt_disable> <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
30008a20: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008a24: e3833020 orr r3, r3, #32 <== NOT EXECUTED 30008a28: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
30008a2c: e3a03001 mov r3, #1 <== NOT EXECUTED 30008a30: e5843094 str r3, [r4, #148] ; 0x94 <== NOT EXECUTED 30008a34: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 0;
30008a38: e3a05000 mov r5, #0 <== NOT EXECUTED 30008a3c: ea00000f b 30008a80 <rtems_termios_refill_transmitter+0x1b0><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
30008a40: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
30008a44: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
30008a48: e1560003 cmp r6, r3 <== NOT EXECUTED
nToSend = tty->rawOutBuf.Size - newTail;
30008a4c: 85945088 ldrhi r5, [r4, #136] ; 0x88 <== NOT EXECUTED
else
nToSend = tty->rawOutBuf.Head - newTail;
30008a50: 95945080 ldrls r5, [r4, #128] ; 0x80 <== NOT EXECUTED
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
30008a54: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
30008a58: e0665005 rsb r5, r6, r5 <== NOT EXECUTED
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
30008a5c: e3130c06 tst r3, #1536 ; 0x600 <== NOT EXECUTED
nToSend = 1;
30008a60: 13a05001 movne r5, #1 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
30008a64: e3a03001 mov r3, #1 <== NOT EXECUTED 30008a68: e5843094 str r3, [r4, #148] ; 0x94 <== NOT EXECUTED
(*tty->device.write)(
30008a6c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008a70: e0811006 add r1, r1, r6 <== NOT EXECUTED 30008a74: e1a02005 mov r2, r5 <== NOT EXECUTED 30008a78: e1a0e00f mov lr, pc <== NOT EXECUTED 30008a7c: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
30008a80: e5846084 str r6, [r4, #132] ; 0x84 <== NOT EXECUTED 30008a84: ea000000 b 30008a8c <rtems_termios_refill_transmitter+0x1bc><== NOT EXECUTED
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
30008a88: e3a05000 mov r5, #0 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
30008a8c: e1a00005 mov r0, r5 <== NOT EXECUTED
30008a90: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000886c <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
3000886c: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr} <== NOT EXECUTED
30008870: e1a04000 mov r4, r0 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30008874: e3a05000 mov r5, #0 <== NOT EXECUTED
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
30008878: e28d6007 add r6, sp, #7 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
3000887c: e1a0300d mov r3, sp <== NOT EXECUTED 30008880: e3a00003 mov r0, #3 <== NOT EXECUTED 30008884: e3a01002 mov r1, #2 <== NOT EXECUTED 30008888: e3a02000 mov r2, #0 <== NOT EXECUTED 3000888c: eb000195 bl 30008ee8 <rtems_event_receive> <== NOT EXECUTED
(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) {
30008890: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30008894: e3130001 tst r3, #1 <== NOT EXECUTED
tty->rxTaskId = 0;
30008898: 158450c4 strne r5, [r4, #196] ; 0xc4 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
3000889c: 11a00005 movne r0, r5 <== NOT EXECUTED 300088a0: 1b0003bd blne 3000979c <rtems_task_delete> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
300088a4: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 300088a8: e1a0e00f mov lr, pc <== NOT EXECUTED 300088ac: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (c != EOF) {
300088b0: e3700001 cmn r0, #1 <== NOT EXECUTED 300088b4: 0afffff0 beq 3000887c <rtems_termios_rxdaemon+0x10> <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
300088b8: e5cd0007 strb r0, [sp, #7] <== NOT EXECUTED
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
300088bc: e1a01006 mov r1, r6 <== NOT EXECUTED 300088c0: e1a00004 mov r0, r4 <== NOT EXECUTED 300088c4: e3a02001 mov r2, #1 <== NOT EXECUTED 300088c8: ebffff3f bl 300085cc <rtems_termios_enqueue_raw_characters><== NOT EXECUTED 300088cc: eaffffea b 3000887c <rtems_termios_rxdaemon+0x10> <== NOT EXECUTED
300085c0 <rtems_termios_rxirq_occured>:
void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty)
{
/*
* send event to rx daemon task
*/
rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT);
300085c0: e59000c4 ldr r0, [r0, #196] ; 0xc4 <== NOT EXECUTED 300085c4: e3a01002 mov r1, #2 <== NOT EXECUTED 300085c8: ea0002a2 b 30009058 <rtems_event_send> <== NOT EXECUTED
3000aa1c <rtems_termios_set_initial_baud>:
int rtems_termios_set_initial_baud(
struct rtems_termios_tty *ttyp,
int32_t baud
)
{
3000aa1c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000aa20: e1a04000 mov r4, r0 <== NOT EXECUTED
int cflags_baud;
cflags_baud = rtems_termios_number_to_baud(baud);
3000aa24: e1a00001 mov r0, r1 <== NOT EXECUTED 3000aa28: ebfff95b bl 30008f9c <rtems_termios_number_to_baud> <== NOT EXECUTED
if ( cflags_baud == -1 )
3000aa2c: e3700001 cmn r0, #1 <== NOT EXECUTED
3000aa30: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return -1;
ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
3000aa34: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 3000aa38: e3c33a01 bic r3, r3, #4096 ; 0x1000 <== NOT EXECUTED 3000aa3c: e3c3300f bic r3, r3, #15 <== NOT EXECUTED 3000aa40: e1800003 orr r0, r0, r3 <== NOT EXECUTED 3000aa44: e5840038 str r0, [r4, #56] ; 0x38 <== NOT EXECUTED
return 0;
3000aa48: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000aa4c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30008a9c <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
30008a9c: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
30008aa0: e59f6054 ldr r6, [pc, #84] ; 30008afc <rtems_termios_txdaemon+0x60><== NOT EXECUTED
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
30008aa4: e1a04000 mov r4, r0 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30008aa8: e3a05000 mov r5, #0 <== NOT EXECUTED 30008aac: e1a0300d mov r3, sp <== NOT EXECUTED 30008ab0: e3a00003 mov r0, #3 <== NOT EXECUTED 30008ab4: e3a01002 mov r1, #2 <== NOT EXECUTED 30008ab8: e3a02000 mov r2, #0 <== NOT EXECUTED 30008abc: eb000109 bl 30008ee8 <rtems_event_receive> <== NOT EXECUTED
(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) {
30008ac0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30008ac4: e3130001 tst r3, #1 <== NOT EXECUTED
tty->txTaskId = 0;
30008ac8: 158450c8 strne r5, [r4, #200] ; 0xc8 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
30008acc: 11a00005 movne r0, r5 <== NOT EXECUTED 30008ad0: 1b000331 blne 3000979c <rtems_task_delete> <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
30008ad4: e59430cc ldr r3, [r4, #204] ; 0xcc <== NOT EXECUTED 30008ad8: e0863283 add r3, r6, r3, lsl #5 <== NOT EXECUTED 30008adc: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED 30008ae0: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
30008ae4: 11a00004 movne r0, r4 <== NOT EXECUTED 30008ae8: 11a0e00f movne lr, pc <== NOT EXECUTED 30008aec: 112fff13 bxne r3 <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
30008af0: e1a00004 mov r0, r4 <== NOT EXECUTED 30008af4: ebffff75 bl 300088d0 <rtems_termios_refill_transmitter> <== NOT EXECUTED
}
30008af8: eaffffeb b 30008aac <rtems_termios_txdaemon+0x10> <== NOT EXECUTED
300081c8 <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;
300081c8: e5903000 ldr r3, [r0]
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
300081cc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
300081d0: e5935034 ldr r5, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
300081d4: e3a01000 mov r1, #0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
300081d8: e1a04000 mov r4, r0
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
300081dc: e1a02001 mov r2, r1 300081e0: e5950018 ldr r0, [r5, #24] 300081e4: eb0004ad bl 300094a0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
300081e8: e2506000 subs r6, r0, #0
300081ec: 1a000020 bne 30008274 <rtems_termios_write+0xac>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
300081f0: e59520cc ldr r2, [r5, #204] ; 0xcc 300081f4: e59f3080 ldr r3, [pc, #128] ; 3000827c <rtems_termios_write+0xb4> 300081f8: e0833282 add r3, r3, r2, lsl #5 300081fc: e593300c ldr r3, [r3, #12] 30008200: e3530000 cmp r3, #0
30008204: 0a000005 beq 30008220 <rtems_termios_write+0x58>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
30008208: e1a00005 mov r0, r5 <== NOT EXECUTED 3000820c: e1a01004 mov r1, r4 <== NOT EXECUTED 30008210: e1a0e00f mov lr, pc <== NOT EXECUTED 30008214: e12fff13 bx r3 <== NOT EXECUTED 30008218: e1a06000 mov r6, r0 <== NOT EXECUTED 3000821c: ea000012 b 3000826c <rtems_termios_write+0xa4> <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
30008220: e5953034 ldr r3, [r5, #52] ; 0x34 30008224: e3130001 tst r3, #1
uint32_t count = args->count;
30008228: 15947010 ldrne r7, [r4, #16]
char *buffer = args->buffer;
3000822c: 1594800c ldrne r8, [r4, #12]
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) {
30008230: 1a000004 bne 30008248 <rtems_termios_write+0x80>
30008234: ea000006 b 30008254 <rtems_termios_write+0x8c> <== NOT EXECUTED
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
30008238: e4d80001 ldrb r0, [r8], #1 3000823c: e1a01005 mov r1, r5 30008240: ebfffe7c bl 30007c38 <oproc> 30008244: e2477001 sub r7, r7, #1
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
30008248: e3570000 cmp r7, #0
3000824c: 1afffff9 bne 30008238 <rtems_termios_write+0x70>
30008250: ea000003 b 30008264 <rtems_termios_write+0x9c>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
30008254: e594000c ldr r0, [r4, #12] <== NOT EXECUTED 30008258: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED 3000825c: e1a02005 mov r2, r5 <== NOT EXECUTED 30008260: ebfffe34 bl 30007b38 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
30008264: e5943010 ldr r3, [r4, #16] 30008268: e5843018 str r3, [r4, #24]
} rtems_semaphore_release (tty->osem);
3000826c: e5950018 ldr r0, [r5, #24] 30008270: eb0004d0 bl 300095b8 <rtems_semaphore_release>
return sc; }
30008274: e1a00006 mov r0, r6
30008278: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
30009e34 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
30009e34: e92d40f0 push {r4, r5, r6, r7, lr}
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
30009e38: e2506000 subs r6, r0, #0
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
30009e3c: e1a04001 mov r4, r1
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30009e40: 03a00003 moveq r0, #3
rtems_id *id
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
30009e44: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_NAME;
if ( !id )
30009e48: e3510000 cmp r1, #0
30009e4c: 0a00001b beq 30009ec0 <rtems_timer_create+0x8c>
30009e50: e59f3070 ldr r3, [pc, #112] ; 30009ec8 <rtems_timer_create+0x94> 30009e54: e5932000 ldr r2, [r3] 30009e58: e2822001 add r2, r2, #1 30009e5c: e5832000 str r2, [r3]
* This function allocates a timer control block from
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void )
{
return (Timer_Control *) _Objects_Allocate( &_Timer_Information );
30009e60: e59f5064 ldr r5, [pc, #100] ; 30009ecc <rtems_timer_create+0x98> 30009e64: e1a00005 mov r0, r5 30009e68: eb000399 bl 3000acd4 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
30009e6c: e3500000 cmp r0, #0
30009e70: 1a000002 bne 30009e80 <rtems_timer_create+0x4c>
_Thread_Enable_dispatch();
30009e74: eb0007aa bl 3000bd24 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30009e78: e3a00005 mov r0, #5 <== NOT EXECUTED
30009e7c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
}
the_timer->the_class = TIMER_DORMANT;
30009e80: e3a03004 mov r3, #4 30009e84: e5803038 str r3, [r0, #56] ; 0x38
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30009e88: e1d010b8 ldrh r1, [r0, #8] 30009e8c: e5903008 ldr r3, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009e90: e595201c ldr r2, [r5, #28]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30009e94: e3a07000 mov r7, #0 30009e98: e5807018 str r7, [r0, #24]
the_watchdog->routine = routine;
30009e9c: e580702c str r7, [r0, #44] ; 0x2c
the_watchdog->id = id;
30009ea0: e5807030 str r7, [r0, #48] ; 0x30
the_watchdog->user_data = user_data;
30009ea4: e5807034 str r7, [r0, #52] ; 0x34 30009ea8: e7820101 str r0, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30009eac: e580600c str r6, [r0, #12]
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
30009eb0: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
30009eb4: eb00079a bl 3000bd24 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30009eb8: e1a00007 mov r0, r7
30009ebc: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
30009ec0: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
30009ec4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30009ed0 <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30009ed0: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr}
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
30009ed4: e2516000 subs r6, r1, #0
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30009ed8: e1a04000 mov r4, r0 30009edc: e1a05002 mov r5, r2 30009ee0: e1a07003 mov r7, r3
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
30009ee4: 03a0000a moveq r0, #10
{
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
30009ee8: 0a000022 beq 30009f78 <rtems_timer_fire_after+0xa8>
return RTEMS_INVALID_NUMBER;
if ( !routine )
30009eec: e3520000 cmp r2, #0
return RTEMS_INVALID_ADDRESS;
30009ef0: 03a00009 moveq r0, #9
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
30009ef4: 0a00001f beq 30009f78 <rtems_timer_fire_after+0xa8>
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
30009ef8: e59f007c ldr r0, [pc, #124] ; 30009f7c <rtems_timer_fire_after+0xac> 30009efc: e1a01004 mov r1, r4 30009f00: e1a0200d mov r2, sp 30009f04: eb00048e bl 3000b144 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30009f08: e59d3000 ldr r3, [sp] 30009f0c: e1a08000 mov r8, r0 30009f10: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009f14: 13a00004 movne r0, #4
if ( !routine )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30009f18: 1a000016 bne 30009f78 <rtems_timer_fire_after+0xa8>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
30009f1c: e288a010 add sl, r8, #16 30009f20: e1a0000a mov r0, sl 30009f24: eb000b26 bl 3000cbc4 <_Watchdog_Remove>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30009f28: e10f2000 mrs r2, CPSR 30009f2c: e3823080 orr r3, r2, #128 ; 0x80 30009f30: e129f003 msr CPSR_fc, r3
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
30009f34: e5983018 ldr r3, [r8, #24] 30009f38: e3530000 cmp r3, #0
30009f3c: 0a000001 beq 30009f48 <rtems_timer_fire_after+0x78>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009f40: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 30009f44: ea000009 b 30009f70 <rtems_timer_fire_after+0xa0> <== NOT EXECUTED
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL;
30009f48: e5883038 str r3, [r8, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30009f4c: e5883018 str r3, [r8, #24]
the_watchdog->routine = routine;
30009f50: e588502c str r5, [r8, #44] ; 0x2c
the_watchdog->id = id;
30009f54: e5884030 str r4, [r8, #48] ; 0x30
the_watchdog->user_data = user_data;
30009f58: e5887034 str r7, [r8, #52] ; 0x34 30009f5c: e129f002 msr CPSR_fc, r2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30009f60: e59f0018 ldr r0, [pc, #24] ; 30009f80 <rtems_timer_fire_after+0xb0>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30009f64: e588601c str r6, [r8, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30009f68: e1a0100a mov r1, sl 30009f6c: eb000abc bl 3000ca64 <_Watchdog_Insert>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
30009f70: eb00076b bl 3000bd24 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30009f74: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30009f78: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc}
30018208 <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018208: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
3001820c: e1a08003 mov r8, r3
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
30018210: e59f30c4 ldr r3, [pc, #196] ; 300182dc <rtems_timer_fire_when+0xd4>
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018214: e1a04000 mov r4, r0
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
30018218: e5d33000 ldrb r3, [r3]
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001821c: e1a06001 mov r6, r1
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
30018220: e3530000 cmp r3, #0
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018224: e1a05002 mov r5, r2
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
30018228: 03a0000b moveq r0, #11
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
3001822c: 0a000029 beq 300182d8 <rtems_timer_fire_when+0xd0>
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
30018230: e1a00001 mov r0, r1 30018234: ebfff548 bl 3001575c <_TOD_Validate> 30018238: e3500000 cmp r0, #0
3001823c: 0a000024 beq 300182d4 <rtems_timer_fire_when+0xcc>
return RTEMS_INVALID_CLOCK;
if ( !routine )
30018240: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
30018244: 03a00009 moveq r0, #9
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
30018248: 0a000022 beq 300182d8 <rtems_timer_fire_when+0xd0>
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
3001824c: e1a00006 mov r0, r6 30018250: ebfff51e bl 300156d0 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
30018254: e59f7084 ldr r7, [pc, #132] ; 300182e0 <rtems_timer_fire_when+0xd8>
return RTEMS_INVALID_CLOCK;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
30018258: e1a06000 mov r6, r0
if ( seconds <= _TOD_Seconds_since_epoch() )
3001825c: e5973000 ldr r3, [r7] 30018260: e1500003 cmp r0, r3
30018264: 9a00001a bls 300182d4 <rtems_timer_fire_when+0xcc>
30018268: e59f0074 ldr r0, [pc, #116] ; 300182e4 <rtems_timer_fire_when+0xdc> 3001826c: e1a01004 mov r1, r4 30018270: e1a0200d mov r2, sp 30018274: eb000aa3 bl 3001ad08 <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018278: e59da000 ldr sl, [sp] 3001827c: e1a09000 mov r9, r0 30018280: e35a0000 cmp sl, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018284: 13a00004 movne r0, #4
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018288: 1a000012 bne 300182d8 <rtems_timer_fire_when+0xd0>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001828c: e289b010 add fp, r9, #16 30018290: e1a0000b mov r0, fp 30018294: eb0011f9 bl 3001ca80 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
30018298: e3a03002 mov r3, #2 3001829c: e5893038 str r3, [r9, #56] ; 0x38
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
300182a0: e5973000 ldr r3, [r7]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
300182a4: e59f003c ldr r0, [pc, #60] ; 300182e8 <rtems_timer_fire_when+0xe0> 300182a8: e0636006 rsb r6, r3, r6 300182ac: e1a0100b mov r1, fp
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
300182b0: e589a018 str sl, [r9, #24]
the_watchdog->routine = routine;
300182b4: e589502c str r5, [r9, #44] ; 0x2c
the_watchdog->id = id;
300182b8: e5894030 str r4, [r9, #48] ; 0x30
the_watchdog->user_data = user_data;
300182bc: e5898034 str r8, [r9, #52] ; 0x34
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
300182c0: e589601c str r6, [r9, #28]
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
300182c4: eb001195 bl 3001c920 <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
300182c8: eb000da8 bl 3001b970 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300182cc: e1a0000a mov r0, sl 300182d0: ea000000 b 300182d8 <rtems_timer_fire_when+0xd0>
if ( !routine )
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
300182d4: e3a00014 mov r0, #20 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300182d8: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
300182ec <rtems_timer_get_information>:
rtems_status_code rtems_timer_get_information(
rtems_id id,
rtems_timer_information *the_info
)
{
300182ec: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
300182f0: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_timer_get_information(
rtems_id id,
rtems_timer_information *the_info
)
{
300182f4: e1a03000 mov r3, r0 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
300182f8: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
300182fc: 0a000011 beq 30018348 <rtems_timer_get_information+0x5c> <== NOT EXECUTED 30018300: e59f0044 ldr r0, [pc, #68] ; 3001834c <rtems_timer_get_information+0x60><== NOT EXECUTED 30018304: e1a01003 mov r1, r3 <== NOT EXECUTED 30018308: e1a0200d mov r2, sp <== NOT EXECUTED 3001830c: eb000a7d bl 3001ad08 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018310: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30018314: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018318: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001831c: 1a000009 bne 30018348 <rtems_timer_get_information+0x5c> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
30018320: e5903038 ldr r3, [r0, #56] ; 0x38 <== NOT EXECUTED 30018324: e5843000 str r3, [r4] <== NOT EXECUTED
the_info->initial = the_timer->Ticker.initial;
30018328: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 3001832c: e5843004 str r3, [r4, #4] <== NOT EXECUTED
the_info->start_time = the_timer->Ticker.start_time;
30018330: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 30018334: e5843008 str r3, [r4, #8] <== NOT EXECUTED
the_info->stop_time = the_timer->Ticker.stop_time;
30018338: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 3001833c: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Thread_Enable_dispatch();
30018340: eb000d8a bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30018344: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018348: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30018968 <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
30018968: e92d41f7 push {r0, r1, r2, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
3001896c: e3500000 cmp r0, #0 <== NOT EXECUTED 30018970: e1a06001 mov r6, r1 <== NOT EXECUTED 30018974: e1a08002 mov r8, r2 <== NOT EXECUTED 30018978: 01a07000 moveq r7, r0 <== NOT EXECUTED 3001897c: 0a000004 beq 30018994 <rtems_timer_initiate_server+0x2c> <== NOT EXECUTED
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
30018980: e59f3124 ldr r3, [pc, #292] ; 30018aac <rtems_timer_initiate_server+0x144><== NOT EXECUTED 30018984: e5d37000 ldrb r7, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
30018988: e1500007 cmp r0, r7 <== NOT EXECUTED 3001898c: 83a07000 movhi r7, #0 <== NOT EXECUTED 30018990: 93a07001 movls r7, #1 <== NOT EXECUTED
* Make sure the requested priority is valid. The if is
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
30018994: e21770ff ands r7, r7, #255 ; 0xff <== NOT EXECUTED 30018998: 1a000003 bne 300189ac <rtems_timer_initiate_server+0x44> <== NOT EXECUTED
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
3001899c: e3700001 cmn r0, #1 <== NOT EXECUTED
return RTEMS_INVALID_PRIORITY;
300189a0: 13a00013 movne r0, #19 <== NOT EXECUTED
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
300189a4: 1a00003f bne 30018aa8 <rtems_timer_initiate_server+0x140> <== NOT EXECUTED 300189a8: ea000000 b 300189b0 <rtems_timer_initiate_server+0x48> <== NOT EXECUTED
* Make sure the requested priority is valid. The if is
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
300189ac: e1a07000 mov r7, r0 <== NOT EXECUTED
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
300189b0: e59f40f8 ldr r4, [pc, #248] ; 30018ab0 <rtems_timer_initiate_server+0x148><== NOT EXECUTED
}
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
300189b4: ebffff0d bl 300185f0 <_Thread_Disable_dispatch> <== NOT EXECUTED
tmpInitialized = initialized;
300189b8: e5d45000 ldrb r5, [r4] <== NOT EXECUTED
initialized = true;
300189bc: e3a03001 mov r3, #1 <== NOT EXECUTED 300189c0: e5c43000 strb r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
300189c4: eb000be9 bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( tmpInitialized )
300189c8: e3550000 cmp r5, #0 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
300189cc: 13a0000e movne r0, #14 <== NOT EXECUTED
_Thread_Disable_dispatch();
tmpInitialized = initialized;
initialized = true;
_Thread_Enable_dispatch();
if ( tmpInitialized )
300189d0: 1a000034 bne 30018aa8 <rtems_timer_initiate_server+0x140> <== NOT EXECUTED
* other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create(
300189d4: e28d3008 add r3, sp, #8 <== NOT EXECUTED 300189d8: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 300189dc: e3888902 orr r8, r8, #32768 ; 0x8000 <== NOT EXECUTED 300189e0: e59f00cc ldr r0, [pc, #204] ; 30018ab4 <rtems_timer_initiate_server+0x14c><== NOT EXECUTED 300189e4: e1a01007 mov r1, r7 <== NOT EXECUTED 300189e8: e1a02006 mov r2, r6 <== NOT EXECUTED 300189ec: e3a03c01 mov r3, #256 ; 0x100 <== NOT EXECUTED 300189f0: e58d8000 str r8, [sp] <== NOT EXECUTED 300189f4: ebfffb51 bl 30017740 <rtems_task_create> <== NOT EXECUTED
/* user may want floating point but we need */
/* system task specified for 0 priority */
attribute_set | RTEMS_SYSTEM_TASK,
&id /* get the id back */
);
if (status) {
300189f8: e3500000 cmp r0, #0 <== NOT EXECUTED
initialized = false;
300189fc: 15c45000 strbne r5, [r4] <== NOT EXECUTED
/* user may want floating point but we need */
/* system task specified for 0 priority */
attribute_set | RTEMS_SYSTEM_TASK,
&id /* get the id back */
);
if (status) {
30018a00: 1a000028 bne 30018aa8 <rtems_timer_initiate_server+0x140> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
30018a04: e59f20ac ldr r2, [pc, #172] ; 30018ab8 <rtems_timer_initiate_server+0x150><== NOT EXECUTED 30018a08: e1dd10b8 ldrh r1, [sp, #8] <== NOT EXECUTED 30018a0c: e592201c ldr r2, [r2, #28] <== NOT EXECUTED 30018a10: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
/*
* We work with the TCB pointer, not the ID, so we need to convert
* to a TCB pointer from here out.
*/
ts->thread = (Thread_Control *)_Objects_Get_local_object(
30018a14: e7921101 ldr r1, [r2, r1, lsl #2] <== NOT EXECUTED 30018a18: e1a02004 mov r2, r4 <== NOT EXECUTED 30018a1c: e5a21004 str r1, [r2, #4]! <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
30018a20: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED 30018a24: e5841034 str r1, [r4, #52] ; 0x34 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
30018a28: e2841034 add r1, r4, #52 ; 0x34 <== NOT EXECUTED 30018a2c: e584103c str r1, [r4, #60] ; 0x3c <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
30018a30: e2841070 add r1, r4, #112 ; 0x70 <== NOT EXECUTED 30018a34: e584106c str r1, [r4, #108] ; 0x6c <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
30018a38: e284106c add r1, r4, #108 ; 0x6c <== NOT EXECUTED 30018a3c: e5841074 str r1, [r4, #116] ; 0x74 <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30018a40: e59f1074 ldr r1, [pc, #116] ; 30018abc <rtems_timer_initiate_server+0x154><== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
30018a44: e5840038 str r0, [r4, #56] ; 0x38 <== NOT EXECUTED 30018a48: e5841028 str r1, [r4, #40] ; 0x28 <== NOT EXECUTED 30018a4c: e5841060 str r1, [r4, #96] ; 0x60 <== NOT EXECUTED
/*
* Initialize the pointer to the timer schedule method so applications that
* do not use the Timer Server do not have to pull it in.
*/
ts->schedule_operation = _Timer_server_Schedule_operation_method;
30018a50: e59f1068 ldr r1, [pc, #104] ; 30018ac0 <rtems_timer_initiate_server+0x158><== NOT EXECUTED 30018a54: e5840070 str r0, [r4, #112] ; 0x70 <== NOT EXECUTED 30018a58: e5841008 str r1, [r4, #8] <== NOT EXECUTED
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
30018a5c: e59f1060 ldr r1, [pc, #96] ; 30018ac4 <rtems_timer_initiate_server+0x15c><== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30018a60: e5840014 str r0, [r4, #20] <== NOT EXECUTED 30018a64: e5911000 ldr r1, [r1] <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
30018a68: e5840030 str r0, [r4, #48] ; 0x30 <== NOT EXECUTED 30018a6c: e5841040 str r1, [r4, #64] ; 0x40 <== NOT EXECUTED
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
30018a70: e59f1050 ldr r1, [pc, #80] ; 30018ac8 <rtems_timer_initiate_server+0x160><== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30018a74: e584004c str r0, [r4, #76] ; 0x4c <== NOT EXECUTED 30018a78: e5911000 ldr r1, [r1] <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
30018a7c: e5840068 str r0, [r4, #104] ; 0x68 <== NOT EXECUTED 30018a80: e5841078 str r1, [r4, #120] ; 0x78 <== NOT EXECUTED
ts->active = false;
/*
* The default timer server is now available.
*/
_Timer_server = ts;
30018a84: e59f1040 ldr r1, [pc, #64] ; 30018acc <rtems_timer_initiate_server+0x164><== NOT EXECUTED
ts->schedule_operation = _Timer_server_Schedule_operation_method;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
ts->insert_chain = NULL;
30018a88: e584007c str r0, [r4, #124] ; 0x7c <== NOT EXECUTED
ts->active = false;
30018a8c: e5c40080 strb r0, [r4, #128] ; 0x80 <== NOT EXECUTED
/*
* The default timer server is now available.
*/
_Timer_server = ts;
30018a90: e5812000 str r2, [r1] <== NOT EXECUTED
/*
* Start the timer server
*/
status = rtems_task_start(
30018a94: e1a00003 mov r0, r3 <== NOT EXECUTED 30018a98: e59f1030 ldr r1, [pc, #48] ; 30018ad0 <rtems_timer_initiate_server+0x168><== NOT EXECUTED
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
30018a9c: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED 30018aa0: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED 30018aa4: ebfffcd6 bl 30017e04 <rtems_task_start> <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
30018aa8: e8bd81fe pop {r1, r2, r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30018380 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
30018380: e92d4071 push {r0, r4, r5, r6, lr}
30018384: e1a01000 mov r1, r0
30018388: e1a0200d mov r2, sp
3001838c: e59f0078 ldr r0, [pc, #120] ; 3001840c <rtems_timer_reset+0x8c>
30018390: eb000a5c bl 3001ad08 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018394: e59d5000 ldr r5, [sp] 30018398: e1a06000 mov r6, r0 3001839c: e3550000 cmp r5, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300183a0: 13a04004 movne r4, #4
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
300183a4: 1a000016 bne 30018404 <rtems_timer_reset+0x84>
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
300183a8: e5904038 ldr r4, [r0, #56] ; 0x38 300183ac: e3540000 cmp r4, #0
300183b0: 1a000006 bne 300183d0 <rtems_timer_reset+0x50>
_Watchdog_Remove( &the_timer->Ticker );
300183b4: e2806010 add r6, r0, #16 300183b8: e1a00006 mov r0, r6 300183bc: eb0011af bl 3001ca80 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
300183c0: e59f0048 ldr r0, [pc, #72] ; 30018410 <rtems_timer_reset+0x90> 300183c4: e1a01006 mov r1, r6 300183c8: eb001154 bl 3001c920 <_Watchdog_Insert> 300183cc: ea00000b b 30018400 <rtems_timer_reset+0x80>
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
300183d0: e3540001 cmp r4, #1 <== NOT EXECUTED
/*
* Must be dormant or time of day timer (e.g. TIMER_DORMANT,
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
300183d4: 13a0400b movne r4, #11 <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
300183d8: 1a000008 bne 30018400 <rtems_timer_reset+0x80> <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
300183dc: e59f3030 ldr r3, [pc, #48] ; 30018414 <rtems_timer_reset+0x94><== NOT EXECUTED
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
300183e0: e2800010 add r0, r0, #16 <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
Timer_server_Control *timer_server = _Timer_server;
300183e4: e5934000 ldr r4, [r3] <== NOT EXECUTED
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
300183e8: eb0011a4 bl 3001ca80 <_Watchdog_Remove> <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
300183ec: e1a00004 mov r0, r4 <== NOT EXECUTED 300183f0: e1a01006 mov r1, r6 <== NOT EXECUTED 300183f4: e1a0e00f mov lr, pc <== NOT EXECUTED 300183f8: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
300183fc: e1a04005 mov r4, r5 <== NOT EXECUTED
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
}
_Thread_Enable_dispatch();
30018400: eb000d5a bl 3001b970 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018404: e1a00004 mov r0, r4
30018408: e8bd8078 pop {r3, r4, r5, r6, pc}
30018418 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018418: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3001841c: e1a08003 mov r8, r3 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
30018420: e59f30b8 ldr r3, [pc, #184] ; 300184e0 <rtems_timer_server_fire_after+0xc8><== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018424: e1a05000 mov r5, r0 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
30018428: e5937000 ldr r7, [r3] <== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001842c: e1a04001 mov r4, r1 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
30018430: e3570000 cmp r7, #0 <== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018434: e1a06002 mov r6, r2 <== NOT EXECUTED
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
30018438: 03a0000e moveq r0, #14 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
3001843c: 0a000026 beq 300184dc <rtems_timer_server_fire_after+0xc4> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !routine )
30018440: e3520000 cmp r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30018444: 03a00009 moveq r0, #9 <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !routine )
30018448: 0a000023 beq 300184dc <rtems_timer_server_fire_after+0xc4> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
3001844c: e3510000 cmp r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
30018450: 03a0000a moveq r0, #10 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
30018454: 0a000020 beq 300184dc <rtems_timer_server_fire_after+0xc4> <== NOT EXECUTED 30018458: e59f0084 ldr r0, [pc, #132] ; 300184e4 <rtems_timer_server_fire_after+0xcc><== NOT EXECUTED 3001845c: e1a01005 mov r1, r5 <== NOT EXECUTED 30018460: e1a0200d mov r2, sp <== NOT EXECUTED 30018464: eb000a27 bl 3001ad08 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018468: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3001846c: e1a0a000 mov sl, r0 <== NOT EXECUTED 30018470: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018474: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018478: 1a000017 bne 300184dc <rtems_timer_server_fire_after+0xc4> <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001847c: e28a0010 add r0, sl, #16 <== NOT EXECUTED 30018480: eb00117e bl 3001ca80 <_Watchdog_Remove> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30018484: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30018488: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3001848c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
30018490: e59a2018 ldr r2, [sl, #24] <== NOT EXECUTED 30018494: e3520000 cmp r2, #0 <== NOT EXECUTED 30018498: 0a000001 beq 300184a4 <rtems_timer_server_fire_after+0x8c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001849c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 300184a0: ea00000b b 300184d4 <rtems_timer_server_fire_after+0xbc> <== NOT EXECUTED
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL_ON_TASK;
300184a4: e3a01001 mov r1, #1 <== NOT EXECUTED 300184a8: e58a1038 str r1, [sl, #56] ; 0x38 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
300184ac: e58a2018 str r2, [sl, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
300184b0: e58a602c str r6, [sl, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
300184b4: e58a5030 str r5, [sl, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
300184b8: e58a8034 str r8, [sl, #52] ; 0x34 <== NOT EXECUTED
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
300184bc: e58a401c str r4, [sl, #28] <== NOT EXECUTED 300184c0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
(*timer_server->schedule_operation)( timer_server, the_timer );
300184c4: e1a00007 mov r0, r7 <== NOT EXECUTED 300184c8: e1a0100a mov r1, sl <== NOT EXECUTED 300184cc: e1a0e00f mov lr, pc <== NOT EXECUTED 300184d0: e597f004 ldr pc, [r7, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
300184d4: eb000d25 bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300184d8: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300184dc: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
300184e8 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
300184e8: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
300184ec: e1a0a003 mov sl, r3 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
300184f0: e59f30d8 ldr r3, [pc, #216] ; 300185d0 <rtems_timer_server_fire_when+0xe8><== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
300184f4: e1a04000 mov r4, r0 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
300184f8: e5936000 ldr r6, [r3] <== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
300184fc: e1a07001 mov r7, r1 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
30018500: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018504: e1a05002 mov r5, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
30018508: 03a0000e moveq r0, #14 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
3001850c: 0a00002e beq 300185cc <rtems_timer_server_fire_when+0xe4> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
30018510: e59f30bc ldr r3, [pc, #188] ; 300185d4 <rtems_timer_server_fire_when+0xec><== NOT EXECUTED 30018514: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 30018518: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
3001851c: 03a0000b moveq r0, #11 <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
30018520: 0a000029 beq 300185cc <rtems_timer_server_fire_when+0xe4> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
if ( !routine )
30018524: e3520000 cmp r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30018528: 03a00009 moveq r0, #9 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
3001852c: 0a000026 beq 300185cc <rtems_timer_server_fire_when+0xe4> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
30018530: e1a00001 mov r0, r1 <== NOT EXECUTED 30018534: ebfff488 bl 3001575c <_TOD_Validate> <== NOT EXECUTED 30018538: e3500000 cmp r0, #0 <== NOT EXECUTED 3001853c: 0a000021 beq 300185c8 <rtems_timer_server_fire_when+0xe0> <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
30018540: e1a00007 mov r0, r7 <== NOT EXECUTED 30018544: ebfff461 bl 300156d0 <_TOD_To_seconds> <== NOT EXECUTED
if ( seconds <= _TOD_Seconds_since_epoch() )
30018548: e59f8088 ldr r8, [pc, #136] ; 300185d8 <rtems_timer_server_fire_when+0xf0><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
3001854c: e1a07000 mov r7, r0 <== NOT EXECUTED
if ( seconds <= _TOD_Seconds_since_epoch() )
30018550: e5983000 ldr r3, [r8] <== NOT EXECUTED 30018554: e1500003 cmp r0, r3 <== NOT EXECUTED 30018558: 9a00001a bls 300185c8 <rtems_timer_server_fire_when+0xe0> <== NOT EXECUTED 3001855c: e59f0078 ldr r0, [pc, #120] ; 300185dc <rtems_timer_server_fire_when+0xf4><== NOT EXECUTED 30018560: e1a01004 mov r1, r4 <== NOT EXECUTED 30018564: e1a0200d mov r2, sp <== NOT EXECUTED 30018568: eb0009e6 bl 3001ad08 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001856c: e59d9000 ldr r9, [sp] <== NOT EXECUTED 30018570: e1a0b000 mov fp, r0 <== NOT EXECUTED 30018574: e3590000 cmp r9, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018578: 13a00004 movne r0, #4 <== NOT EXECUTED
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001857c: 1a000012 bne 300185cc <rtems_timer_server_fire_when+0xe4> <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
30018580: e28b0010 add r0, fp, #16 <== NOT EXECUTED 30018584: eb00113d bl 3001ca80 <_Watchdog_Remove> <== NOT EXECUTED
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
30018588: e3a03003 mov r3, #3 <== NOT EXECUTED 3001858c: e58b3038 str r3, [fp, #56] ; 0x38 <== NOT EXECUTED
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
30018590: e5983000 ldr r3, [r8] <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
30018594: e1a00006 mov r0, r6 <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
30018598: e0637007 rsb r7, r3, r7 <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
3001859c: e1a0100b mov r1, fp <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
300185a0: e58b9018 str r9, [fp, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
300185a4: e58b502c str r5, [fp, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
300185a8: e58b4030 str r4, [fp, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
300185ac: e58ba034 str sl, [fp, #52] ; 0x34 <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
300185b0: e58b701c str r7, [fp, #28] <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
300185b4: e1a0e00f mov lr, pc <== NOT EXECUTED 300185b8: e596f004 ldr pc, [r6, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
300185bc: eb000ceb bl 3001b970 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300185c0: e1a00009 mov r0, r9 <== NOT EXECUTED 300185c4: ea000000 b 300185cc <rtems_timer_server_fire_when+0xe4> <== NOT EXECUTED
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
300185c8: e3a00014 mov r0, #20 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300185cc: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000a7d8 <rtems_verror>:
{
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
3000a7d8: e3100202 tst r0, #536870912 ; 0x20000000 <== NOT EXECUTED
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
3000a7dc: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000a7e0: e1a05000 mov r5, r0 <== NOT EXECUTED
3000a7e4: e1a08001 mov r8, r1 <== NOT EXECUTED
3000a7e8: e1a04002 mov r4, r2 <== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
3000a7ec: 0a00000e beq 3000a82c <rtems_verror+0x54> <== NOT EXECUTED
if (rtems_panic_in_progress++)
3000a7f0: e59f212c ldr r2, [pc, #300] ; 3000a924 <rtems_verror+0x14c><== NOT EXECUTED 3000a7f4: e5923000 ldr r3, [r2] <== NOT EXECUTED 3000a7f8: e2831001 add r1, r3, #1 <== NOT EXECUTED 3000a7fc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a800: e5821000 str r1, [r2] <== NOT EXECUTED 3000a804: 0a000003 beq 3000a818 <rtems_verror+0x40> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000a808: e59f3118 ldr r3, [pc, #280] ; 3000a928 <rtems_verror+0x150><== NOT EXECUTED 3000a80c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000a810: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000a814: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
3000a818: e59f3104 ldr r3, [pc, #260] ; 3000a924 <rtems_verror+0x14c><== NOT EXECUTED 3000a81c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a820: e3530002 cmp r3, #2 <== NOT EXECUTED
return 0;
3000a824: c3a04000 movgt r4, #0 <== NOT EXECUTED
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)
3000a828: ca00003b bgt 3000a91c <rtems_verror+0x144> <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
3000a82c: e59f30f8 ldr r3, [pc, #248] ; 3000a92c <rtems_verror+0x154><== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
3000a830: e3c56207 bic r6, r5, #1879048192 ; 0x70000000 <== NOT EXECUTED
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
3000a834: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a838: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 3000a83c: eb002bc3 bl 30015750 <fflush> <== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
3000a840: e2155101 ands r5, r5, #1073741824 ; 0x40000000 <== NOT EXECUTED 3000a844: 0a000001 beq 3000a850 <rtems_verror+0x78> <== NOT EXECUTED
local_errno = errno;
3000a848: eb002ac9 bl 30015374 <__errno> <== NOT EXECUTED 3000a84c: e5905000 ldr r5, [r0] <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
3000a850: e59f70d4 ldr r7, [pc, #212] ; 3000a92c <rtems_verror+0x154><== NOT EXECUTED 3000a854: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a858: e5973000 ldr r3, [r7] <== NOT EXECUTED 3000a85c: e1a01008 mov r1, r8 <== NOT EXECUTED 3000a860: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000a864: eb0046f6 bl 3001c444 <vfprintf> <== NOT EXECUTED
if (status)
3000a868: e3560000 cmp r6, #0 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
3000a86c: e1a04000 mov r4, r0 <== NOT EXECUTED
if (status)
3000a870: 0a000008 beq 3000a898 <rtems_verror+0xc0> <== NOT EXECUTED
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
3000a874: e5973000 ldr r3, [r7] <== NOT EXECUTED 3000a878: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a87c: e593700c ldr r7, [r3, #12] <== NOT EXECUTED 3000a880: ebffffd0 bl 3000a7c8 <rtems_status_text> <== NOT EXECUTED 3000a884: e59f10a4 ldr r1, [pc, #164] ; 3000a930 <rtems_verror+0x158><== NOT EXECUTED 3000a888: e1a02000 mov r2, r0 <== NOT EXECUTED 3000a88c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a890: eb002c94 bl 30015ae8 <fprintf> <== NOT EXECUTED
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
3000a894: e0844000 add r4, r4, r0 <== NOT EXECUTED
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
3000a898: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a89c: 0a000015 beq 3000a8f8 <rtems_verror+0x120> <== NOT EXECUTED
if ((local_errno > 0) && *strerror(local_errno))
3000a8a0: da00000d ble 3000a8dc <rtems_verror+0x104> <== NOT EXECUTED 3000a8a4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a8a8: eb002f91 bl 300166f4 <strerror> <== NOT EXECUTED 3000a8ac: e5d03000 ldrb r3, [r0] <== NOT EXECUTED 3000a8b0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a8b4: 0a000008 beq 3000a8dc <rtems_verror+0x104> <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
3000a8b8: e59f306c ldr r3, [pc, #108] ; 3000a92c <rtems_verror+0x154><== NOT EXECUTED 3000a8bc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a8c0: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a8c4: e593600c ldr r6, [r3, #12] <== NOT EXECUTED 3000a8c8: eb002f89 bl 300166f4 <strerror> <== NOT EXECUTED 3000a8cc: e59f1060 ldr r1, [pc, #96] ; 3000a934 <rtems_verror+0x15c> <== NOT EXECUTED 3000a8d0: e1a02000 mov r2, r0 <== NOT EXECUTED 3000a8d4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a8d8: ea000004 b 3000a8f0 <rtems_verror+0x118> <== NOT EXECUTED
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
3000a8dc: e59f3048 ldr r3, [pc, #72] ; 3000a92c <rtems_verror+0x154> <== NOT EXECUTED 3000a8e0: e59f1050 ldr r1, [pc, #80] ; 3000a938 <rtems_verror+0x160> <== NOT EXECUTED 3000a8e4: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a8e8: e1a02005 mov r2, r5 <== NOT EXECUTED 3000a8ec: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000a8f0: eb002c7c bl 30015ae8 <fprintf> <== NOT EXECUTED 3000a8f4: e0844000 add r4, r4, r0 <== NOT EXECUTED
}
chars_written += fprintf(stderr, "\n");
3000a8f8: e59f502c ldr r5, [pc, #44] ; 3000a92c <rtems_verror+0x154> <== NOT EXECUTED 3000a8fc: e59f1038 ldr r1, [pc, #56] ; 3000a93c <rtems_verror+0x164> <== NOT EXECUTED 3000a900: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000a904: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000a908: eb002c76 bl 30015ae8 <fprintf> <== NOT EXECUTED
(void) fflush(stderr);
3000a90c: e5953000 ldr r3, [r5] <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
3000a910: e0804004 add r4, r0, r4 <== NOT EXECUTED
(void) fflush(stderr);
3000a914: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000a918: eb002b8c bl 30015750 <fflush> <== NOT EXECUTED
return chars_written;
}
3000a91c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000a920: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300069a0 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
300069a0: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0;
300069a4: e3a04000 mov r4, #0 <== NOT EXECUTED
int d;
for (;;) {
c = getc(fp);
300069a8: e59fb0d8 ldr fp, [pc, #216] ; 30006a88 <scanInt+0xe8> <== NOT EXECUTED
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
300069ac: e59f90d8 ldr r9, [pc, #216] ; 30006a8c <scanInt+0xec> <== NOT EXECUTED
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
300069b0: e1a05000 mov r5, r0 <== NOT EXECUTED 300069b4: e58d1000 str r1, [sp] <== NOT EXECUTED
int c; unsigned int i = 0; unsigned int limit = INT_MAX;
300069b8: e3e08102 mvn r8, #-2147483648 ; 0x80000000 <== NOT EXECUTED
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
300069bc: e1a07004 mov r7, r4 <== NOT EXECUTED
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
300069c0: e3a0a00a mov sl, #10 <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
300069c4: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 300069c8: e2433001 sub r3, r3, #1 <== NOT EXECUTED 300069cc: e3530000 cmp r3, #0 <== NOT EXECUTED 300069d0: e5853004 str r3, [r5, #4] <== NOT EXECUTED 300069d4: a5953000 ldrge r3, [r5] <== NOT EXECUTED 300069d8: a4d36001 ldrbge r6, [r3], #1 <== NOT EXECUTED 300069dc: a5853000 strge r3, [r5] <== NOT EXECUTED 300069e0: aa000003 bge 300069f4 <scanInt+0x54> <== NOT EXECUTED 300069e4: e59b0000 ldr r0, [fp] <== NOT EXECUTED 300069e8: e1a01005 mov r1, r5 <== NOT EXECUTED 300069ec: eb0030f8 bl 30012dd4 <__srget_r> <== NOT EXECUTED 300069f0: e1a06000 mov r6, r0 <== NOT EXECUTED
if (c == ':')
300069f4: e356003a cmp r6, #58 ; 0x3a <== NOT EXECUTED 300069f8: 0a000019 beq 30006a64 <scanInt+0xc4> <== NOT EXECUTED
break;
if (sign == 0) {
300069fc: e3540000 cmp r4, #0 <== NOT EXECUTED 30006a00: 1a000004 bne 30006a18 <scanInt+0x78> <== NOT EXECUTED
if (c == '-') {
30006a04: e356002d cmp r6, #45 ; 0x2d <== NOT EXECUTED
sign = -1;
limit++;
30006a08: 02888001 addeq r8, r8, #1 <== NOT EXECUTED
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
30006a0c: 03e04000 mvneq r4, #0 <== NOT EXECUTED
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
30006a10: 0affffeb beq 300069c4 <scanInt+0x24> <== NOT EXECUTED
sign = -1;
limit++;
continue;
}
sign = 1;
30006a14: e3a04001 mov r4, #1 <== NOT EXECUTED
}
if (!isdigit(c))
30006a18: e5993000 ldr r3, [r9] <== NOT EXECUTED 30006a1c: e0833006 add r3, r3, r6 <== NOT EXECUTED 30006a20: e5d30001 ldrb r0, [r3, #1] <== NOT EXECUTED 30006a24: e2100004 ands r0, r0, #4 <== NOT EXECUTED 30006a28: 0a000015 beq 30006a84 <scanInt+0xe4> <== NOT EXECUTED
return 0;
d = c - '0';
if ((i > (limit / 10))
30006a2c: e1a00008 mov r0, r8 <== NOT EXECUTED 30006a30: e3a0100a mov r1, #10 <== NOT EXECUTED 30006a34: eb003a15 bl 30015290 <__aeabi_uidiv> <== NOT EXECUTED 30006a38: e1570000 cmp r7, r0 <== NOT EXECUTED 30006a3c: 8a00000f bhi 30006a80 <scanInt+0xe0> <== NOT EXECUTED
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
30006a40: e2466030 sub r6, r6, #48 ; 0x30 <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
30006a44: 1a000004 bne 30006a5c <scanInt+0xbc> <== NOT EXECUTED 30006a48: e1a00008 mov r0, r8 <== NOT EXECUTED 30006a4c: e3a0100a mov r1, #10 <== NOT EXECUTED 30006a50: eb003aa6 bl 300154f0 <__umodsi3> <== NOT EXECUTED 30006a54: e1560000 cmp r6, r0 <== NOT EXECUTED 30006a58: 8a000008 bhi 30006a80 <scanInt+0xe0> <== NOT EXECUTED
return 0;
i = i * 10 + d;
30006a5c: e027679a mla r7, sl, r7, r6 <== NOT EXECUTED 30006a60: eaffffd7 b 300069c4 <scanInt+0x24> <== NOT EXECUTED
} if (sign == 0)
30006a64: e3540000 cmp r4, #0 <== NOT EXECUTED
return 0;
30006a68: 01a00004 moveq r0, r4 <== NOT EXECUTED
*val = i * sign;
30006a6c: 10040497 mulne r4, r7, r4 <== NOT EXECUTED 30006a70: 159d3000 ldrne r3, [sp] <== NOT EXECUTED
return 1;
30006a74: 13a00001 movne r0, #1 <== NOT EXECUTED
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
30006a78: 15834000 strne r4, [r3] <== NOT EXECUTED
return 1;
30006a7c: ea000000 b 30006a84 <scanInt+0xe4> <== NOT EXECUTED
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
30006a80: e3a00000 mov r0, #0 <== NOT EXECUTED
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
30006a84: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30006a90 <scanString>:
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
30006a90: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006a94: e1a06003 mov r6, r3 <== NOT EXECUTED
int c;
*name = *bufp;
30006a98: e5923000 ldr r3, [r2] <== NOT EXECUTED
for (;;) {
c = getc(fp);
30006a9c: e59f80d8 ldr r8, [pc, #216] ; 30006b7c <scanString+0xec> <== NOT EXECUTED
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
30006aa0: e59d7018 ldr r7, [sp, #24] <== NOT EXECUTED 30006aa4: e1a04000 mov r4, r0 <== NOT EXECUTED 30006aa8: e1a05002 mov r5, r2 <== NOT EXECUTED
int c;
*name = *bufp;
30006aac: e5813000 str r3, [r1] <== NOT EXECUTED
for (;;) {
c = getc(fp);
30006ab0: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30006ab4: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30006ab8: e3530000 cmp r3, #0 <== NOT EXECUTED 30006abc: e5843004 str r3, [r4, #4] <== NOT EXECUTED 30006ac0: a5943000 ldrge r3, [r4] <== NOT EXECUTED 30006ac4: a4d30001 ldrbge r0, [r3], #1 <== NOT EXECUTED 30006ac8: a5843000 strge r3, [r4] <== NOT EXECUTED 30006acc: b5980000 ldrlt r0, [r8] <== NOT EXECUTED 30006ad0: b1a01004 movlt r1, r4 <== NOT EXECUTED 30006ad4: bb0030be bllt 30012dd4 <__srget_r> <== NOT EXECUTED
if (c == ':') {
30006ad8: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED 30006adc: 1a000002 bne 30006aec <scanString+0x5c> <== NOT EXECUTED
if (nlFlag)
30006ae0: e3570000 cmp r7, #0 <== NOT EXECUTED 30006ae4: 0a000013 beq 30006b38 <scanString+0xa8> <== NOT EXECUTED 30006ae8: ea00001f b 30006b6c <scanString+0xdc> <== NOT EXECUTED
return 0;
break;
}
if (c == '\n') {
30006aec: e350000a cmp r0, #10 <== NOT EXECUTED 30006af0: 1a000002 bne 30006b00 <scanString+0x70> <== NOT EXECUTED
if (!nlFlag)
30006af4: e3570000 cmp r7, #0 <== NOT EXECUTED 30006af8: 1a00000e bne 30006b38 <scanString+0xa8> <== NOT EXECUTED 30006afc: ea000018 b 30006b64 <scanString+0xd4> <== NOT EXECUTED
return 0;
break;
}
if (c == EOF)
30006b00: e3700001 cmn r0, #1 <== NOT EXECUTED 30006b04: 0a000018 beq 30006b6c <scanString+0xdc> <== NOT EXECUTED
return 0;
if (*nleft < 2)
30006b08: e5963000 ldr r3, [r6] <== NOT EXECUTED 30006b0c: e3530001 cmp r3, #1 <== NOT EXECUTED 30006b10: 9a000017 bls 30006b74 <scanString+0xe4> <== NOT EXECUTED
return 0;
**bufp = c;
30006b14: e5953000 ldr r3, [r5] <== NOT EXECUTED 30006b18: e5c30000 strb r0, [r3] <== NOT EXECUTED
++(*bufp);
30006b1c: e5953000 ldr r3, [r5] <== NOT EXECUTED 30006b20: e2833001 add r3, r3, #1 <== NOT EXECUTED 30006b24: e5853000 str r3, [r5] <== NOT EXECUTED
--(*nleft);
30006b28: e5963000 ldr r3, [r6] <== NOT EXECUTED 30006b2c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30006b30: e5863000 str r3, [r6] <== NOT EXECUTED
}
30006b34: eaffffdd b 30006ab0 <scanString+0x20> <== NOT EXECUTED
**bufp = '\0';
30006b38: e5953000 ldr r3, [r5] <== NOT EXECUTED 30006b3c: e3a02000 mov r2, #0 <== NOT EXECUTED 30006b40: e5c32000 strb r2, [r3] <== NOT EXECUTED
++(*bufp);
30006b44: e5953000 ldr r3, [r5] <== NOT EXECUTED
--(*nleft); return 1;
30006b48: e3a00001 mov r0, #1 <== NOT EXECUTED
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
30006b4c: e2833001 add r3, r3, #1 <== NOT EXECUTED 30006b50: e5853000 str r3, [r5] <== NOT EXECUTED
--(*nleft);
30006b54: e5963000 ldr r3, [r6] <== NOT EXECUTED 30006b58: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30006b5c: e5863000 str r3, [r6] <== NOT EXECUTED
return 1;
30006b60: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
return 0;
30006b64: e1a00007 mov r0, r7 <== NOT EXECUTED
30006b68: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
break;
}
if (c == EOF)
return 0;
30006b6c: e3a00000 mov r0, #0 <== NOT EXECUTED
30006b70: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if (*nleft < 2)
return 0;
30006b74: e3a00000 mov r0, #0 <== NOT EXECUTED
} **bufp = '\0'; ++(*bufp); --(*nleft); return 1; }
30006b78: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30006b80 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
30006b80: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006b84: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30006b88: e28d6008 add r6, sp, #8 <== NOT EXECUTED 30006b8c: e28d5004 add r5, sp, #4 <== NOT EXECUTED
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
30006b90: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 30006b94: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30006b98: e3a08000 mov r8, #0 <== NOT EXECUTED 30006b9c: e1a02006 mov r2, r6 <== NOT EXECUTED 30006ba0: e1a03005 mov r3, r5 <== NOT EXECUTED
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
30006ba4: e1a07000 mov r7, r0 <== NOT EXECUTED 30006ba8: e1a04001 mov r4, r1 <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30006bac: e58d8000 str r8, [sp] <== NOT EXECUTED 30006bb0: ebffffb6 bl 30006a90 <scanString> <== NOT EXECUTED 30006bb4: e3500000 cmp r0, #0 <== NOT EXECUTED 30006bb8: 0a000037 beq 30006c9c <scangr+0x11c> <== NOT EXECUTED
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
30006bbc: e1a00007 mov r0, r7 <== NOT EXECUTED 30006bc0: e2841004 add r1, r4, #4 <== NOT EXECUTED 30006bc4: e1a02006 mov r2, r6 <== NOT EXECUTED 30006bc8: e1a03005 mov r3, r5 <== NOT EXECUTED 30006bcc: e58d8000 str r8, [sp] <== NOT EXECUTED 30006bd0: ebffffae bl 30006a90 <scanString> <== NOT EXECUTED 30006bd4: e3500000 cmp r0, #0 <== NOT EXECUTED 30006bd8: 0a00002f beq 30006c9c <scangr+0x11c> <== NOT EXECUTED
|| !scanInt(fp, &grgid)
30006bdc: e1a00007 mov r0, r7 <== NOT EXECUTED 30006be0: e28d1010 add r1, sp, #16 <== NOT EXECUTED 30006be4: ebffff6d bl 300069a0 <scanInt> <== NOT EXECUTED 30006be8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006bec: 0a00002a beq 30006c9c <scangr+0x11c> <== NOT EXECUTED
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
30006bf0: e2888001 add r8, r8, #1 <== NOT EXECUTED 30006bf4: e1a00007 mov r0, r7 <== NOT EXECUTED 30006bf8: e28d100c add r1, sp, #12 <== NOT EXECUTED 30006bfc: e1a02006 mov r2, r6 <== NOT EXECUTED 30006c00: e1a03005 mov r3, r5 <== NOT EXECUTED 30006c04: e58d8000 str r8, [sp] <== NOT EXECUTED 30006c08: ebffffa0 bl 30006a90 <scanString> <== NOT EXECUTED 30006c0c: e3500000 cmp r0, #0 <== NOT EXECUTED 30006c10: 0a000021 beq 30006c9c <scangr+0x11c> <== NOT EXECUTED
return 0;
grp->gr_gid = grgid;
30006c14: e1dd31b0 ldrh r3, [sp, #16] <== NOT EXECUTED
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006c18: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
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;
30006c1c: e1c430b8 strh r3, [r4, #8] <== NOT EXECUTED
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006c20: e1a03002 mov r3, r2 <== NOT EXECUTED 30006c24: ea000001 b 30006c30 <scangr+0xb0> <== NOT EXECUTED
if(*cp == ',')
30006c28: e350002c cmp r0, #44 ; 0x2c <== NOT EXECUTED
memcount++;
30006c2c: 02888001 addeq r8, r8, #1 <== NOT EXECUTED
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006c30: e4d30001 ldrb r0, [r3], #1 <== NOT EXECUTED 30006c34: e3500000 cmp r0, #0 <== NOT EXECUTED 30006c38: 1afffffa bne 30006c28 <scangr+0xa8> <== NOT EXECUTED
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
30006c3c: e1a08108 lsl r8, r8, #2 <== NOT EXECUTED 30006c40: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30006c44: e2888013 add r8, r8, #19 <== NOT EXECUTED 30006c48: e1530008 cmp r3, r8 <== NOT EXECUTED 30006c4c: 3a000012 bcc 30006c9c <scangr+0x11c> <== NOT EXECUTED
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
30006c50: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30006c54: e283300f add r3, r3, #15 <== NOT EXECUTED 30006c58: e3c3300f bic r3, r3, #15 <== NOT EXECUTED 30006c5c: e584300c str r3, [r4, #12] <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
30006c60: e5832000 str r2, [r3] <== NOT EXECUTED 30006c64: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006c68: e3a03001 mov r3, #1 <== NOT EXECUTED 30006c6c: ea000004 b 30006c84 <scangr+0x104> <== NOT EXECUTED
if(*cp == ',') {
30006c70: e351002c cmp r1, #44 ; 0x2c <== NOT EXECUTED
*cp = '\0';
30006c74: 05420001 strbeq r0, [r2, #-1] <== NOT EXECUTED
grp->gr_mem[memcount++] = cp + 1;
30006c78: 0594100c ldreq r1, [r4, #12] <== NOT EXECUTED 30006c7c: 07812103 streq r2, [r1, r3, lsl #2] <== NOT EXECUTED 30006c80: 02833001 addeq r3, r3, #1 <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006c84: e4d21001 ldrb r1, [r2], #1 <== NOT EXECUTED 30006c88: e3510000 cmp r1, #0 <== NOT EXECUTED 30006c8c: 1afffff7 bne 30006c70 <scangr+0xf0> <== NOT EXECUTED
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
30006c90: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
return 1;
30006c94: e3a00001 mov r0, #1 <== NOT EXECUTED
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
30006c98: e7821103 str r1, [r2, r3, lsl #2] <== NOT EXECUTED
return 1; }
30006c9c: e28dd014 add sp, sp, #20 <== NOT EXECUTED
30006ca0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30006ca4 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
30006ca4: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006ca8: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
30006cac: e28d7008 add r7, sp, #8 <== NOT EXECUTED 30006cb0: e28d6004 add r6, sp, #4 <== NOT EXECUTED
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
30006cb4: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 30006cb8: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
30006cbc: e3a08000 mov r8, #0 <== NOT EXECUTED 30006cc0: e1a02007 mov r2, r7 <== NOT EXECUTED 30006cc4: e1a03006 mov r3, r6 <== NOT EXECUTED
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
30006cc8: e1a05000 mov r5, r0 <== NOT EXECUTED 30006ccc: e1a04001 mov r4, r1 <== NOT EXECUTED
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
30006cd0: e58d8000 str r8, [sp] <== NOT EXECUTED 30006cd4: ebffff6d bl 30006a90 <scanString> <== NOT EXECUTED 30006cd8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006cdc: 0a000036 beq 30006dbc <scanpw+0x118> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
30006ce0: e1a00005 mov r0, r5 <== NOT EXECUTED 30006ce4: e2841004 add r1, r4, #4 <== NOT EXECUTED 30006ce8: e1a02007 mov r2, r7 <== NOT EXECUTED 30006cec: e1a03006 mov r3, r6 <== NOT EXECUTED 30006cf0: e58d8000 str r8, [sp] <== NOT EXECUTED 30006cf4: ebffff65 bl 30006a90 <scanString> <== NOT EXECUTED 30006cf8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006cfc: 0a00002e beq 30006dbc <scanpw+0x118> <== NOT EXECUTED
|| !scanInt(fp, &pwuid)
30006d00: e1a00005 mov r0, r5 <== NOT EXECUTED 30006d04: e28d1010 add r1, sp, #16 <== NOT EXECUTED 30006d08: ebffff24 bl 300069a0 <scanInt> <== NOT EXECUTED 30006d0c: e3500000 cmp r0, #0 <== NOT EXECUTED 30006d10: 0a000029 beq 30006dbc <scanpw+0x118> <== NOT EXECUTED
|| !scanInt(fp, &pwgid)
30006d14: e1a00005 mov r0, r5 <== NOT EXECUTED 30006d18: e28d100c add r1, sp, #12 <== NOT EXECUTED 30006d1c: ebffff1f bl 300069a0 <scanInt> <== NOT EXECUTED 30006d20: e3500000 cmp r0, #0 <== NOT EXECUTED 30006d24: 0a000024 beq 30006dbc <scanpw+0x118> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
30006d28: e1a00005 mov r0, r5 <== NOT EXECUTED 30006d2c: e284100c add r1, r4, #12 <== NOT EXECUTED 30006d30: e1a02007 mov r2, r7 <== NOT EXECUTED 30006d34: e1a03006 mov r3, r6 <== NOT EXECUTED 30006d38: e58d8000 str r8, [sp] <== NOT EXECUTED 30006d3c: ebffff53 bl 30006a90 <scanString> <== NOT EXECUTED 30006d40: e3500000 cmp r0, #0 <== NOT EXECUTED 30006d44: 0a00001c beq 30006dbc <scanpw+0x118> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
30006d48: e1a00005 mov r0, r5 <== NOT EXECUTED 30006d4c: e2841010 add r1, r4, #16 <== NOT EXECUTED 30006d50: e1a02007 mov r2, r7 <== NOT EXECUTED 30006d54: e1a03006 mov r3, r6 <== NOT EXECUTED 30006d58: e58d8000 str r8, [sp] <== NOT EXECUTED 30006d5c: ebffff4b bl 30006a90 <scanString> <== NOT EXECUTED 30006d60: e3500000 cmp r0, #0 <== NOT EXECUTED 30006d64: 0a000014 beq 30006dbc <scanpw+0x118> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
30006d68: e1a00005 mov r0, r5 <== NOT EXECUTED 30006d6c: e2841014 add r1, r4, #20 <== NOT EXECUTED 30006d70: e1a02007 mov r2, r7 <== NOT EXECUTED 30006d74: e1a03006 mov r3, r6 <== NOT EXECUTED 30006d78: e58d8000 str r8, [sp] <== NOT EXECUTED 30006d7c: ebffff43 bl 30006a90 <scanString> <== NOT EXECUTED 30006d80: e3500000 cmp r0, #0 <== NOT EXECUTED 30006d84: 0a00000c beq 30006dbc <scanpw+0x118> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
30006d88: e1a03006 mov r3, r6 <== NOT EXECUTED 30006d8c: e2888001 add r8, r8, #1 <== NOT EXECUTED 30006d90: e1a00005 mov r0, r5 <== NOT EXECUTED 30006d94: e2841018 add r1, r4, #24 <== NOT EXECUTED 30006d98: e1a02007 mov r2, r7 <== NOT EXECUTED 30006d9c: e58d8000 str r8, [sp] <== NOT EXECUTED 30006da0: ebffff3a bl 30006a90 <scanString> <== NOT EXECUTED 30006da4: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
pwd->pw_uid = pwuid;
30006da8: 11dd31b0 ldrhne r3, [sp, #16] <== NOT EXECUTED
pwd->pw_gid = pwgid; return 1;
30006dac: 11a00008 movne r0, r8 <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
30006db0: 11c430b8 strhne r3, [r4, #8] <== NOT EXECUTED
pwd->pw_gid = pwgid;
30006db4: 11dd30bc ldrhne r3, [sp, #12] <== NOT EXECUTED 30006db8: 11c430ba strhne r3, [r4, #10] <== NOT EXECUTED
return 1; }
30006dbc: e28dd014 add sp, sp, #20 <== NOT EXECUTED
30006dc0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30008e4c <seteuid>:
#include <rtems/userenv.h>
int seteuid( uid_t euid )
{
_POSIX_types_Euid = euid;
30008e4c: e59f300c ldr r3, [pc, #12] ; 30008e60 <seteuid+0x14> <== NOT EXECUTED 30008e50: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008e54: e1c303b6 strh r0, [r3, #54] ; 0x36 <== NOT EXECUTED
return 0; }
30008e58: e3a00000 mov r0, #0 <== NOT EXECUTED 30008e5c: e12fff1e bx lr <== NOT EXECUTED
30008004 <setgid>:
*/
int setgid(
gid_t gid
)
{
_POSIX_types_Gid = gid;
30008004: e59f300c ldr r3, [pc, #12] ; 30008018 <setgid+0x14> <== NOT EXECUTED 30008008: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000800c: e1c303b4 strh r0, [r3, #52] ; 0x34 <== NOT EXECUTED
return 0; }
30008010: e3a00000 mov r0, #0 <== NOT EXECUTED 30008014: e12fff1e bx lr <== NOT EXECUTED
30007280 <setgrent>:
void setgrent(void)
{
30007280: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
init_etc_passwd_group();
30007284: ebfffece bl 30006dc4 <init_etc_passwd_group> <== NOT EXECUTED
if (group_fp != NULL)
30007288: e59f3020 ldr r3, [pc, #32] ; 300072b0 <setgrent+0x30> <== NOT EXECUTED 3000728c: e59301c4 ldr r0, [r3, #452] ; 0x1c4 <== NOT EXECUTED 30007290: e3500000 cmp r0, #0 <== NOT EXECUTED
fclose(group_fp);
30007294: 1b0027fe blne 30011294 <fclose> <== NOT EXECUTED
group_fp = fopen("/etc/group", "r");
30007298: e59f0014 ldr r0, [pc, #20] ; 300072b4 <setgrent+0x34> <== NOT EXECUTED 3000729c: e59f1014 ldr r1, [pc, #20] ; 300072b8 <setgrent+0x38> <== NOT EXECUTED 300072a0: eb0029d2 bl 300119f0 <fopen> <== NOT EXECUTED 300072a4: e59f3004 ldr r3, [pc, #4] ; 300072b0 <setgrent+0x30> <== NOT EXECUTED 300072a8: e58301c4 str r0, [r3, #452] ; 0x1c4 <== NOT EXECUTED
}
300072ac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000801c <setpgid>:
int setpgid(
pid_t pid __attribute__((unused)),
pid_t pgid __attribute__((unused))
)
{
3000801c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30008020: eb00244d bl 3001115c <__errno> <== NOT EXECUTED 30008024: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30008028: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000802c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30008030: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007130 <setpwent>:
void setpwent(void)
{
30007130: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
init_etc_passwd_group();
30007134: ebffff22 bl 30006dc4 <init_etc_passwd_group> <== NOT EXECUTED
if (passwd_fp != NULL)
30007138: e59f3020 ldr r3, [pc, #32] ; 30007160 <setpwent+0x30> <== NOT EXECUTED 3000713c: e59300e8 ldr r0, [r3, #232] ; 0xe8 <== NOT EXECUTED 30007140: e3500000 cmp r0, #0 <== NOT EXECUTED
fclose(passwd_fp);
30007144: 1b002852 blne 30011294 <fclose> <== NOT EXECUTED
passwd_fp = fopen("/etc/passwd", "r");
30007148: e59f0014 ldr r0, [pc, #20] ; 30007164 <setpwent+0x34> <== NOT EXECUTED 3000714c: e59f1014 ldr r1, [pc, #20] ; 30007168 <setpwent+0x38> <== NOT EXECUTED 30007150: eb002a26 bl 300119f0 <fopen> <== NOT EXECUTED 30007154: e59f3004 ldr r3, [pc, #4] ; 30007160 <setpwent+0x30> <== NOT EXECUTED 30007158: e58300e8 str r0, [r3, #232] ; 0xe8 <== NOT EXECUTED
}
3000715c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30008034 <setsid>:
*
* 4.3.2 Create Session and Set Process Group ID, P1003.1b-1993, p. 88
*/
pid_t setsid( void )
{
30008034: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
30008038: eb002447 bl 3001115c <__errno> <== NOT EXECUTED 3000803c: e3a03001 mov r3, #1 <== NOT EXECUTED 30008040: e5803000 str r3, [r0] <== NOT EXECUTED
}
30008044: e3e00000 mvn r0, #0 <== NOT EXECUTED
30008048: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000804c <setuid>:
*/
int setuid(
uid_t uid
)
{
_POSIX_types_Uid = uid;
3000804c: e59f300c ldr r3, [pc, #12] ; 30008060 <setuid+0x14> <== NOT EXECUTED 30008050: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008054: e1c303b2 strh r0, [r3, #50] ; 0x32 <== NOT EXECUTED
return 0; }
30008058: e3a00000 mov r0, #0 <== NOT EXECUTED 3000805c: e12fff1e bx lr <== NOT EXECUTED
3000816c <siproc>:
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
3000816c: e591203c ldr r2, [r1, #60] ; 0x3c <== NOT EXECUTED 30008170: e59f304c ldr r3, [pc, #76] ; 300081c4 <siproc+0x58> <== NOT EXECUTED
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008174: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
30008178: e0023003 and r3, r2, r3 <== NOT EXECUTED 3000817c: e3530000 cmp r3, #0 <== NOT EXECUTED
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008180: e1a04001 mov r4, r1 <== NOT EXECUTED 30008184: e1a05000 mov r5, r0 <== NOT EXECUTED
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
30008188: 0a00000b beq 300081bc <siproc+0x50> <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3000818c: e5910018 ldr r0, [r1, #24] <== NOT EXECUTED 30008190: e3a01000 mov r1, #0 <== NOT EXECUTED 30008194: e1a02001 mov r2, r1 <== NOT EXECUTED 30008198: eb0004c0 bl 300094a0 <rtems_semaphore_obtain> <== NOT EXECUTED
i = iproc (c, tty);
3000819c: e1a01004 mov r1, r4 <== NOT EXECUTED 300081a0: e1a00005 mov r0, r5 <== NOT EXECUTED 300081a4: ebffff8b bl 30007fd8 <iproc> <== NOT EXECUTED 300081a8: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
300081ac: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED 300081b0: eb000500 bl 300095b8 <rtems_semaphore_release> <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
300081b4: e1a00005 mov r0, r5 <== NOT EXECUTED
300081b8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
300081bc: 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);
300081c0: eaffff84 b 30007fd8 <iproc> <== NOT EXECUTED
30007110 <stat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
30007110: e92d4070 push {r4, r5, r6, lr}
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
30007114: e2515000 subs r5, r1, #0
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
30007118: e24dd018 sub sp, sp, #24 3000711c: e1a06000 mov r6, r0
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
30007120: 1a000003 bne 30007134 <stat+0x24>
rtems_set_errno_and_return_minus_one( EFAULT );
30007124: eb001dac bl 3000e7dc <__errno> <== NOT EXECUTED 30007128: e3a0300e mov r3, #14 <== NOT EXECUTED 3000712c: e5803000 str r3, [r0] <== NOT EXECUTED 30007130: ea000016 b 30007190 <stat+0x80> <== NOT EXECUTED
status = rtems_filesystem_evaluate_path( path, strlen( path ),
30007134: eb002117 bl 3000f598 <strlen> 30007138: e28d4004 add r4, sp, #4 3000713c: e3a03001 mov r3, #1 30007140: e1a01000 mov r1, r0 30007144: e58d3000 str r3, [sp] 30007148: e1a00006 mov r0, r6 3000714c: e3a02000 mov r2, #0 30007150: e1a03004 mov r3, r4 30007154: ebfffc60 bl 300062dc <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
30007158: e2501000 subs r1, r0, #0
3000715c: 1a00000b bne 30007190 <stat+0x80>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
30007160: e3a02048 mov r2, #72 ; 0x48 30007164: e1a00005 mov r0, r5 30007168: eb002000 bl 3000f170 <memset>
status = (*loc.handlers->fstat_h)( &loc, buf );
3000716c: e1a01005 mov r1, r5 30007170: e1a00004 mov r0, r4 30007174: e59d300c ldr r3, [sp, #12] 30007178: e1a0e00f mov lr, pc 3000717c: e593f018 ldr pc, [r3, #24] 30007180: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
30007184: e1a00004 mov r0, r4 30007188: ebfffc83 bl 3000639c <rtems_filesystem_freenode>
return status;
3000718c: ea000000 b 30007194 <stat+0x84>
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
return -1;
30007190: e3e05000 mvn r5, #0
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
30007194: e1a00005 mov r0, r5
30007198: e28dd018 add sp, sp, #24
3000719c: e8bd8070 pop {r4, r5, r6, pc}
30009978 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
30009978: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000997c: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30009980: e1a05001 mov r5, r1 <== NOT EXECUTED
30009984: e1a06000 mov r6, r0 <== NOT EXECUTED
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
30009988: eb002d8a bl 30014fb8 <strlen> <== NOT EXECUTED 3000998c: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30009990: e3a03001 mov r3, #1 <== NOT EXECUTED 30009994: e1a01000 mov r1, r0 <== NOT EXECUTED 30009998: e58d3000 str r3, [sp] <== NOT EXECUTED 3000999c: e1a00006 mov r0, r6 <== NOT EXECUTED 300099a0: e3a02000 mov r2, #0 <== NOT EXECUTED 300099a4: e1a03004 mov r3, r4 <== NOT EXECUTED 300099a8: ebfffb0d bl 300085e4 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 300099ac: e2501000 subs r1, r0, #0 <== NOT EXECUTED
return -1;
300099b0: 13e05000 mvnne r5, #0 <== NOT EXECUTED
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
300099b4: 1a00000b bne 300099e8 <statvfs+0x70> <== NOT EXECUTED
return -1;
mt_entry = loc.mt_entry;
300099b8: e59d6014 ldr r6, [sp, #20] <== NOT EXECUTED
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
300099bc: e1a00005 mov r0, r5 <== NOT EXECUTED 300099c0: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 300099c4: eb002873 bl 30013b98 <memset> <== NOT EXECUTED
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
300099c8: e1a01005 mov r1, r5 <== NOT EXECUTED 300099cc: e5963028 ldr r3, [r6, #40] ; 0x28 <== NOT EXECUTED 300099d0: e286001c add r0, r6, #28 <== NOT EXECUTED 300099d4: e1a0e00f mov lr, pc <== NOT EXECUTED 300099d8: e593f044 ldr pc, [r3, #68] ; 0x44 <== NOT EXECUTED 300099dc: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
300099e0: e1a00004 mov r0, r4 <== NOT EXECUTED 300099e4: ebfffb2e bl 300086a4 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
300099e8: e1a00005 mov r0, r5 <== NOT EXECUTED
300099ec: e28dd018 add sp, sp, #24 <== NOT EXECUTED
300099f0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300082e0 <sync>:
{
/*
* Walk the one used initially by RTEMS.
*/
_fwalk(_global_impure_ptr, sync_wrapper);
300082e0: e59f3018 ldr r3, [pc, #24] ; 30008300 <sync+0x20> <== NOT EXECUTED
* We have to extern it here.
*/
extern struct _reent * const _global_impure_ptr __ATTRIBUTE_IMPURE_PTR__;
void sync(void)
{
300082e4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
/*
* Walk the one used initially by RTEMS.
*/
_fwalk(_global_impure_ptr, sync_wrapper);
300082e8: e5930000 ldr r0, [r3] <== NOT EXECUTED 300082ec: e59f1010 ldr r1, [pc, #16] ; 30008304 <sync+0x24> <== NOT EXECUTED 300082f0: eb00279b bl 30012164 <_fwalk> <== NOT EXECUTED
*/
/*
* Now walk all the per-thread reentrancy structures.
*/
rtems_iterate_over_all_threads(sync_per_thread);
300082f4: e59f000c ldr r0, [pc, #12] ; 30008308 <sync+0x28> <== NOT EXECUTED
}
300082f8: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
*/
/*
* Now walk all the per-thread reentrancy structures.
*/
rtems_iterate_over_all_threads(sync_per_thread);
300082fc: ea000da0 b 3000b984 <rtems_iterate_over_all_threads> <== NOT EXECUTED
30008284 <sync_per_thread>:
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
30008284: e59030f0 ldr r3, [r0, #240] ; 0xf0 <== NOT EXECUTED
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
30008288: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
if ( this_reent ) {
3000828c: e3530000 cmp r3, #0 <== NOT EXECUTED
30008290: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
current_reent = _Thread_Executing->libc_reent;
30008294: e59f4020 ldr r4, [pc, #32] ; 300082bc <sync_per_thread+0x38><== NOT EXECUTED
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
30008298: e59f1020 ldr r1, [pc, #32] ; 300082c0 <sync_per_thread+0x3c><== NOT EXECUTED
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
if ( this_reent ) {
current_reent = _Thread_Executing->libc_reent;
3000829c: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 300082a0: e59250f0 ldr r5, [r2, #240] ; 0xf0 <== NOT EXECUTED
_Thread_Executing->libc_reent = this_reent;
300082a4: e58230f0 str r3, [r2, #240] ; 0xf0 <== NOT EXECUTED
_fwalk (t->libc_reent, sync_wrapper);
300082a8: e59000f0 ldr r0, [r0, #240] ; 0xf0 <== NOT EXECUTED 300082ac: eb0027ac bl 30012164 <_fwalk> <== NOT EXECUTED
_Thread_Executing->libc_reent = current_reent;
300082b0: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
300082b4: e58350f0 str r5, [r3, #240] ; 0xf0 <== NOT EXECUTED
300082b8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
300082c4 <sync_wrapper>:
/* XXX check standards -- Linux version appears to be void */
void _fwalk(struct _reent *, void *);
static void sync_wrapper(FILE *f)
{
300082c4: e92d4010 push {r4, lr} <== NOT EXECUTED
int fn = fileno(f);
300082c8: eb0024c1 bl 300115d4 <fileno> <== NOT EXECUTED 300082cc: e1a04000 mov r4, r0 <== NOT EXECUTED
/* * We are explicitly NOT checking the return values as it does not * matter if they succeed. We are just making a best faith attempt * at both and trusting that we were passed a good FILE pointer. */ fsync(fn);
300082d0: ebfffb5c bl 30007048 <fsync> <== NOT EXECUTED
fdatasync(fn);
300082d4: e1a00004 mov r0, r4 <== NOT EXECUTED
}
300082d8: e8bd4010 pop {r4, lr} <== NOT EXECUTED
* We are explicitly NOT checking the return values as it does not * matter if they succeed. We are just making a best faith attempt * at both and trusting that we were passed a good FILE pointer. */ fsync(fn); fdatasync(fn);
300082dc: eafffaa5 b 30006d78 <fdatasync> <== NOT EXECUTED
3000ee18 <tcgetattr>:
int tcgetattr(
int fd,
struct termios *tp
)
{
3000ee18: e1a02001 mov r2, r1 <== NOT EXECUTED
return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp );
3000ee1c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000ee20: eaffff30 b 3000eae8 <ioctl> <== NOT EXECUTED
3000ee24 <tcsetattr>:
int fd,
int opt,
struct termios *tp
)
{
switch (opt) {
3000ee24: e3510000 cmp r1, #0 <== NOT EXECUTED
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
3000ee28: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000ee2c: e1a05000 mov r5, r0 <== NOT EXECUTED
3000ee30: e1a04002 mov r4, r2 <== NOT EXECUTED
switch (opt) {
3000ee34: 0a00000a beq 3000ee64 <tcsetattr+0x40> <== NOT EXECUTED 3000ee38: e3510001 cmp r1, #1 <== NOT EXECUTED 3000ee3c: 0a000003 beq 3000ee50 <tcsetattr+0x2c> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000ee40: eb000b19 bl 30011aac <__errno> <== NOT EXECUTED 3000ee44: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 3000ee48: e5803000 str r3, [r0] <== NOT EXECUTED 3000ee4c: ea000009 b 3000ee78 <tcsetattr+0x54> <== NOT EXECUTED
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
3000ee50: e3a01003 mov r1, #3 <== NOT EXECUTED 3000ee54: e3a02000 mov r2, #0 <== NOT EXECUTED 3000ee58: ebffff22 bl 3000eae8 <ioctl> <== NOT EXECUTED 3000ee5c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ee60: ba000004 blt 3000ee78 <tcsetattr+0x54> <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
3000ee64: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ee68: e3a01002 mov r1, #2 <== NOT EXECUTED 3000ee6c: e1a02004 mov r2, r4 <== NOT EXECUTED
} }
3000ee70: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
3000ee74: eaffff1b b 3000eae8 <ioctl> <== NOT EXECUTED
} }
3000ee78: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000ee7c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30008e94 <times>:
clock_t times(
struct tms *ptms
)
{
return _times( ptms );
30008e94: eaffffd6 b 30008df4 <_times> <== NOT EXECUTED
3000c56c <truncate>:
int truncate(
const char *path,
off_t length
)
{
3000c56c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000c570: e1a05001 mov r5, r1 <== NOT EXECUTED
int status;
int fd;
fd = open( path, O_WRONLY );
3000c574: e3a01001 mov r1, #1 <== NOT EXECUTED
int truncate(
const char *path,
off_t length
)
{
3000c578: e1a06002 mov r6, r2 <== NOT EXECUTED
int status;
int fd;
fd = open( path, O_WRONLY );
3000c57c: ebfff77b bl 3000a370 <open> <== NOT EXECUTED
if ( fd == -1 )
3000c580: e3700001 cmn r0, #1 <== NOT EXECUTED
)
{
int status;
int fd;
fd = open( path, O_WRONLY );
3000c584: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( fd == -1 )
return -1;
3000c588: 01a05000 moveq r5, r0 <== NOT EXECUTED
{
int status;
int fd;
fd = open( path, O_WRONLY );
if ( fd == -1 )
3000c58c: 0a000005 beq 3000c5a8 <truncate+0x3c> <== NOT EXECUTED
return -1;
status = ftruncate( fd, length );
3000c590: e1a01005 mov r1, r5 <== NOT EXECUTED 3000c594: e1a02006 mov r2, r6 <== NOT EXECUTED 3000c598: eb0014b6 bl 30011878 <ftruncate> <== NOT EXECUTED 3000c59c: e1a05000 mov r5, r0 <== NOT EXECUTED
(void) close( fd );
3000c5a0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c5a4: ebfff2a2 bl 30009034 <close> <== NOT EXECUTED
return status;
}
3000c5a8: e1a00005 mov r0, r5 <== NOT EXECUTED
3000c5ac: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30009d98 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
30009d98: e92d40f0 push {r4, r5, r6, r7, lr}
30009d9c: e24dd030 sub sp, sp, #48 ; 0x30
30009da0: e1a06000 mov r6, r0
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
30009da4: ebfff55c bl 3000731c <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
30009da8: e2504000 subs r4, r0, #0 30009dac: e28d3018 add r3, sp, #24
30009db0: 1a000005 bne 30009dcc <unlink+0x34>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
30009db4: e1a00006 mov r0, r6 30009db8: e28d102c add r1, sp, #44 ; 0x2c 30009dbc: e1a02003 mov r2, r3 30009dc0: ebfff92f bl 30008284 <rtems_filesystem_get_start_loc>
const char *name; rtems_filesystem_location_info_t parentloc; rtems_filesystem_location_info_t loc; int i; int result; bool free_parentloc = false;
30009dc4: e1a05004 mov r5, r4 30009dc8: ea000008 b 30009df0 <unlink+0x58>
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
30009dcc: e3a02000 mov r2, #0 30009dd0: e58d2000 str r2, [sp] 30009dd4: e1a00006 mov r0, r6 30009dd8: e1a01004 mov r1, r4 30009ddc: e2822002 add r2, r2, #2 30009de0: ebfff53a bl 300072d0 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
30009de4: e3500000 cmp r0, #0
30009de8: 1a00003a bne 30009ed8 <unlink+0x140>
return -1;
free_parentloc = true;
30009dec: e3a05001 mov r5, #1
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30009df0: e28dc004 add ip, sp, #4
30009df4: e28de018 add lr, sp, #24
30009df8: e8be000f ldm lr!, {r0, r1, r2, r3}
30009dfc: e8ac000f stmia ip!, {r0, r1, r2, r3}
name = path + parentpathlen;
30009e00: e0864004 add r4, r6, r4
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30009e04: e59e3000 ldr r3, [lr]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
30009e08: e1a00004 mov r0, r4
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30009e0c: e58c3000 str r3, [ip]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
30009e10: eb002ce2 bl 300151a0 <strlen> 30009e14: e1a01000 mov r1, r0 30009e18: e1a00004 mov r0, r4 30009e1c: ebfff54c bl 30007354 <rtems_filesystem_prefix_separators> 30009e20: e0846000 add r6, r4, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
30009e24: e1a00006 mov r0, r6 30009e28: eb002cdc bl 300151a0 <strlen> 30009e2c: e28d4004 add r4, sp, #4 30009e30: e1a01000 mov r1, r0 30009e34: e3a02000 mov r2, #0 30009e38: e1a00006 mov r0, r6 30009e3c: e1a03004 mov r3, r4 30009e40: e58d2000 str r2, [sp] 30009e44: ebfff505 bl 30007260 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
30009e48: e3500000 cmp r0, #0
30009e4c: 0a000004 beq 30009e64 <unlink+0xcc>
if ( free_parentloc )
30009e50: e3550000 cmp r5, #0 <== NOT EXECUTED 30009e54: 0a00001f beq 30009ed8 <unlink+0x140> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
30009e58: e28d0018 add r0, sp, #24 <== NOT EXECUTED 30009e5c: ebfff54b bl 30007390 <rtems_filesystem_freenode> <== NOT EXECUTED 30009e60: ea00001c b 30009ed8 <unlink+0x140> <== NOT EXECUTED
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
30009e64: e1a00004 mov r0, r4 30009e68: e59d3010 ldr r3, [sp, #16] 30009e6c: e1a0e00f mov lr, pc 30009e70: e593f010 ldr pc, [r3, #16] 30009e74: e3500001 cmp r0, #1
30009e78: 1a000008 bne 30009ea0 <unlink+0x108>
rtems_filesystem_freenode( &loc );
30009e7c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009e80: ebfff542 bl 30007390 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_parentloc )
30009e84: e3550000 cmp r5, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
30009e88: 128d0018 addne r0, sp, #24 <== NOT EXECUTED 30009e8c: 1bfff53f blne 30007390 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EISDIR );
30009e90: eb002903 bl 300142a4 <__errno> <== NOT EXECUTED 30009e94: e3a03015 mov r3, #21 <== NOT EXECUTED 30009e98: e5803000 str r3, [r0] <== NOT EXECUTED 30009e9c: ea00000d b 30009ed8 <unlink+0x140> <== NOT EXECUTED
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
30009ea0: e28d6018 add r6, sp, #24 30009ea4: e1a01004 mov r1, r4 30009ea8: e59d3010 ldr r3, [sp, #16] 30009eac: e1a00006 mov r0, r6 30009eb0: e1a0e00f mov lr, pc 30009eb4: e593f00c ldr pc, [r3, #12] 30009eb8: e1a07000 mov r7, r0
rtems_filesystem_freenode( &loc );
30009ebc: e1a00004 mov r0, r4 30009ec0: ebfff532 bl 30007390 <rtems_filesystem_freenode>
if ( free_parentloc )
30009ec4: e3550000 cmp r5, #0
30009ec8: 0a000003 beq 30009edc <unlink+0x144>
rtems_filesystem_freenode( &parentloc );
30009ecc: e1a00006 mov r0, r6 30009ed0: ebfff52e bl 30007390 <rtems_filesystem_freenode> 30009ed4: ea000000 b 30009edc <unlink+0x144>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
30009ed8: e3e07000 mvn r7, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
30009edc: e1a00007 mov r0, r7
30009ee0: e28dd030 add sp, sp, #48 ; 0x30
30009ee4: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000a034 <unmount>:
*/
int unmount(
const char *path
)
{
3000a034: e92d4070 push {r4, r5, r6, lr}
3000a038: e24dd018 sub sp, sp, #24
3000a03c: e1a05000 mov r5, r0
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
3000a040: eb00229f bl 30012ac4 <strlen> 3000a044: e28d4004 add r4, sp, #4 3000a048: e3a03001 mov r3, #1 3000a04c: e1a01000 mov r1, r0 3000a050: e58d3000 str r3, [sp] 3000a054: e1a00005 mov r0, r5 3000a058: e3a02000 mov r2, #0 3000a05c: e1a03004 mov r3, r4 3000a060: ebfff46a bl 30007210 <rtems_filesystem_evaluate_path> 3000a064: e3500000 cmp r0, #0
3000a068: 1a000040 bne 3000a170 <unmount+0x13c>
return -1;
mt_entry = loc.mt_entry;
3000a06c: e59d5014 ldr r5, [sp, #20]
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
3000a070: e59d3004 ldr r3, [sp, #4] 3000a074: e595201c ldr r2, [r5, #28] 3000a078: e1520003 cmp r2, r3
3000a07c: 0a000004 beq 3000a094 <unmount+0x60>
rtems_filesystem_freenode( &loc );
3000a080: e1a00004 mov r0, r4 3000a084: ebfff491 bl 300072d0 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
3000a088: eb001d15 bl 300114e4 <__errno> 3000a08c: e3a0300d mov r3, #13 3000a090: ea000011 b 3000a0dc <unmount+0xa8>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
3000a094: e1a00004 mov r0, r4 3000a098: ebfff48c bl 300072d0 <rtems_filesystem_freenode>
* that made the current node thread based instead
* of system based? I thought it was but it doesn't
* look like it in this version.
*/
if ( rtems_filesystem_current.mt_entry == mt_entry )
3000a09c: e59f30d8 ldr r3, [pc, #216] ; 3000a17c <unmount+0x148> 3000a0a0: e5933000 ldr r3, [r3] 3000a0a4: e5933014 ldr r3, [r3, #20] 3000a0a8: e1530005 cmp r3, r5
3000a0ac: 0a000008 beq 3000a0d4 <unmount+0xa0>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
3000a0b0: e59f00c8 ldr r0, [pc, #200] ; 3000a180 <unmount+0x14c> 3000a0b4: e595102c ldr r1, [r5, #44] ; 0x2c 3000a0b8: ebfff6b1 bl 30007b84 <rtems_filesystem_mount_iterate> 3000a0bc: e3500000 cmp r0, #0
3000a0c0: 1a000003 bne 3000a0d4 <unmount+0xa0>
* Run the file descriptor table to determine if there are any file
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
3000a0c4: e1a00005 mov r0, r5 3000a0c8: ebfff55b bl 3000763c <rtems_libio_is_open_files_in_fs> 3000a0cc: e3500001 cmp r0, #1
3000a0d0: 1a000003 bne 3000a0e4 <unmount+0xb0>
rtems_set_errno_and_return_minus_one( EBUSY );
3000a0d4: eb001d02 bl 300114e4 <__errno> 3000a0d8: e3a03010 mov r3, #16 3000a0dc: e5803000 str r3, [r0] 3000a0e0: ea000022 b 3000a170 <unmount+0x13c>
* Allow the file system being unmounted on to do its cleanup.
* If it fails it will set the errno to the approprate value
* and the fileystem will not be modified.
*/
if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )
3000a0e4: e5953014 ldr r3, [r5, #20] 3000a0e8: e1a00005 mov r0, r5 3000a0ec: e1a0e00f mov lr, pc 3000a0f0: e593f028 ldr pc, [r3, #40] ; 0x28 3000a0f4: e2506000 subs r6, r0, #0
3000a0f8: 1a00001c bne 3000a170 <unmount+0x13c>
* NOTE: Fatal error is called in a case which should never happen
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
3000a0fc: e5953028 ldr r3, [r5, #40] ; 0x28 3000a100: e1a00005 mov r0, r5 3000a104: e1a0e00f mov lr, pc 3000a108: e593f02c ldr pc, [r3, #44] ; 0x2c 3000a10c: e2504000 subs r4, r0, #0
3000a110: 0a000007 beq 3000a134 <unmount+0x100>
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
3000a114: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 3000a118: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a11c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a120: e593f020 ldr pc, [r3, #32] <== NOT EXECUTED 3000a124: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a128: 0a000010 beq 3000a170 <unmount+0x13c> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
3000a12c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a130: eb0003e2 bl 3000b0c0 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
3000a134: e59f6048 ldr r6, [pc, #72] ; 3000a184 <unmount+0x150> 3000a138: e1a01004 mov r1, r4 3000a13c: e1a02004 mov r2, r4 3000a140: e5960000 ldr r0, [r6] 3000a144: eb00025b bl 3000aab8 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000a148: e1a00005 mov r0, r5 3000a14c: eb000492 bl 3000b39c <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3000a150: e5960000 ldr r0, [r6] 3000a154: eb00029d bl 3000abd0 <rtems_semaphore_release>
/*
* Free the memory node that was allocated in mount
* Free the memory associated with the extracted mount table entry.
*/
rtems_filesystem_freenode( fs_mount_loc );
3000a158: e2850008 add r0, r5, #8 3000a15c: ebfff45b bl 300072d0 <rtems_filesystem_freenode>
free( mt_entry );
3000a160: e1a00005 mov r0, r5 3000a164: ebfff45e bl 300072e4 <free>
return 0;
3000a168: e1a00004 mov r0, r4 3000a16c: ea000000 b 3000a174 <unmount+0x140>
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
rtems_fatal_error_occurred( 0 );
return -1;
3000a170: e3e00000 mvn r0, #0
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
3000a174: e28dd018 add sp, sp, #24
3000a178: e8bd8070 pop {r4, r5, r6, pc}
30009db0 <utime>:
int utime(
const char *path,
const struct utimbuf *times
)
{
30009db0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30009db4: e24dd020 sub sp, sp, #32 <== NOT EXECUTED
30009db8: e1a04001 mov r4, r1 <== NOT EXECUTED
30009dbc: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_location_info_t temp_loc;
int result;
struct utimbuf now;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
30009dc0: eb002413 bl 30012e14 <strlen> <== NOT EXECUTED 30009dc4: e3a03001 mov r3, #1 <== NOT EXECUTED 30009dc8: e1a01000 mov r1, r0 <== NOT EXECUTED 30009dcc: e58d3000 str r3, [sp] <== NOT EXECUTED 30009dd0: e1a00005 mov r0, r5 <== NOT EXECUTED 30009dd4: e3a02000 mov r2, #0 <== NOT EXECUTED 30009dd8: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30009ddc: ebfff340 bl 30006ae4 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 30009de0: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30009de4: 13e04000 mvnne r4, #0 <== NOT EXECUTED
{
rtems_filesystem_location_info_t temp_loc;
int result;
struct utimbuf now;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
30009de8: 1a00000e bne 30009e28 <utime+0x78> <== NOT EXECUTED
return -1;
if ( times == NULL ) {
30009dec: e3540000 cmp r4, #0 <== NOT EXECUTED 30009df0: 1a000003 bne 30009e04 <utime+0x54> <== NOT EXECUTED
now.actime = now.modtime = time( NULL );
30009df4: eb002459 bl 30012f60 <time> <== NOT EXECUTED 30009df8: e28d4020 add r4, sp, #32 <== NOT EXECUTED 30009dfc: e58d001c str r0, [sp, #28] <== NOT EXECUTED 30009e00: e5240008 str r0, [r4, #-8]! <== NOT EXECUTED
times = &now;
}
result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
30009e04: e28d5004 add r5, sp, #4 <== NOT EXECUTED
30009e08: e8940006 ldm r4, {r1, r2} <== NOT EXECUTED
30009e0c: e1a00005 mov r0, r5 <== NOT EXECUTED
30009e10: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
30009e14: e1a0e00f mov lr, pc <== NOT EXECUTED
30009e18: e593f030 ldr pc, [r3, #48] ; 0x30 <== NOT EXECUTED
30009e1c: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &temp_loc );
30009e20: e1a00005 mov r0, r5 <== NOT EXECUTED 30009e24: ebfff434 bl 30006efc <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
30009e28: e1a00004 mov r0, r4 <== NOT EXECUTED
30009e2c: e28dd020 add sp, sp, #32 <== NOT EXECUTED
30009e30: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30009e34 <utimes>:
int utimes(
const char *path,
const struct timeval times[2]
)
{
30009e34: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
struct utimbuf timeinsecs;
if ( times == NULL )
30009e38: e2513000 subs r3, r1, #0 <== NOT EXECUTED
return utime( path, NULL );
timeinsecs.actime = (time_t) times[0].tv_sec;
30009e3c: 15932000 ldrne r2, [r3] <== NOT EXECUTED
timeinsecs.modtime = (time_t) times[1].tv_sec;
30009e40: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
return utime( path, &timeinsecs );
30009e44: 11a0100d movne r1, sp <== NOT EXECUTED
struct utimbuf timeinsecs;
if ( times == NULL )
return utime( path, NULL );
timeinsecs.actime = (time_t) times[0].tv_sec;
30009e48: 158d2000 strne r2, [sp] <== NOT EXECUTED
timeinsecs.modtime = (time_t) times[1].tv_sec;
30009e4c: 158d3004 strne r3, [sp, #4] <== NOT EXECUTED
return utime( path, &timeinsecs );
30009e50: ebffffd6 bl 30009db0 <utime> <== NOT EXECUTED
}
30009e54: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
30015dc0 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
30015dc0: e92d4030 push {r4, r5, lr}
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30015dc4: e59f4098 ldr r4, [pc, #152] ; 30015e64 <write+0xa4> 30015dc8: e5944000 ldr r4, [r4] 30015dcc: e1500004 cmp r0, r4
30015dd0: 2a000006 bcs 30015df0 <write+0x30> iop = rtems_libio_iop( fd );
30015dd4: e59f408c ldr r4, [pc, #140] ; 30015e68 <write+0xa8> 30015dd8: e3a05038 mov r5, #56 ; 0x38 30015ddc: e5944000 ldr r4, [r4] 30015de0: e0244095 mla r4, r5, r0, r4
rtems_libio_check_is_open( iop );
30015de4: e5940014 ldr r0, [r4, #20] 30015de8: e3100c01 tst r0, #256 ; 0x100
30015dec: 1a000002 bne 30015dfc <write+0x3c>
30015df0: ebffe911 bl 3001023c <__errno> 30015df4: e3a03009 mov r3, #9 30015df8: ea000003 b 30015e0c <write+0x4c>
rtems_libio_check_buffer( buffer );
30015dfc: e3510000 cmp r1, #0
30015e00: 1a000004 bne 30015e18 <write+0x58>
30015e04: ebffe90c bl 3001023c <__errno> <== NOT EXECUTED 30015e08: e3a03016 mov r3, #22 <== NOT EXECUTED
30015e0c: e5803000 str r3, [r0]
30015e10: e3e00000 mvn r0, #0
30015e14: e8bd8030 pop {r4, r5, pc}
rtems_libio_check_count( count );
30015e18: e3520000 cmp r2, #0
30015e1c: 0a00000e beq 30015e5c <write+0x9c> rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30015e20: e3100004 tst r0, #4
30015e24: 0afffff6 beq 30015e04 <write+0x44>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
30015e28: e5943020 ldr r3, [r4, #32] 30015e2c: e1a00004 mov r0, r4 30015e30: e1a0e00f mov lr, pc 30015e34: e593f00c ldr pc, [r3, #12]
if ( rc > 0 )
30015e38: e3500000 cmp r0, #0
30015e3c: d8bd8030 pople {r4, r5, pc}
iop->offset += rc;
30015e40: e284300c add r3, r4, #12
30015e44: e893000c ldm r3, {r2, r3}
30015e48: e0922000 adds r2, r2, r0
30015e4c: e0a33fc0 adc r3, r3, r0, asr #31
30015e50: e584200c str r2, [r4, #12]
30015e54: e5843010 str r3, [r4, #16]
30015e58: e8bd8030 pop {r4, r5, pc}
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
30015e5c: e1a00002 mov r0, r2
if ( rc > 0 )
iop->offset += rc;
return rc;
}
30015e60: e8bd8030 pop {r4, r5, pc}
3000a114 <writev>:
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
3000a114: e59f3150 ldr r3, [pc, #336] ; 3000a26c <writev+0x158> <== NOT EXECUTED
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
3000a118: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
3000a11c: e5933000 ldr r3, [r3] <== NOT EXECUTED
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
3000a120: e1a08002 mov r8, r2 <== NOT EXECUTED
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
3000a124: e1500003 cmp r0, r3 <== NOT EXECUTED 3000a128: 2a000006 bcs 3000a148 <writev+0x34> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
3000a12c: e59f313c ldr r3, [pc, #316] ; 3000a270 <writev+0x15c> <== NOT EXECUTED 3000a130: e3a06038 mov r6, #56 ; 0x38 <== NOT EXECUTED 3000a134: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a138: e0263690 mla r6, r0, r6, r3 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
3000a13c: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 3000a140: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3000a144: 1a000002 bne 3000a154 <writev+0x40> <== NOT EXECUTED 3000a148: eb001c20 bl 300111d0 <__errno> <== NOT EXECUTED 3000a14c: e3a03009 mov r3, #9 <== NOT EXECUTED 3000a150: ea00001f b 3000a1d4 <writev+0xc0> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000a154: e3130004 tst r3, #4 <== NOT EXECUTED 3000a158: 0a00001b beq 3000a1cc <writev+0xb8> <== NOT EXECUTED
/*
* Argument validation on IO vector
*/
if ( !iov )
3000a15c: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a160: 0a000019 beq 3000a1cc <writev+0xb8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
3000a164: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a168: da000017 ble 3000a1cc <writev+0xb8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
3000a16c: e3520b01 cmp r2, #1024 ; 0x400 <== NOT EXECUTED 3000a170: ca000015 bgt 3000a1cc <writev+0xb8> <== NOT EXECUTED 3000a174: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000a178: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
3000a17c: e1a02001 mov r2, r1 <== NOT EXECUTED 3000a180: e3a07001 mov r7, #1 <== NOT EXECUTED 3000a184: e1a04003 mov r4, r3 <== NOT EXECUTED
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
3000a188: e59f00e4 ldr r0, [pc, #228] ; 3000a274 <writev+0x160> <== NOT EXECUTED 3000a18c: ea000000 b 3000a194 <writev+0x80> <== NOT EXECUTED
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
3000a190: e1a04001 mov r4, r1 <== NOT EXECUTED
/*
* 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 )
3000a194: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000a198: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a19c: 0a00000a beq 3000a1cc <writev+0xb8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
3000a1a0: e5921004 ldr r1, [r2, #4] <== NOT EXECUTED
all_zeros = false;
3000a1a4: e3510000 cmp r1, #0 <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
3000a1a8: e0841001 add r1, r4, r1 <== NOT EXECUTED
*/
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
3000a1ac: 13a07000 movne r7, #0 <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
3000a1b0: e1510004 cmp r1, r4 <== NOT EXECUTED 3000a1b4: a3a04000 movge r4, #0 <== NOT EXECUTED 3000a1b8: b3a04001 movlt r4, #1 <== NOT EXECUTED 3000a1bc: e1510000 cmp r1, r0 <== NOT EXECUTED 3000a1c0: c3844001 orrgt r4, r4, #1 <== NOT EXECUTED 3000a1c4: e3540000 cmp r4, #0 <== NOT EXECUTED 3000a1c8: 0a000003 beq 3000a1dc <writev+0xc8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000a1cc: eb001bff bl 300111d0 <__errno> <== NOT EXECUTED 3000a1d0: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a1d4: e5803000 str r3, [r0] <== NOT EXECUTED 3000a1d8: ea000020 b 3000a260 <writev+0x14c> <== NOT EXECUTED
* 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++ ) {
3000a1dc: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000a1e0: e1530008 cmp r3, r8 <== NOT EXECUTED 3000a1e4: e2822008 add r2, r2, #8 <== NOT EXECUTED 3000a1e8: baffffe8 blt 3000a190 <writev+0x7c> <== NOT EXECUTED
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
3000a1ec: e3570000 cmp r7, #0 <== NOT EXECUTED 3000a1f0: 1a00001b bne 3000a264 <writev+0x150> <== NOT EXECUTED 3000a1f4: e1a04007 mov r4, r7 <== NOT EXECUTED
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
3000a1f8: e5952004 ldr r2, [r5, #4] <== NOT EXECUTED 3000a1fc: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a200: 0a000011 beq 3000a24c <writev+0x138> <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
3000a204: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED 3000a208: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a20c: e5951000 ldr r1, [r5] <== NOT EXECUTED 3000a210: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a214: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
3000a218: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a21c: ba00000f blt 3000a260 <writev+0x14c> <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
3000a220: 0a000006 beq 3000a240 <writev+0x12c> <== NOT EXECUTED
iop->offset += bytes;
3000a224: e286300c add r3, r6, #12 <== NOT EXECUTED
3000a228: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000a22c: e0922000 adds r2, r2, r0 <== NOT EXECUTED
3000a230: e0a33fc0 adc r3, r3, r0, asr #31 <== NOT EXECUTED
3000a234: e586200c str r2, [r6, #12] <== NOT EXECUTED
3000a238: e5863010 str r3, [r6, #16] <== NOT EXECUTED
total += bytes;
3000a23c: e0844000 add r4, r4, r0 <== NOT EXECUTED
}
if (bytes != iov[ v ].iov_len)
3000a240: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 3000a244: e1500003 cmp r0, r3 <== NOT EXECUTED 3000a248: 1a000005 bne 3000a264 <writev+0x150> <== NOT EXECUTED
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3000a24c: e2877001 add r7, r7, #1 <== NOT EXECUTED 3000a250: e1570008 cmp r7, r8 <== NOT EXECUTED 3000a254: e2855008 add r5, r5, #8 <== NOT EXECUTED 3000a258: baffffe6 blt 3000a1f8 <writev+0xe4> <== NOT EXECUTED 3000a25c: ea000000 b 3000a264 <writev+0x150> <== NOT EXECUTED
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
3000a260: e3e04000 mvn r4, #0 <== NOT EXECUTED
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
3000a264: e1a00004 mov r0, r4 <== NOT EXECUTED
3000a268: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED