30006ac8 <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 );
30006ac8: e3a03000 mov r3, #0 <== NOT EXECUTED 30006acc: e5803084 str r3, [r0, #132] ; 0x84 <== NOT EXECUTED 30006ad0: e5803088 str r3, [r0, #136] ; 0x88 <== NOT EXECUTED
#else
the_thread->cpu_time_used = 0;
#endif
}
30006ad4: 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: eb003081 bl 30011c40 <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: eb0030d5 bl 30011dac <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: eb0030cf bl 30011dac <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: eb003066 bl 30011c40 <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: eb0030ba bl 30011dac <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: eb0030b2 bl 30011dac <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
3000d028 <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 ) {
3000d028: e5902000 ldr r2, [r0]
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
3000d02c: e5903010 ldr r3, [r0, #16]
switch( node->type ) {
3000d030: 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;
3000d034: e5933034 ldr r3, [r3, #52] ; 0x34
switch( node->type ) {
3000d038: e2422001 sub r2, r2, #1 3000d03c: e3520006 cmp r2, #6 3000d040: 979ff102 ldrls pc, [pc, r2, lsl #2]
3000d044: ea000010 b 3000d08c <IMFS_Set_handlers+0x64> <== NOT EXECUTED 3000d048: 3000d064 .word 0x3000d064 <== NOT EXECUTED 3000d04c: 3000d06c .word 0x3000d06c <== NOT EXECUTED 3000d050: 3000d074 .word 0x3000d074 <== NOT EXECUTED 3000d054: 3000d074 .word 0x3000d074 <== NOT EXECUTED 3000d058: 3000d07c .word 0x3000d07c <== NOT EXECUTED 3000d05c: 3000d07c .word 0x3000d07c <== NOT EXECUTED 3000d060: 3000d084 .word 0x3000d084 <== NOT EXECUTED
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
3000d064: e593300c ldr r3, [r3, #12] 3000d068: ea000006 b 3000d088 <IMFS_Set_handlers+0x60>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
3000d06c: e59f3020 ldr r3, [pc, #32] ; 3000d094 <IMFS_Set_handlers+0x6c> 3000d070: ea000004 b 3000d088 <IMFS_Set_handlers+0x60>
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
3000d074: e59f301c ldr r3, [pc, #28] ; 3000d098 <IMFS_Set_handlers+0x70> 3000d078: ea000002 b 3000d088 <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;
3000d07c: e5933008 ldr r3, [r3, #8] 3000d080: ea000000 b 3000d088 <IMFS_Set_handlers+0x60>
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
3000d084: e5933010 ldr r3, [r3, #16] 3000d088: e5803008 str r3, [r0, #8]
break;
}
return 0;
}
3000d08c: e3a00000 mov r0, #0 3000d090: e12fff1e bx lr
3000cdc4 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
3000cdc4: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr} <== NOT EXECUTED
3000cdc8: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
3000cdcc: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
3000cdd0: e5904000 ldr r4, [r0] <== NOT EXECUTED
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
3000cdd4: e1a06821 lsr r6, r1, #16 <== NOT EXECUTED 3000cdd8: e1a07822 lsr r7, r2, #16 <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
3000cddc: eb000397 bl 3000dc40 <geteuid> <== NOT EXECUTED
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
3000cde0: e1d453bc ldrh r5, [r4, #60] ; 0x3c <== NOT EXECUTED 3000cde4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000cde8: 11550000 cmpne r5, r0 <== NOT EXECUTED 3000cdec: 03a05000 moveq r5, #0 <== NOT EXECUTED 3000cdf0: 13a05001 movne r5, #1 <== NOT EXECUTED 3000cdf4: 0a000004 beq 3000ce0c <IMFS_chown+0x48> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
3000cdf8: eb0010b1 bl 300110c4 <__errno> <== NOT EXECUTED 3000cdfc: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ce00: e5803000 str r3, [r0] <== NOT EXECUTED 3000ce04: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000ce08: ea000007 b 3000ce2c <IMFS_chown+0x68> <== NOT EXECUTED
#endif
jnode->st_uid = owner;
3000ce0c: e1c463bc strh r6, [r4, #60] ; 0x3c <== NOT EXECUTED
jnode->st_gid = group;
3000ce10: e1c473be strh r7, [r4, #62] ; 0x3e <== NOT EXECUTED
IMFS_update_ctime( jnode );
3000ce14: e1a0000d mov r0, sp <== NOT EXECUTED 3000ce18: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ce1c: ebffe549 bl 30006348 <gettimeofday> <== NOT EXECUTED 3000ce20: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
3000ce24: e1a00005 mov r0, r5 <== NOT EXECUTED
#endif
jnode->st_uid = owner;
jnode->st_gid = group;
IMFS_update_ctime( jnode );
3000ce28: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
3000ce2c: e8bd80fc pop {r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000d150 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
3000d150: 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 ) ) {
3000d154: e3d27007 bics r7, r2, #7
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
3000d158: e24dd040 sub sp, sp, #64 ; 0x40 3000d15c: e58d0000 str r0, [sp] 3000d160: e1a06001 mov r6, r1 3000d164: e1a08002 mov r8, r2 3000d168: e1a04003 mov r4, r3
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
3000d16c: 05935000 ldreq r5, [r3]
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
int len;
IMFS_token_types type = IMFS_CURRENT_DIR;
3000d170: 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 );
3000d174: 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 ) ) {
3000d178: 0a000057 beq 3000d2dc <IMFS_eval_path+0x18c>
rtems_set_errno_and_return_minus_one( EIO );
3000d17c: eb000fd0 bl 300110c4 <__errno> <== NOT EXECUTED 3000d180: e3a03005 mov r3, #5 <== NOT EXECUTED 3000d184: ea00007e b 3000d384 <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 );
3000d188: e59d2000 ldr r2, [sp] 3000d18c: e28d303c add r3, sp, #60 ; 0x3c 3000d190: e0820007 add r0, r2, r7 3000d194: e1a01006 mov r1, r6 3000d198: e1a0200a mov r2, sl 3000d19c: eb0001ae bl 3000d85c <IMFS_get_token>
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
3000d1a0: 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 );
3000d1a4: e1a09000 mov r9, r0
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
3000d1a8: 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;
3000d1ac: e59db03c ldr fp, [sp, #60] ; 0x3c
i += len;
if ( !pathloc->node_access )
3000d1b0: 0a000041 beq 3000d2bc <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 )
3000d1b4: e3500000 cmp r0, #0
3000d1b8: 0a000006 beq 3000d1d8 <IMFS_eval_path+0x88>
if ( node->type == IMFS_DIRECTORY )
3000d1bc: e595104c ldr r1, [r5, #76] ; 0x4c 3000d1c0: e3510001 cmp r1, #1
3000d1c4: 1a000003 bne 3000d1d8 <IMFS_eval_path+0x88>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
3000d1c8: e1a00004 mov r0, r4 3000d1cc: ebffffb2 bl 3000d09c <IMFS_evaluate_permission> 3000d1d0: e3500000 cmp r0, #0
3000d1d4: 0a000068 beq 3000d37c <IMFS_eval_path+0x22c>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
3000d1d8: 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;
3000d1dc: e06b6006 rsb r6, fp, r6
i += len;
3000d1e0: 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;
3000d1e4: e5945000 ldr r5, [r4]
switch( type ) {
3000d1e8: 0a000014 beq 3000d240 <IMFS_eval_path+0xf0>
3000d1ec: e3590004 cmp r9, #4
3000d1f0: 0a000036 beq 3000d2d0 <IMFS_eval_path+0x180>
3000d1f4: e3590002 cmp r9, #2
3000d1f8: 1a000037 bne 3000d2dc <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 )
3000d1fc: e59fc194 ldr ip, [pc, #404] ; 3000d398 <IMFS_eval_path+0x248> 3000d200: e59c3000 ldr r3, [ip] 3000d204: e5933018 ldr r3, [r3, #24] 3000d208: e1550003 cmp r5, r3
3000d20c: 0a000032 beq 3000d2dc <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) {
3000d210: e594e010 ldr lr, [r4, #16]
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
3000d214: e59e301c ldr r3, [lr, #28] 3000d218: 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;
3000d21c: 028dc028 addeq ip, sp, #40 ; 0x28 3000d220: 028ee008 addeq lr, lr, #8
3000d224: 0a000037 beq 3000d308 <IMFS_eval_path+0x1b8>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
3000d228: e5955008 ldr r5, [r5, #8] 3000d22c: e3550000 cmp r5, #0
3000d230: 1a000024 bne 3000d2c8 <IMFS_eval_path+0x178>
rtems_set_errno_and_return_minus_one( ENOENT );
3000d234: eb000fa2 bl 300110c4 <__errno> <== NOT EXECUTED 3000d238: e5809000 str r9, [r0] <== NOT EXECUTED 3000d23c: ea000051 b 3000d388 <IMFS_eval_path+0x238> <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
3000d240: e595304c ldr r3, [r5, #76] ; 0x4c 3000d244: e3530003 cmp r3, #3
3000d248: 1a000004 bne 3000d260 <IMFS_eval_path+0x110>
IMFS_evaluate_hard_link( pathloc, 0 );
3000d24c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d250: e3a01000 mov r1, #0 <== NOT EXECUTED 3000d254: ebffffaa bl 3000d104 <IMFS_evaluate_hard_link> <== NOT EXECUTED
node = pathloc->node_access;
3000d258: e5945000 ldr r5, [r4] <== NOT EXECUTED 3000d25c: ea000008 b 3000d284 <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 ) {
3000d260: e3530004 cmp r3, #4
3000d264: 1a000006 bne 3000d284 <IMFS_eval_path+0x134>
result = IMFS_evaluate_sym_link( pathloc, 0 );
3000d268: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d26c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000d270: eb000049 bl 3000d39c <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 )
3000d274: 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 );
3000d278: 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;
3000d27c: e5945000 ldr r5, [r4] <== NOT EXECUTED
if ( result == -1 )
3000d280: 0a000041 beq 3000d38c <IMFS_eval_path+0x23c> <== NOT EXECUTED
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
3000d284: e595304c ldr r3, [r5, #76] ; 0x4c 3000d288: e3530001 cmp r3, #1
3000d28c: 0a000002 beq 3000d29c <IMFS_eval_path+0x14c>
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000d290: eb000f8b bl 300110c4 <__errno> <== NOT EXECUTED 3000d294: e3a03014 mov r3, #20 <== NOT EXECUTED 3000d298: ea000039 b 3000d384 <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 ) {
3000d29c: e595e05c ldr lr, [r5, #92] ; 0x5c 3000d2a0: e35e0000 cmp lr, #0
3000d2a4: 1a000015 bne 3000d300 <IMFS_eval_path+0x1b0>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
3000d2a8: e1a00005 mov r0, r5 3000d2ac: e1a0100a mov r1, sl 3000d2b0: eb000149 bl 3000d7dc <IMFS_find_match_in_dir>
if ( !node )
3000d2b4: e2505000 subs r5, r0, #0
3000d2b8: 1a000002 bne 3000d2c8 <IMFS_eval_path+0x178>
rtems_set_errno_and_return_minus_one( ENOENT );
3000d2bc: eb000f80 bl 300110c4 <__errno> 3000d2c0: e3a03002 mov r3, #2 3000d2c4: ea00002e b 3000d384 <IMFS_eval_path+0x234>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
3000d2c8: e5845000 str r5, [r4] 3000d2cc: ea000002 b 3000d2dc <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 );
3000d2d0: eb000f7b bl 300110c4 <__errno> <== NOT EXECUTED 3000d2d4: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 3000d2d8: ea000029 b 3000d384 <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) ) {
3000d2dc: e3590004 cmp r9, #4 3000d2e0: 13590000 cmpne r9, #0
3000d2e4: 1affffa7 bne 3000d188 <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 ) {
3000d2e8: e595304c ldr r3, [r5, #76] ; 0x4c 3000d2ec: e3530001 cmp r3, #1
3000d2f0: 1a000019 bne 3000d35c <IMFS_eval_path+0x20c>
if ( node->info.directory.mt_fs != NULL ) {
3000d2f4: e595e05c ldr lr, [r5, #92] ; 0x5c 3000d2f8: e35e0000 cmp lr, #0
3000d2fc: 0a000016 beq 3000d35c <IMFS_eval_path+0x20c>
newloc = node->info.directory.mt_fs->mt_fs_root;
3000d300: e28dc028 add ip, sp, #40 ; 0x28
3000d304: e28ee01c add lr, lr, #28
3000d308: e8be000f ldm lr!, {r0, r1, r2, r3}
3000d30c: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000d310: e59ee000 ldr lr, [lr]
3000d314: e58ce000 str lr, [ip]
*pathloc = newloc;
3000d318: e28dc028 add ip, sp, #40 ; 0x28
3000d31c: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000d320: e1a0c004 mov ip, r4
3000d324: e8ac000f stmia ip!, {r0, r1, r2, r3}
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
3000d328: e59d103c ldr r1, [sp, #60] ; 0x3c 3000d32c: 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;
3000d330: e58ce000 str lr, [ip]
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
3000d334: e0610007 rsb r0, r1, r7 3000d338: e0820000 add r0, r2, r0 3000d33c: e594c00c ldr ip, [r4, #12] 3000d340: e0861001 add r1, r6, r1 3000d344: e1a02008 mov r2, r8 3000d348: e1a03004 mov r3, r4 3000d34c: e1a0e00f mov lr, pc 3000d350: e59cf000 ldr pc, [ip] 3000d354: e1a0b000 mov fp, r0 3000d358: ea00000b b 3000d38c <IMFS_eval_path+0x23c>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
3000d35c: e1a00004 mov r0, r4 3000d360: ebffff30 bl 3000d028 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
3000d364: e1a01008 mov r1, r8
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
3000d368: e1a0b000 mov fp, r0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
3000d36c: e1a00004 mov r0, r4 3000d370: ebffff49 bl 3000d09c <IMFS_evaluate_permission> 3000d374: e3500000 cmp r0, #0
3000d378: 1a000003 bne 3000d38c <IMFS_eval_path+0x23c>
rtems_set_errno_and_return_minus_one( EACCES );
3000d37c: eb000f50 bl 300110c4 <__errno> <== NOT EXECUTED 3000d380: e3a0300d mov r3, #13 <== NOT EXECUTED
3000d384: e5803000 str r3, [r0] 3000d388: e3e0b000 mvn fp, #0
return result;
}
3000d38c: e1a0000b mov r0, fp
3000d390: e28dd040 add sp, sp, #64 ; 0x40
3000d394: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000d4d8 <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 */
)
{
3000d4d8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000d4dc: e24dd03c sub sp, sp, #60 ; 0x3c
3000d4e0: e1a07000 mov r7, r0
3000d4e4: e1a04001 mov r4, r1
3000d4e8: e1a0a002 mov sl, r2
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
3000d4ec: e5916000 ldr r6, [r1]
/*
* Get the path length.
*/
pathlen = strlen( path );
3000d4f0: eb0012dd bl 3001206c <strlen>
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
3000d4f4: e3a05000 mov r5, #0
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
3000d4f8: 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 );
3000d4fc: e1a01008 mov r1, r8 3000d500: e28d3038 add r3, sp, #56 ; 0x38 3000d504: e0870005 add r0, r7, r5 3000d508: e1a0200d mov r2, sp 3000d50c: eb0000d2 bl 3000d85c <IMFS_get_token>
pathlen -= len;
i += len;
if ( !pathloc->node_access )
3000d510: e5943000 ldr r3, [r4]
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
3000d514: e59db038 ldr fp, [sp, #56] ; 0x38
i += len;
if ( !pathloc->node_access )
3000d518: 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 );
3000d51c: e1a09000 mov r9, r0
pathlen -= len;
3000d520: e06b8008 rsb r8, fp, r8
i += len;
if ( !pathloc->node_access )
3000d524: 0a000060 beq 3000d6ac <IMFS_evaluate_for_make+0x1d4>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
3000d528: e3500000 cmp r0, #0
3000d52c: 0a000006 beq 3000d54c <IMFS_evaluate_for_make+0x74>
if ( node->type == IMFS_DIRECTORY )
3000d530: e596104c ldr r1, [r6, #76] ; 0x4c 3000d534: e3510001 cmp r1, #1
3000d538: 1a000003 bne 3000d54c <IMFS_evaluate_for_make+0x74>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
3000d53c: e1a00004 mov r0, r4 3000d540: ebfffed5 bl 3000d09c <IMFS_evaluate_permission> 3000d544: e3500000 cmp r0, #0
3000d548: 0a00006c beq 3000d700 <IMFS_evaluate_for_make+0x228>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
3000d54c: e5943000 ldr r3, [r4]
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
3000d550: 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;
3000d554: e1a06003 mov r6, r3
switch( type ) {
3000d558: e3590004 cmp r9, #4 3000d55c: 979ff109 ldrls pc, [pc, r9, lsl #2]
3000d560: eaffffe5 b 3000d4fc <IMFS_evaluate_for_make+0x24> <== NOT EXECUTED 3000d564: 3000d670 .word 0x3000d670 <== NOT EXECUTED 3000d568: 3000d4fc .word 0x3000d4fc <== NOT EXECUTED 3000d56c: 3000d578 .word 0x3000d578 <== NOT EXECUTED 3000d570: 3000d5b4 .word 0x3000d5b4 <== NOT EXECUTED 3000d574: 3000d67c .word 0x3000d67c <== 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 )
3000d578: e59f119c ldr r1, [pc, #412] ; 3000d71c <IMFS_evaluate_for_make+0x244> 3000d57c: e5912000 ldr r2, [r1] 3000d580: e5922018 ldr r2, [r2, #24] 3000d584: e1530002 cmp r3, r2
3000d588: 0affffdb beq 3000d4fc <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){
3000d58c: e594e010 ldr lr, [r4, #16] 3000d590: e59e201c ldr r2, [lr, #28] 3000d594: e1530002 cmp r3, r2
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
3000d598: 028dc024 addeq ip, sp, #36 ; 0x24 3000d59c: 028ee008 addeq lr, lr, #8
3000d5a0: 0a000019 beq 3000d60c <IMFS_evaluate_for_make+0x134>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
3000d5a4: e5936008 ldr r6, [r3, #8] 3000d5a8: e3560000 cmp r6, #0
3000d5ac: 1a00002d bne 3000d668 <IMFS_evaluate_for_make+0x190>
3000d5b0: ea00003d b 3000d6ac <IMFS_evaluate_for_make+0x1d4> <== NOT EXECUTED
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
3000d5b4: e593304c ldr r3, [r3, #76] ; 0x4c 3000d5b8: e3530003 cmp r3, #3
3000d5bc: 0a000001 beq 3000d5c8 <IMFS_evaluate_for_make+0xf0>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
3000d5c0: e3530004 cmp r3, #4
3000d5c4: 1a000005 bne 3000d5e0 <IMFS_evaluate_for_make+0x108>
result = IMFS_evaluate_link( pathloc, 0 );
3000d5c8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d5cc: e3a01000 mov r1, #0 <== NOT EXECUTED 3000d5d0: ebffff93 bl 3000d424 <IMFS_evaluate_link> <== NOT EXECUTED
if ( result == -1 )
3000d5d4: e3700001 cmn r0, #1 <== NOT EXECUTED
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
3000d5d8: e1a06000 mov r6, r0 <== NOT EXECUTED
if ( result == -1 )
3000d5dc: 0a00004b beq 3000d710 <IMFS_evaluate_for_make+0x238> <== NOT EXECUTED
return -1;
}
node = pathloc->node_access;
3000d5e0: e5940000 ldr r0, [r4]
if ( !node )
3000d5e4: e3500000 cmp r0, #0
3000d5e8: 0a00003c beq 3000d6e0 <IMFS_evaluate_for_make+0x208>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
3000d5ec: e590304c ldr r3, [r0, #76] ; 0x4c 3000d5f0: e3530001 cmp r3, #1
3000d5f4: 1a000039 bne 3000d6e0 <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 ) {
3000d5f8: e590e05c ldr lr, [r0, #92] ; 0x5c 3000d5fc: e35e0000 cmp lr, #0
3000d600: 0a000014 beq 3000d658 <IMFS_evaluate_for_make+0x180>
newloc = node->info.directory.mt_fs->mt_fs_root;
3000d604: e28dc024 add ip, sp, #36 ; 0x24
3000d608: e28ee01c add lr, lr, #28
3000d60c: e8be000f ldm lr!, {r0, r1, r2, r3}
3000d610: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000d614: e59ee000 ldr lr, [lr]
3000d618: e58ce000 str lr, [ip]
*pathloc = newloc;
3000d61c: e28dc024 add ip, sp, #36 ; 0x24
3000d620: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000d624: e1a0c004 mov ip, r4
3000d628: e8ac000f stmia ip!, {r0, r1, r2, r3}
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
3000d62c: 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;
3000d630: e58ce000 str lr, [ip]
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
3000d634: e0625005 rsb r5, r2, r5 3000d638: e594300c ldr r3, [r4, #12] 3000d63c: e0870005 add r0, r7, r5 3000d640: e1a01004 mov r1, r4 3000d644: e1a0200a mov r2, sl 3000d648: e1a0e00f mov lr, pc 3000d64c: e593f004 ldr pc, [r3, #4] 3000d650: e1a06000 mov r6, r0 3000d654: ea00002d b 3000d710 <IMFS_evaluate_for_make+0x238>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
3000d658: e1a0100d mov r1, sp 3000d65c: eb00005e bl 3000d7dc <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
3000d660: e2506000 subs r6, r0, #0
3000d664: 0a000007 beq 3000d688 <IMFS_evaluate_for_make+0x1b0>
done = true;
else
pathloc->node_access = node;
3000d668: e5846000 str r6, [r4] 3000d66c: eaffffa2 b 3000d4fc <IMFS_evaluate_for_make+0x24>
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
3000d670: eb000e93 bl 300110c4 <__errno> 3000d674: e3a03011 mov r3, #17 3000d678: ea000022 b 3000d708 <IMFS_evaluate_for_make+0x230>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
3000d67c: eb000e90 bl 300110c4 <__errno> <== NOT EXECUTED 3000d680: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 3000d684: ea00001f b 3000d708 <IMFS_evaluate_for_make+0x230> <== NOT EXECUTED
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
3000d688: e59d3038 ldr r3, [sp, #56] ; 0x38 3000d68c: e0633005 rsb r3, r3, r5 3000d690: e0873003 add r3, r7, r3 3000d694: 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(
3000d698: 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++) {
3000d69c: ea000005 b 3000d6b8 <IMFS_evaluate_for_make+0x1e0>
if ( !IMFS_is_separator( path[ i ] ) )
3000d6a0: ebffe687 bl 300070c4 <rtems_filesystem_is_separator> <== NOT EXECUTED 3000d6a4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d6a8: 1a000002 bne 3000d6b8 <IMFS_evaluate_for_make+0x1e0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
3000d6ac: eb000e84 bl 300110c4 <__errno> <== NOT EXECUTED 3000d6b0: e3a03002 mov r3, #2 <== NOT EXECUTED 3000d6b4: ea000013 b 3000d708 <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++) {
3000d6b8: e4d50001 ldrb r0, [r5], #1 3000d6bc: e3500000 cmp r0, #0
3000d6c0: 1afffff6 bne 3000d6a0 <IMFS_evaluate_for_make+0x1c8>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
3000d6c4: e1a00004 mov r0, r4 3000d6c8: ebfffe56 bl 3000d028 <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
3000d6cc: e5943000 ldr r3, [r4]
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
3000d6d0: e1a06000 mov r6, r0
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
3000d6d4: e593304c ldr r3, [r3, #76] ; 0x4c 3000d6d8: e3530001 cmp r3, #1
3000d6dc: 0a000002 beq 3000d6ec <IMFS_evaluate_for_make+0x214>
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000d6e0: eb000e77 bl 300110c4 <__errno> <== NOT EXECUTED 3000d6e4: e3a03014 mov r3, #20 <== NOT EXECUTED 3000d6e8: ea000006 b 3000d708 <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 ) )
3000d6ec: e1a00004 mov r0, r4 3000d6f0: e3a01003 mov r1, #3 3000d6f4: ebfffe68 bl 3000d09c <IMFS_evaluate_permission> 3000d6f8: e3500000 cmp r0, #0
3000d6fc: 1a000003 bne 3000d710 <IMFS_evaluate_for_make+0x238>
rtems_set_errno_and_return_minus_one( EACCES );
3000d700: eb000e6f bl 300110c4 <__errno> 3000d704: e3a0300d mov r3, #13 3000d708: e5803000 str r3, [r0] 3000d70c: e3e06000 mvn r6, #0
return result;
}
3000d710: e1a00006 mov r0, r6
3000d714: e28dd03c add sp, sp, #60 ; 0x3c
3000d718: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000d104 <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d104: 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;
3000d108: e5903000 ldr r3, [r0] <== NOT EXECUTED
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d10c: 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;
3000d110: e5933050 ldr r3, [r3, #80] ; 0x50 <== NOT EXECUTED
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d114: 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;
3000d118: e5803000 str r3, [r0] <== NOT EXECUTED
IMFS_Set_handlers( node );
3000d11c: ebffffc1 bl 3000d028 <IMFS_Set_handlers> <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
3000d120: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d124: e1a01005 mov r1, r5 <== NOT EXECUTED 3000d128: ebffffdb bl 3000d09c <IMFS_evaluate_permission> <== NOT EXECUTED 3000d12c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d130: 1a000004 bne 3000d148 <IMFS_evaluate_hard_link+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
3000d134: eb000fe2 bl 300110c4 <__errno> <== NOT EXECUTED
3000d138: e3a0300d mov r3, #13 <== NOT EXECUTED
3000d13c: e5803000 str r3, [r0] <== NOT EXECUTED
3000d140: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d144: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
return result;
3000d148: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000d14c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000d424 <IMFS_evaluate_link>:
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d424: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000d428: e59f70a4 ldr r7, [pc, #164] ; 3000d4d4 <IMFS_evaluate_link+0xb0>
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d42c: e1a04000 mov r4, r0 3000d430: e1a05001 mov r5, r1
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000d434: e5973000 ldr r3, [r7]
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
3000d438: e5946000 ldr r6, [r4]
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000d43c: e1d323b0 ldrh r2, [r3, #48] ; 0x30 3000d440: e2822001 add r2, r2, #1 3000d444: e1a02802 lsl r2, r2, #16 3000d448: e1a02822 lsr r2, r2, #16
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
3000d44c: e3520005 cmp r2, #5
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000d450: e1c323b0 strh r2, [r3, #48] ; 0x30
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
3000d454: 9a000006 bls 3000d474 <IMFS_evaluate_link+0x50>
rtems_filesystem_link_counts = 0;
3000d458: e3a02000 mov r2, #0 <== NOT EXECUTED 3000d45c: e1c323b0 strh r2, [r3, #48] ; 0x30 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ELOOP );
3000d460: eb000f17 bl 300110c4 <__errno> <== NOT EXECUTED
3000d464: e3a0305c mov r3, #92 ; 0x5c <== NOT EXECUTED
3000d468: e5803000 str r3, [r0] <== NOT EXECUTED
3000d46c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d470: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
3000d474: e596304c ldr r3, [r6, #76] ; 0x4c 3000d478: e3530003 cmp r3, #3
3000d47c: 1a000003 bne 3000d490 <IMFS_evaluate_link+0x6c>
result = IMFS_evaluate_hard_link( node, flags );
3000d480: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d484: e1a01005 mov r1, r5 <== NOT EXECUTED 3000d488: ebffff1d bl 3000d104 <IMFS_evaluate_hard_link> <== NOT EXECUTED 3000d48c: ea000004 b 3000d4a4 <IMFS_evaluate_link+0x80> <== NOT EXECUTED
else if (jnode->type == IMFS_SYM_LINK )
3000d490: e3530004 cmp r3, #4
3000d494: 1a000004 bne 3000d4ac <IMFS_evaluate_link+0x88>
result = IMFS_evaluate_sym_link( node, flags );
3000d498: e1a00004 mov r0, r4 3000d49c: e1a01005 mov r1, r5 3000d4a0: ebffffbd bl 3000d39c <IMFS_evaluate_sym_link>
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
3000d4a4: e3500000 cmp r0, #0
3000d4a8: 1a000004 bne 3000d4c0 <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 ) ||
3000d4ac: e596304c ldr r3, [r6, #76] ; 0x4c 3000d4b0: e2433003 sub r3, r3, #3 3000d4b4: e3530001 cmp r3, #1
3000d4b8: 9affffdd bls 3000d434 <IMFS_evaluate_link+0x10>
3000d4bc: e3a00000 mov r0, #0
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
3000d4c0: e59f300c ldr r3, [pc, #12] ; 3000d4d4 <IMFS_evaluate_link+0xb0> 3000d4c4: e3a02000 mov r2, #0 3000d4c8: e5933000 ldr r3, [r3] 3000d4cc: e1c323b0 strh r2, [r3, #48] ; 0x30
return result;
}
3000d4d0: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000d09c <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 ) )
3000d09c: e3d13007 bics r3, r1, #7
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
3000d0a0: e92d4070 push {r4, r5, r6, lr}
3000d0a4: e1a04001 mov r4, r1
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
3000d0a8: 0a000004 beq 3000d0c0 <IMFS_evaluate_permission+0x24>
rtems_set_errno_and_return_minus_one( EPERM );
3000d0ac: eb001004 bl 300110c4 <__errno> <== NOT EXECUTED
3000d0b0: e3a03001 mov r3, #1 <== NOT EXECUTED
3000d0b4: e5803000 str r3, [r0] <== NOT EXECUTED
3000d0b8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d0bc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
jnode = node->node_access;
3000d0c0: e5905000 ldr r5, [r0]
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
3000d0c4: eb0002dd bl 3000dc40 <geteuid> 3000d0c8: e1a06000 mov r6, r0
st_gid = getegid();
3000d0cc: eb0002d6 bl 3000dc2c <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
3000d0d0: e1d533bc ldrh r3, [r5, #60] ; 0x3c 3000d0d4: e1530006 cmp r3, r6
flags_to_test <<= 6;
3000d0d8: 01a04304 lsleq r4, r4, #6
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
3000d0dc: 0a000002 beq 3000d0ec <IMFS_evaluate_permission+0x50>
flags_to_test <<= 6;
else if ( st_gid == jnode->st_gid )
3000d0e0: e1d533be ldrh r3, [r5, #62] ; 0x3e <== NOT EXECUTED 3000d0e4: e1530000 cmp r3, r0 <== NOT EXECUTED
flags_to_test <<= 3;
3000d0e8: 01a04184 lsleq r4, r4, #3 <== 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 )
3000d0ec: e5950030 ldr r0, [r5, #48] ; 0x30 3000d0f0: e0040000 and r0, r4, 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 );
3000d0f4: e1500004 cmp r0, r4 3000d0f8: 13a00000 movne r0, #0 3000d0fc: 03a00001 moveq r0, #1
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
3000d100: e8bd8070 pop {r4, r5, r6, pc}
3000d39c <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d39c: e92d4071 push {r0, r4, r5, r6, lr}
IMFS_jnode_t *jnode = node->node_access;
3000d3a0: e5906000 ldr r6, [r0]
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d3a4: 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;
3000d3a8: e5963008 ldr r3, [r6, #8]
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d3ac: 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;
3000d3b0: e5803000 str r3, [r0]
rtems_filesystem_get_sym_start_loc(
3000d3b4: e5960050 ldr r0, [r6, #80] ; 0x50 3000d3b8: e1a0100d mov r1, sp 3000d3bc: e1a02004 mov r2, r4 3000d3c0: eb00034b bl 3000e0f4 <rtems_filesystem_get_sym_start_loc>
);
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
3000d3c4: e59d3000 ldr r3, [sp] 3000d3c8: e5966050 ldr r6, [r6, #80] ; 0x50 3000d3cc: e0866003 add r6, r6, r3 3000d3d0: e1a00006 mov r0, r6 3000d3d4: eb001324 bl 3001206c <strlen> 3000d3d8: e1a02005 mov r2, r5 3000d3dc: e1a01000 mov r1, r0 3000d3e0: e1a03004 mov r3, r4 3000d3e4: e1a00006 mov r0, r6 3000d3e8: ebffff58 bl 3000d150 <IMFS_eval_path> 3000d3ec: e1a06000 mov r6, r0
strlen( &jnode->info.sym_link.name[i] ),
flags,
node
);
IMFS_Set_handlers( node );
3000d3f0: e1a00004 mov r0, r4 3000d3f4: ebffff0b bl 3000d028 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
3000d3f8: e1a00004 mov r0, r4 3000d3fc: e1a01005 mov r1, r5 3000d400: ebffff25 bl 3000d09c <IMFS_evaluate_permission> 3000d404: e3500000 cmp r0, #0
3000d408: 1a000003 bne 3000d41c <IMFS_evaluate_sym_link+0x80>
rtems_set_errno_and_return_minus_one( EACCES );
3000d40c: eb000f2c bl 300110c4 <__errno> <== NOT EXECUTED 3000d410: e3a0300d mov r3, #13 <== NOT EXECUTED 3000d414: e5803000 str r3, [r0] <== NOT EXECUTED 3000d418: e3e06000 mvn r6, #0 <== NOT EXECUTED
return result;
}
3000d41c: e1a00006 mov r0, r6
3000d420: e8bd8078 pop {r3, r4, r5, r6, pc}
3001073c <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
3001073c: e92d4073 push {r0, r1, r4, r5, r6, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
30010740: e5904000 ldr r4, [r0] <== NOT EXECUTED
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
30010744: e1a06001 mov r6, r1 <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
30010748: ebfff53c bl 3000dc40 <geteuid> <== NOT EXECUTED
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
3001074c: e1d453bc ldrh r5, [r4, #60] ; 0x3c <== NOT EXECUTED 30010750: e3500000 cmp r0, #0 <== NOT EXECUTED 30010754: 11550000 cmpne r5, r0 <== NOT EXECUTED 30010758: 03a05000 moveq r5, #0 <== NOT EXECUTED 3001075c: 13a05001 movne r5, #1 <== NOT EXECUTED 30010760: 0a000004 beq 30010778 <IMFS_fchmod+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
30010764: eb000256 bl 300110c4 <__errno> <== NOT EXECUTED 30010768: e3a03001 mov r3, #1 <== NOT EXECUTED 3001076c: e5803000 str r3, [r0] <== NOT EXECUTED 30010770: e3e00000 mvn r0, #0 <== NOT EXECUTED 30010774: ea00000b b 300107a8 <IMFS_fchmod+0x6c> <== 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);
30010778: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
3001077c: e1a06a06 lsl r6, r6, #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);
30010780: e3c33eff bic r3, r3, #4080 ; 0xff0 <== NOT EXECUTED 30010784: e3c3300f bic r3, r3, #15 <== NOT EXECUTED
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
30010788: e1833a26 orr r3, r3, r6, lsr #20 <== NOT EXECUTED 3001078c: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
IMFS_update_ctime( jnode );
30010790: e1a0000d mov r0, sp <== NOT EXECUTED 30010794: e1a01005 mov r1, r5 <== NOT EXECUTED 30010798: ebffd6ea bl 30006348 <gettimeofday> <== NOT EXECUTED 3001079c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
300107a0: e1a00005 mov r0, r5 <== 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 );
300107a4: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
300107a8: e8bd807c pop {r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
300107ac <IMFS_fdatasync>:
int IMFS_fdatasync(
rtems_libio_t *iop
)
{
return 0;
}
300107ac: e3a00000 mov r0, #0 <== NOT EXECUTED 300107b0: e12fff1e bx lr <== NOT EXECUTED
30006e3c <IMFS_fifo_ioctl>:
void *buffer
)
{
int err;
if (command == FIONBIO) {
30006e3c: e59fc06c ldr ip, [pc, #108] ; 30006eb0 <IMFS_fifo_ioctl+0x74>
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30006e40: e92d4010 push {r4, lr}
int err;
if (command == FIONBIO) {
30006e44: e151000c cmp r1, ip
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30006e48: e1a03000 mov r3, r0
int err;
if (command == FIONBIO) {
30006e4c: 1a00000a bne 30006e7c <IMFS_fifo_ioctl+0x40>
if (buffer == NULL)
30006e50: e3520000 cmp r2, #0
30006e54: 0a00000e beq 30006e94 <IMFS_fifo_ioctl+0x58>
err = -EFAULT;
else {
if (*(int *)buffer)
30006e58: e5924000 ldr r4, [r2] 30006e5c: e5932014 ldr r2, [r3, #20] 30006e60: e3540000 cmp r4, #0
iop->flags |= LIBIO_FLAGS_NO_DELAY;
30006e64: 13822001 orrne r2, r2, #1
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
30006e68: 03c22001 biceq r2, r2, #1
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
30006e6c: 15832014 strne r2, [r3, #20]
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
return 0;
30006e70: 13a04000 movne r4, #0
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
30006e74: 05832014 streq r2, [r3, #20] 30006e78: ea00000a b 30006ea8 <IMFS_fifo_ioctl+0x6c>
return 0;
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
30006e7c: e5930018 ldr r0, [r3, #24] <== NOT EXECUTED 30006e80: e5900050 ldr r0, [r0, #80] ; 0x50 <== NOT EXECUTED 30006e84: eb0024d2 bl 300101d4 <pipe_ioctl> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30006e88: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30006e8c: aa000005 bge 30006ea8 <IMFS_fifo_ioctl+0x6c> <== NOT EXECUTED 30006e90: ea000000 b 30006e98 <IMFS_fifo_ioctl+0x5c> <== NOT EXECUTED
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
30006e94: e3e0400d mvn r4, #13 <== NOT EXECUTED
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
30006e98: eb0030f8 bl 30013280 <__errno> <== NOT EXECUTED 30006e9c: e2644000 rsb r4, r4, #0 <== NOT EXECUTED 30006ea0: e5804000 str r4, [r0] <== NOT EXECUTED 30006ea4: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
30006ea8: e1a00004 mov r0, r4
30006eac: e8bd8010 pop {r4, pc}
30006dec <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
30006dec: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
30006df0: e590c018 ldr ip, [r0, #24] <== NOT EXECUTED 30006df4: e58d0000 str r0, [sp] <== NOT EXECUTED 30006df8: e59c0050 ldr r0, [ip, #80] ; 0x50 <== NOT EXECUTED 30006dfc: eb00250d bl 30010238 <pipe_lseek> <== NOT EXECUTED 30006e00: e1a02000 mov r2, r0 <== NOT EXECUTED 30006e04: e1a03fc2 asr r3, r2, #31 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30006e08: 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);
30006e0c: e1a04000 mov r4, r0 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30006e10: a1a04003 movge r4, r3 <== NOT EXECUTED 30006e14: a1a03002 movge r3, r2 <== NOT EXECUTED 30006e18: aa000004 bge 30006e30 <IMFS_fifo_lseek+0x44> <== NOT EXECUTED 30006e1c: eb003117 bl 30013280 <__errno> <== NOT EXECUTED 30006e20: e2644000 rsb r4, r4, #0 <== NOT EXECUTED 30006e24: e5804000 str r4, [r0] <== NOT EXECUTED 30006e28: e3e03000 mvn r3, #0 <== NOT EXECUTED 30006e2c: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
30006e30: e1a00003 mov r0, r3 <== NOT EXECUTED
30006e34: e1a01004 mov r1, r4 <== NOT EXECUTED
30006e38: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
30006f94 <IMFS_fifo_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
30006f94: e1a01000 mov r1, r0
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = fifo_open(&JNODE2PIPE(jnode), iop);
30006f98: e5900018 ldr r0, [r0, #24]
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
30006f9c: e92d4010 push {r4, lr}
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = fifo_open(&JNODE2PIPE(jnode), iop);
30006fa0: e2800050 add r0, r0, #80 ; 0x50 30006fa4: eb0022c5 bl 3000fac0 <fifo_open>
IMFS_FIFO_RETURN(err);
30006fa8: e2504000 subs r4, r0, #0
30006fac: aa000003 bge 30006fc0 <IMFS_fifo_open+0x2c>
30006fb0: eb0030b2 bl 30013280 <__errno> <== NOT EXECUTED 30006fb4: e2644000 rsb r4, r4, #0 <== NOT EXECUTED 30006fb8: e5804000 str r4, [r0] <== NOT EXECUTED 30006fbc: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
30006fc0: e1a00004 mov r0, r4
30006fc4: e8bd8010 pop {r4, pc}
3000d720 <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
)
{
3000d720: 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;
3000d724: 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
)
{
3000d728: 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;
3000d72c: e5bc401c ldr r4, [ip, #28]!
loc = temp_mt_entry->mt_fs_root;
3000d730: 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
)
{
3000d734: 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;
3000d738: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000d73c: e8ae000f stmia lr!, {r0, r1, r2, r3}
3000d740: e59c3000 ldr r3, [ip]
3000d744: e58e3000 str r3, [lr]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
3000d748: e3a03000 mov r3, #0 3000d74c: e585301c str r3, [r5, #28]
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
3000d750: e1a0500d mov r5, sp 3000d754: e1a0000d mov r0, sp
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
3000d758: e5946008 ldr r6, [r4, #8]
loc.node_access = (void *)jnode;
3000d75c: e58d4000 str r4, [sp]
IMFS_Set_handlers( &loc );
3000d760: ebfffe30 bl 3000d028 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
3000d764: e594304c ldr r3, [r4, #76] ; 0x4c 3000d768: e3530001 cmp r3, #1
3000d76c: 1a000003 bne 3000d780 <IMFS_fsunmount+0x60>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
3000d770: 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 );
3000d774: e2843054 add r3, r4, #84 ; 0x54 3000d778: e1520003 cmp r2, r3
3000d77c: 1a000005 bne 3000d798 <IMFS_fsunmount+0x78>
result = IMFS_unlink( NULL, &loc );
3000d780: e3a00000 mov r0, #0 3000d784: e1a0100d mov r1, sp 3000d788: ebffe197 bl 30005dec <IMFS_unlink>
if (result != 0)
3000d78c: e3500000 cmp r0, #0
3000d790: 1a00000c bne 3000d7c8 <IMFS_fsunmount+0xa8>
return -1;
jnode = next;
3000d794: e1a04006 mov r4, r6
}
if ( jnode != NULL ) {
3000d798: e3540000 cmp r4, #0
3000d79c: 0a00000b beq 3000d7d0 <IMFS_fsunmount+0xb0>
if ( jnode->type == IMFS_DIRECTORY ) {
3000d7a0: e594304c ldr r3, [r4, #76] ; 0x4c 3000d7a4: e3530001 cmp r3, #1
3000d7a8: 1affffe9 bne 3000d754 <IMFS_fsunmount+0x34>
}
}
} while (jnode != NULL);
return 0;
}
3000d7ac: e5943050 ldr r3, [r4, #80] ; 0x50 3000d7b0: e2842054 add r2, r4, #84 ; 0x54
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
3000d7b4: e1530002 cmp r3, r2
3000d7b8: 0affffe5 beq 3000d754 <IMFS_fsunmount+0x34>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
3000d7bc: e2534000 subs r4, r3, #0
3000d7c0: 1affffe3 bne 3000d754 <IMFS_fsunmount+0x34>
3000d7c4: ea000001 b 3000d7d0 <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;
3000d7c8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000d7cc: ea000000 b 3000d7d4 <IMFS_fsunmount+0xb4> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
3000d7d0: e1a00004 mov r0, r4
}
3000d7d4: e28dd014 add sp, sp, #20
3000d7d8: e8bd8070 pop {r4, r5, r6, pc}
3000d85c <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
3000d85c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3000d860: e1a05001 mov r5, r1
3000d864: e1a04002 mov r4, r2
3000d868: e1a0a003 mov sl, r3
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
3000d86c: e5d07000 ldrb r7, [r0] 3000d870: e1a08000 mov r8, r0
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
3000d874: 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) ) {
3000d878: ea000004 b 3000d890 <IMFS_get_token+0x34>
token[i] = c;
if ( i == IMFS_NAME_MAX )
3000d87c: 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;
3000d880: e7c47006 strb r7, [r4, r6]
if ( i == IMFS_NAME_MAX )
3000d884: 0a000024 beq 3000d91c <IMFS_get_token+0xc0>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
3000d888: e5f87001 ldrb r7, [r8, #1]! 3000d88c: 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) ) {
3000d890: e1a00007 mov r0, r7 3000d894: ebffe60a bl 300070c4 <rtems_filesystem_is_separator> 3000d898: e3500000 cmp r0, #0
3000d89c: 1a000001 bne 3000d8a8 <IMFS_get_token+0x4c>
3000d8a0: e1560005 cmp r6, r5
3000d8a4: bafffff4 blt 3000d87c <IMFS_get_token+0x20>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
3000d8a8: e3560000 cmp r6, #0
3000d8ac: 1a000005 bne 3000d8c8 <IMFS_get_token+0x6c>
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
3000d8b0: e3570000 cmp r7, #0 3000d8b4: 13550000 cmpne r5, #0
i++;
type = IMFS_CURRENT_DIR;
3000d8b8: 13a06001 movne r6, #1
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
token[i] = c;
3000d8bc: e5c47000 strb r7, [r4]
if ( (token[i] != '\0') && pathlen ) {
i++;
3000d8c0: e1a00006 mov r0, r6 3000d8c4: ea000005 b 3000d8e0 <IMFS_get_token+0x84>
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
3000d8c8: e0843006 add r3, r4, r6 3000d8cc: e5533001 ldrb r3, [r3, #-1]
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
3000d8d0: e3a00003 mov r0, #3
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
3000d8d4: e3530000 cmp r3, #0
token[i] = '\0';
3000d8d8: 13a03000 movne r3, #0 3000d8dc: 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 ) {
3000d8e0: e3500003 cmp r0, #3
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
3000d8e4: e58a6000 str r6, [sl]
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
3000d8e8: 18bd85f0 popne {r4, r5, r6, r7, r8, sl, pc}
if ( strcmp( token, "..") == 0 )
3000d8ec: e1a00004 mov r0, r4 3000d8f0: e59f1034 ldr r1, [pc, #52] ; 3000d92c <IMFS_get_token+0xd0> 3000d8f4: eb001100 bl 30011cfc <strcmp> 3000d8f8: e3500000 cmp r0, #0
3000d8fc: 0a000008 beq 3000d924 <IMFS_get_token+0xc8>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
3000d900: e1a00004 mov r0, r4 3000d904: e59f1024 ldr r1, [pc, #36] ; 3000d930 <IMFS_get_token+0xd4> 3000d908: eb0010fb bl 30011cfc <strcmp>
type = IMFS_CURRENT_DIR;
3000d90c: e3500000 cmp r0, #0
3000d910: 13a00003 movne r0, #3
3000d914: 03a00001 moveq r0, #1
3000d918: 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;
3000d91c: e3a00004 mov r0, #4 <== NOT EXECUTED
3000d920: 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;
3000d924: e3a00002 mov r0, #2
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
3000d928: 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: eb001d59 bl 3000cfe8 <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: eb002d7c bl 300110c4 <__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: eb002d5e bl 300110c4 <__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: eb003144 bl 3001206c <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: eb001f3a bl 3000d85c <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: eb001cc6 bl 3000cea8 <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: eb002d4a bl 300110c4 <__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
3000fdf4 <IMFS_memfile_extend>:
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
3000fdf4: e59f3110 ldr r3, [pc, #272] ; 3000ff0c <IMFS_memfile_extend+0x118>
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
3000fdf8: 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 )
3000fdfc: e593b000 ldr fp, [r3]
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
3000fe00: 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 )
3000fe04: e1a0312b lsr r3, fp, #2 3000fe08: e2832001 add r2, r3, #1 3000fe0c: e0020293 mul r2, r3, r2 3000fe10: e2822001 add r2, r2, #1 3000fe14: e0030392 mul r3, r2, r3 3000fe18: e3a02000 mov r2, #0 3000fe1c: e2433001 sub r3, r3, #1 3000fe20: e1520005 cmp r2, r5
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
3000fe24: e1a04000 mov r4, r0 3000fe28: 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 )
3000fe2c: e003039b mul r3, fp, r3
3000fe30: ca000005 bgt 3000fe4c <IMFS_memfile_extend+0x58> 3000fe34: 1a000001 bne 3000fe40 <IMFS_memfile_extend+0x4c>
3000fe38: e1530001 cmp r3, r1
3000fe3c: 8a000002 bhi 3000fe4c <IMFS_memfile_extend+0x58>
rtems_set_errno_and_return_minus_one( EINVAL );
3000fe40: eb00049f bl 300110c4 <__errno> <== NOT EXECUTED 3000fe44: e3a03016 mov r3, #22 <== NOT EXECUTED 3000fe48: ea000025 b 3000fee4 <IMFS_memfile_extend+0xf0> <== NOT EXECUTED
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
3000fe4c: e5948054 ldr r8, [r4, #84] ; 0x54 3000fe50: e5947050 ldr r7, [r4, #80] ; 0x50 3000fe54: e1550008 cmp r5, r8
3000fe58: ca000002 bgt 3000fe68 <IMFS_memfile_extend+0x74> 3000fe5c: 1a000028 bne 3000ff04 <IMFS_memfile_extend+0x110>
3000fe60: e1560007 cmp r6, r7
3000fe64: 9a000026 bls 3000ff04 <IMFS_memfile_extend+0x110>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000fe68: e1a0cfcb asr ip, fp, #31 3000fe6c: e1a0300c mov r3, ip 3000fe70: e1a0200b mov r2, fp 3000fe74: e1a00006 mov r0, r6 3000fe78: e1a01005 mov r1, r5 3000fe7c: e58dc000 str ip, [sp] 3000fe80: eb00154a bl 300153b0 <__divdi3>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000fe84: e59dc000 ldr ip, [sp] 3000fe88: e1a01008 mov r1, r8
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000fe8c: e1a0a000 mov sl, r0
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000fe90: e1a0200b mov r2, fp 3000fe94: e1a00007 mov r0, r7 3000fe98: e1a0300c mov r3, ip 3000fe9c: eb001543 bl 300153b0 <__divdi3> 3000fea0: e1a08000 mov r8, r0
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
3000fea4: e1a07000 mov r7, r0 3000fea8: ea000011 b 3000fef4 <IMFS_memfile_extend+0x100>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
3000feac: e1a00004 mov r0, r4 3000feb0: e1a01007 mov r1, r7 3000feb4: ebffff57 bl 3000fc18 <IMFS_memfile_addblock> 3000feb8: e3500000 cmp r0, #0
3000febc: 0a00000b beq 3000fef0 <IMFS_memfile_extend+0xfc>
3000fec0: ea000003 b 3000fed4 <IMFS_memfile_extend+0xe0> <== NOT EXECUTED
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
3000fec4: e1a01007 mov r1, r7 <== NOT EXECUTED 3000fec8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000fecc: ebffffbe bl 3000fdcc <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-- ) {
3000fed0: e2477001 sub r7, r7, #1 <== NOT EXECUTED 3000fed4: e1570008 cmp r7, r8 <== NOT EXECUTED 3000fed8: 2afffff9 bcs 3000fec4 <IMFS_memfile_extend+0xd0> <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
3000fedc: eb000478 bl 300110c4 <__errno> <== NOT EXECUTED 3000fee0: e3a0301c mov r3, #28 <== NOT EXECUTED 3000fee4: e5803000 str r3, [r0] <== NOT EXECUTED 3000fee8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000feec: ea000005 b 3000ff08 <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++ ) {
3000fef0: e2877001 add r7, r7, #1 3000fef4: e157000a cmp r7, sl
3000fef8: 9affffeb bls 3000feac <IMFS_memfile_extend+0xb8>
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
3000fefc: e5846050 str r6, [r4, #80] ; 0x50 3000ff00: 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;
3000ff04: e3a00000 mov r0, #0
/* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; }
3000ff08: e8bd8df8 pop {r3, r4, r5, r6, r7, r8, sl, fp, pc}
3000f828 <IMFS_memfile_get_block_pointer>:
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000f828: e59f31e4 ldr r3, [pc, #484] ; 3000fa14 <IMFS_memfile_get_block_pointer+0x1ec>
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000f82c: 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 ) {
3000f830: e5935000 ldr r5, [r3]
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000f834: e1a04000 mov r4, r0
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000f838: e1a05125 lsr r5, r5, #2 3000f83c: e2453001 sub r3, r5, #1 3000f840: e1510003 cmp r1, r3
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000f844: e1a06001 mov r6, r1 3000f848: e1a08002 mov r8, r2
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000f84c: 8a00000e bhi 3000f88c <IMFS_memfile_get_block_pointer+0x64>
p = info->indirect;
if ( malloc_it ) {
3000f850: e3520000 cmp r2, #0
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
3000f854: e5900058 ldr r0, [r0, #88] ; 0x58
if ( malloc_it ) {
3000f858: 0a000007 beq 3000f87c <IMFS_memfile_get_block_pointer+0x54>
if ( !p ) {
3000f85c: e3500000 cmp r0, #0
3000f860: 1a000003 bne 3000f874 <IMFS_memfile_get_block_pointer+0x4c>
p = memfile_alloc_block();
3000f864: ebffffe2 bl 3000f7f4 <memfile_alloc_block>
if ( !p )
3000f868: e3500000 cmp r0, #0
3000f86c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
info->indirect = p;
3000f870: e5840058 str r0, [r4, #88] ; 0x58
}
return &info->indirect[ my_block ];
3000f874: e5940058 ldr r0, [r4, #88] ; 0x58 3000f878: ea000001 b 3000f884 <IMFS_memfile_get_block_pointer+0x5c>
}
if ( !p )
3000f87c: e3500000 cmp r0, #0
3000f880: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
return &info->indirect[ my_block ];
3000f884: e0800106 add r0, r0, r6, lsl #2
3000f888: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
3000f88c: e2853001 add r3, r5, #1 3000f890: e0030395 mul r3, r5, r3 3000f894: e2432001 sub r2, r3, #1 3000f898: e1510002 cmp r1, r2
3000f89c: 8a000021 bhi 3000f928 <IMFS_memfile_get_block_pointer+0x100>
my_block -= FIRST_DOUBLY_INDIRECT;
3000f8a0: e0656001 rsb r6, r5, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000f8a4: e1a00006 mov r0, r6 3000f8a8: e1a01005 mov r1, r5 3000f8ac: eb00145f bl 30014a30 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000f8b0: e1a01005 mov r1, r5
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000f8b4: e1a07000 mov r7, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000f8b8: e1a00006 mov r0, r6 3000f8bc: eb0013c3 bl 300147d0 <__aeabi_uidiv>
p = info->doubly_indirect;
if ( malloc_it ) {
3000f8c0: 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;
3000f8c4: e1a05000 mov r5, r0
p = info->doubly_indirect;
3000f8c8: e594005c ldr r0, [r4, #92] ; 0x5c
if ( malloc_it ) {
3000f8cc: 0a00000e beq 3000f90c <IMFS_memfile_get_block_pointer+0xe4>
if ( !p ) {
3000f8d0: e3500000 cmp r0, #0
3000f8d4: 1a000003 bne 3000f8e8 <IMFS_memfile_get_block_pointer+0xc0>
p = memfile_alloc_block();
3000f8d8: ebffffc5 bl 3000f7f4 <memfile_alloc_block>
if ( !p )
3000f8dc: e3500000 cmp r0, #0
3000f8e0: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
info->doubly_indirect = p;
3000f8e4: e584005c str r0, [r4, #92] ; 0x5c
}
p1 = (block_p *)p[ doubly ];
3000f8e8: e0804105 add r4, r0, r5, lsl #2 3000f8ec: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !p1 ) {
3000f8f0: e3500000 cmp r0, #0
3000f8f4: 1a000009 bne 3000f920 <IMFS_memfile_get_block_pointer+0xf8>
p1 = memfile_alloc_block();
3000f8f8: ebffffbd bl 3000f7f4 <memfile_alloc_block>
if ( !p1 )
3000f8fc: e3500000 cmp r0, #0
return 0;
p[ doubly ] = (block_p) p1;
3000f900: 15840000 strne r0, [r4]
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
3000f904: 1a000005 bne 3000f920 <IMFS_memfile_get_block_pointer+0xf8>
3000f908: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
return (block_p *)&p1[ singly ];
}
if ( !p )
3000f90c: e3500000 cmp r0, #0
3000f910: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
p = (block_p *)p[ doubly ];
3000f914: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !p )
3000f918: e3500000 cmp r0, #0
3000f91c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
return (block_p *)&p[ singly ];
3000f920: e0800107 add r0, r0, r7, lsl #2
3000f924: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
3000f928: e2832001 add r2, r3, #1 <== NOT EXECUTED 3000f92c: e0020295 mul r2, r5, r2 <== NOT EXECUTED 3000f930: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000f934: e1510002 cmp r1, r2 <== NOT EXECUTED 3000f938: 8a000033 bhi 3000fa0c <IMFS_memfile_get_block_pointer+0x1e4><== NOT EXECUTED
my_block -= FIRST_TRIPLY_INDIRECT;
3000f93c: e0636001 rsb r6, r3, r1 <== NOT EXECUTED
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000f940: e1a00006 mov r0, r6 <== NOT EXECUTED 3000f944: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f948: eb001438 bl 30014a30 <__umodsi3> <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000f94c: 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;
3000f950: e1a0a000 mov sl, r0 <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000f954: e1a00006 mov r0, r6 <== NOT EXECUTED 3000f958: eb00139c bl 300147d0 <__aeabi_uidiv> <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
3000f95c: 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;
3000f960: e1a06000 mov r6, r0 <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
3000f964: eb001399 bl 300147d0 <__aeabi_uidiv> <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
3000f968: 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;
3000f96c: e1a07000 mov r7, r0 <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
3000f970: e1a00006 mov r0, r6 <== NOT EXECUTED 3000f974: eb00142d bl 30014a30 <__umodsi3> <== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
3000f978: 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;
3000f97c: e1a05000 mov r5, r0 <== NOT EXECUTED
p = info->triply_indirect;
3000f980: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED
if ( malloc_it ) {
3000f984: 0a000016 beq 3000f9e4 <IMFS_memfile_get_block_pointer+0x1bc><== NOT EXECUTED
if ( !p ) {
3000f988: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f98c: 1a000003 bne 3000f9a0 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
p = memfile_alloc_block();
3000f990: ebffff97 bl 3000f7f4 <memfile_alloc_block> <== NOT EXECUTED
if ( !p )
3000f994: e3500000 cmp r0, #0 <== NOT EXECUTED
3000f998: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return 0;
info->triply_indirect = p;
3000f99c: e5840060 str r0, [r4, #96] ; 0x60 <== NOT EXECUTED
}
p1 = (block_p *) p[ triply ];
3000f9a0: e0804107 add r4, r0, r7, lsl #2 <== NOT EXECUTED 3000f9a4: e7900107 ldr r0, [r0, r7, lsl #2] <== NOT EXECUTED
if ( !p1 ) {
3000f9a8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f9ac: 1a000003 bne 3000f9c0 <IMFS_memfile_get_block_pointer+0x198><== NOT EXECUTED
p1 = memfile_alloc_block();
3000f9b0: ebffff8f bl 3000f7f4 <memfile_alloc_block> <== NOT EXECUTED
if ( !p1 )
3000f9b4: e3500000 cmp r0, #0 <== NOT EXECUTED
3000f9b8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return 0;
p[ triply ] = (block_p) p1;
3000f9bc: e5840000 str r0, [r4] <== NOT EXECUTED
}
p2 = (block_p *)p1[ doubly ];
3000f9c0: e0804105 add r4, r0, r5, lsl #2 <== NOT EXECUTED 3000f9c4: e7900105 ldr r0, [r0, r5, lsl #2] <== NOT EXECUTED
if ( !p2 ) {
3000f9c8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f9cc: 1a00000c bne 3000fa04 <IMFS_memfile_get_block_pointer+0x1dc><== NOT EXECUTED
p2 = memfile_alloc_block();
3000f9d0: ebffff87 bl 3000f7f4 <memfile_alloc_block> <== NOT EXECUTED
if ( !p2 )
3000f9d4: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
p1[ doubly ] = (block_p) p2;
3000f9d8: 15840000 strne r0, [r4] <== NOT EXECUTED
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
3000f9dc: 1a000008 bne 3000fa04 <IMFS_memfile_get_block_pointer+0x1dc><== NOT EXECUTED
3000f9e0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
3000f9e4: e3500000 cmp r0, #0 <== NOT EXECUTED
3000f9e8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return 0;
p1 = (block_p *) p[ triply ];
3000f9ec: e7900107 ldr r0, [r0, r7, lsl #2] <== NOT EXECUTED
if ( !p1 )
3000f9f0: e3500000 cmp r0, #0 <== NOT EXECUTED
3000f9f4: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return 0;
p2 = (block_p *)p1[ doubly ];
3000f9f8: e7900105 ldr r0, [r0, r5, lsl #2] <== NOT EXECUTED
if ( !p2 )
3000f9fc: e3500000 cmp r0, #0 <== NOT EXECUTED
3000fa00: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return 0;
return (block_p *)&p2[ singly ];
3000fa04: e080010a add r0, r0, sl, lsl #2 <== NOT EXECUTED
3000fa08: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
/*
* This means the requested block number is out of range.
*/
return 0;
3000fa0c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000fa10: 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
3000fcc0 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
3000fcc0: 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;
3000fcc4: e59f30fc ldr r3, [pc, #252] ; 3000fdc8 <IMFS_memfile_remove+0x108>
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
3000fcc8: 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;
3000fccc: e5935000 ldr r5, [r3]
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
3000fcd0: 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;
3000fcd4: e1a05125 lsr r5, r5, #2
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
3000fcd8: e3530000 cmp r3, #0
memfile_free_blocks_in_table( &info->indirect, to_free );
3000fcdc: 12800058 addne r0, r0, #88 ; 0x58 3000fce0: 11a01005 movne r1, r5 3000fce4: 1bffffe1 blne 3000fc70 <memfile_free_blocks_in_table>
}
if ( info->doubly_indirect ) {
3000fce8: e594305c ldr r3, [r4, #92] ; 0x5c 3000fcec: e3530000 cmp r3, #0 3000fcf0: 13a06000 movne r6, #0
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
3000fcf4: 159f70cc ldrne r7, [pc, #204] ; 3000fdc8 <IMFS_memfile_remove+0x108>
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
3000fcf8: 1a000008 bne 3000fd20 <IMFS_memfile_remove+0x60>
3000fcfc: ea00000d b 3000fd38 <IMFS_memfile_remove+0x78>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
3000fd00: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED 3000fd04: e1a00106 lsl r0, r6, #2 <== NOT EXECUTED 3000fd08: e7932106 ldr r2, [r3, r6, lsl #2] <== NOT EXECUTED 3000fd0c: e3520000 cmp r2, #0 <== NOT EXECUTED
memfile_free_blocks_in_table(
3000fd10: 10830000 addne r0, r3, r0 <== NOT EXECUTED 3000fd14: 11a01005 movne r1, r5 <== NOT EXECUTED 3000fd18: 1bffffd4 blne 3000fc70 <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++ ) {
3000fd1c: e2866001 add r6, r6, #1 <== NOT EXECUTED 3000fd20: e5973000 ldr r3, [r7] <== NOT EXECUTED 3000fd24: e1560123 cmp r6, r3, lsr #2 <== NOT EXECUTED 3000fd28: 3afffff4 bcc 3000fd00 <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 );
3000fd2c: e284005c add r0, r4, #92 ; 0x5c <== NOT EXECUTED 3000fd30: e1a01005 mov r1, r5 <== NOT EXECUTED 3000fd34: ebffffcd bl 3000fc70 <memfile_free_blocks_in_table> <== NOT EXECUTED
}
if ( info->triply_indirect ) {
3000fd38: e5943060 ldr r3, [r4, #96] ; 0x60 3000fd3c: e3530000 cmp r3, #0 3000fd40: 13a06000 movne r6, #0
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
3000fd44: 159fa07c ldrne sl, [pc, #124] ; 3000fdc8 <IMFS_memfile_remove+0x108>
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
3000fd48: 1a000016 bne 3000fda8 <IMFS_memfile_remove+0xe8>
3000fd4c: ea00001b b 3000fdc0 <IMFS_memfile_remove+0x100>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
3000fd50: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
3000fd54: e1a09106 lsl r9, r6, #2 <== NOT EXECUTED
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
3000fd58: e7938106 ldr r8, [r3, r6, lsl #2] <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
3000fd5c: e3580000 cmp r8, #0 <== NOT EXECUTED 3000fd60: 0a000013 beq 3000fdb4 <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(
3000fd64: e2488004 sub r8, r8, #4 <== NOT EXECUTED 3000fd68: e3a07000 mov r7, #0 <== NOT EXECUTED 3000fd6c: ea000005 b 3000fd88 <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] ) {
3000fd70: e5b83004 ldr r3, [r8, #4]! <== NOT EXECUTED 3000fd74: e3530000 cmp r3, #0 <== NOT EXECUTED
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
3000fd78: 11a00008 movne r0, r8 <== NOT EXECUTED 3000fd7c: 11a01005 movne r1, r5 <== NOT EXECUTED 3000fd80: 1bffffba blne 3000fc70 <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++ ) {
3000fd84: e2877001 add r7, r7, #1 <== NOT EXECUTED 3000fd88: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3000fd8c: e1570123 cmp r7, r3, lsr #2 <== NOT EXECUTED 3000fd90: 3afffff6 bcc 3000fd70 <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(
3000fd94: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 3000fd98: e1a01005 mov r1, r5 <== NOT EXECUTED 3000fd9c: e0800009 add r0, r0, r9 <== NOT EXECUTED 3000fda0: ebffffb2 bl 3000fc70 <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++ ) {
3000fda4: e2866001 add r6, r6, #1 <== NOT EXECUTED 3000fda8: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3000fdac: e1560123 cmp r6, r3, lsr #2 <== NOT EXECUTED 3000fdb0: 3affffe6 bcc 3000fd50 <IMFS_memfile_remove+0x90> <== NOT EXECUTED
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
3000fdb4: e2840060 add r0, r4, #96 ; 0x60 <== NOT EXECUTED 3000fdb8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000fdbc: ebffffab bl 3000fc70 <memfile_free_blocks_in_table> <== NOT EXECUTED
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
3000fdc0: e3a00000 mov r0, #0
3000fdc4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
3000fdcc <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
3000fdcc: 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 );
3000fdd0: e3a02000 mov r2, #0 <== NOT EXECUTED 3000fdd4: ebfffe93 bl 3000f828 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
*block_ptr = 0;
3000fdd8: e3a02000 mov r2, #0 <== NOT EXECUTED
)
{
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3000fddc: e1a03000 mov r3, r0 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
3000fde0: e5900000 ldr r0, [r0] <== NOT EXECUTED
*block_ptr = 0;
3000fde4: e5832000 str r2, [r3] <== NOT EXECUTED
memfile_free_block( ptr );
3000fde8: ebffff98 bl 3000fc50 <memfile_free_block> <== NOT EXECUTED
return 1;
}
3000fdec: e3a00001 mov r0, #1 <== NOT EXECUTED
3000fdf0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ff10 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
3000ff10: e92d4ff7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000ff14: 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 ) {
3000ff18: e5903054 ldr r3, [r0, #84] ; 0x54
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
3000ff1c: 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 ) {
3000ff20: e3530000 cmp r3, #0
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
3000ff24: e1a07001 mov r7, r1 3000ff28: e1a04000 mov r4, r0 3000ff2c: 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;
3000ff30: e0881001 add r1, r8, r1
if ( last_byte > the_jnode->info.file.size ) {
3000ff34: ba000003 blt 3000ff48 <IMFS_memfile_write+0x38>
3000ff38: 1a00000c bne 3000ff70 <IMFS_memfile_write+0x60>
3000ff3c: e5903050 ldr r3, [r0, #80] ; 0x50 3000ff40: e1530001 cmp r3, r1
3000ff44: 2a000009 bcs 3000ff70 <IMFS_memfile_write+0x60>
status = IMFS_memfile_extend( the_jnode, last_byte );
3000ff48: e1a00004 mov r0, r4 3000ff4c: e3a02000 mov r2, #0 3000ff50: ebffffa7 bl 3000fdf4 <IMFS_memfile_extend>
if ( status )
3000ff54: e3500000 cmp r0, #0
3000ff58: 0a000004 beq 3000ff70 <IMFS_memfile_write+0x60>
rtems_set_errno_and_return_minus_one( ENOSPC );
3000ff5c: eb000458 bl 300110c4 <__errno> <== NOT EXECUTED 3000ff60: e3a0301c mov r3, #28 <== NOT EXECUTED 3000ff64: e5803000 str r3, [r0] <== NOT EXECUTED 3000ff68: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000ff6c: ea00004d b 300100a8 <IMFS_memfile_write+0x198> <== NOT EXECUTED
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
3000ff70: e59f3138 ldr r3, [pc, #312] ; 300100b0 <IMFS_memfile_write+0x1a0> 3000ff74: e1a00007 mov r0, r7 3000ff78: e5939000 ldr r9, [r3] 3000ff7c: e1a0100a mov r1, sl 3000ff80: e1a0b009 mov fp, r9 3000ff84: e1a0cfcb asr ip, fp, #31 3000ff88: e1a0300c mov r3, ip 3000ff8c: e1a0200b mov r2, fp 3000ff90: e58dc000 str ip, [sp] 3000ff94: eb001632 bl 30015864 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000ff98: e59dc000 ldr ip, [sp]
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
3000ff9c: e1a05000 mov r5, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000ffa0: e1a0100a mov r1, sl 3000ffa4: e1a00007 mov r0, r7 3000ffa8: e1a0200b mov r2, fp 3000ffac: e1a0300c mov r3, ip 3000ffb0: eb0014fe bl 300153b0 <__divdi3>
if ( start_offset ) {
3000ffb4: 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;
3000ffb8: e1a07000 mov r7, r0
if ( start_offset ) {
3000ffbc: 0a000012 beq 3001000c <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 );
3000ffc0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ffc4: e1a01007 mov r1, r7 <== NOT EXECUTED 3000ffc8: e3a02000 mov r2, #0 <== NOT EXECUTED 3000ffcc: ebfffe15 bl 3000f828 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
if ( !block_ptr )
3000ffd0: e3500000 cmp r0, #0 <== NOT EXECUTED
return copied;
3000ffd4: 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 )
3000ffd8: 0a000032 beq 300100a8 <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;
3000ffdc: e065a009 rsb sl, r5, r9 <== NOT EXECUTED
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
3000ffe0: 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;
3000ffe4: e15a0008 cmp sl, r8 <== NOT EXECUTED 3000ffe8: 21a0a008 movcs sl, r8 <== NOT EXECUTED
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
3000ffec: e0800005 add r0, r0, r5 <== NOT EXECUTED 3000fff0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000fff4: e1a0200a mov r2, sl <== NOT EXECUTED 3000fff8: eb00065f bl 3001197c <memcpy> <== NOT EXECUTED
src += to_copy;
3000fffc: e086600a add r6, r6, sl <== NOT EXECUTED
block++;
30010000: e2877001 add r7, r7, #1 <== NOT EXECUTED
my_length -= to_copy;
30010004: e06a8008 rsb r8, sl, r8 <== NOT EXECUTED
copied += to_copy;
30010008: e1a0500a mov r5, sl <== NOT EXECUTED
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
3001000c: e59f909c ldr r9, [pc, #156] ; 300100b0 <IMFS_memfile_write+0x1a0> 30010010: e599a000 ldr sl, [r9]
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
30010014: ea00000d b 30010050 <IMFS_memfile_write+0x140>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
30010018: e1a00004 mov r0, r4 3001001c: e1a01007 mov r1, r7 30010020: e3a02000 mov r2, #0 30010024: ebfffdff bl 3000f828 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
30010028: e3500000 cmp r0, #0
3001002c: 0a00001d beq 300100a8 <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 );
30010030: e1a01006 mov r1, r6 30010034: e5900000 ldr r0, [r0] 30010038: e1a0200a mov r2, sl 3001003c: eb00064e bl 3001197c <memcpy>
src += to_copy;
30010040: e086600a add r6, r6, sl
block++;
30010044: e2877001 add r7, r7, #1
my_length -= to_copy;
30010048: 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(
3001004c: 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 ) {
30010050: e5993000 ldr r3, [r9] 30010054: e1580003 cmp r8, r3
30010058: 2affffee bcs 30010018 <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 ) {
3001005c: e3580000 cmp r8, #0
30010060: 0a00000a beq 30010090 <IMFS_memfile_write+0x180>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
30010064: e1a00004 mov r0, r4 30010068: e1a01007 mov r1, r7 3001006c: e3a02000 mov r2, #0 30010070: ebfffdec bl 3000f828 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
30010074: e3500000 cmp r0, #0
30010078: 0a00000a beq 300100a8 <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 );
3001007c: e5900000 ldr r0, [r0] 30010080: e1a01006 mov r1, r6 30010084: e1a02008 mov r2, r8 30010088: eb00063b bl 3001197c <memcpy>
my_length = 0;
copied += to_copy;
3001008c: e0855008 add r5, r5, r8
}
IMFS_mtime_ctime_update( the_jnode );
30010090: e28d0004 add r0, sp, #4 30010094: e3a01000 mov r1, #0 30010098: ebffd8aa bl 30006348 <gettimeofday> 3001009c: e59d3004 ldr r3, [sp, #4] 300100a0: e5843044 str r3, [r4, #68] ; 0x44 300100a4: e5843048 str r3, [r4, #72] ; 0x48
return copied;
}
300100a8: e1a00005 mov r0, r5
300100ac: 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: eb002d07 bl 300110c4 <__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: eb00347e bl 3001582c <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: eb003439 bl 30015758 <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: eb00340c bl 300156d8 <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: eb003406 bl 300156d8 <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: ea003452 b 3001582c <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: ea0033f8 b 300156d8 <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: ea003b24 b 30017394 <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: eb0030ec bl 300120cc <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: 1b001041 blne 30009e30 <_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: eb001031 bl 30009e04 <_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
3000da04 <IMFS_stat>:
{
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
3000da04: e5903000 ldr r3, [r0]
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
3000da08: e92d4800 push {fp, lr}
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
3000da0c: e593204c ldr r2, [r3, #76] ; 0x4c 3000da10: e2422002 sub r2, r2, #2 3000da14: e3520005 cmp r2, #5 3000da18: 979ff102 ldrls pc, [pc, r2, lsl #2]
3000da1c: ea000012 b 3000da6c <IMFS_stat+0x68> <== NOT EXECUTED 3000da20: 3000da38 .word 0x3000da38 <== NOT EXECUTED 3000da24: 3000da6c .word 0x3000da6c <== NOT EXECUTED 3000da28: 3000da58 .word 0x3000da58 <== NOT EXECUTED 3000da2c: 3000da4c .word 0x3000da4c <== NOT EXECUTED 3000da30: 3000da4c .word 0x3000da4c <== NOT EXECUTED 3000da34: 3000da58 .word 0x3000da58 <== NOT EXECUTED
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
3000da38: e5932054 ldr r2, [r3, #84] ; 0x54
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
3000da3c: e593c050 ldr ip, [r3, #80] ; 0x50 3000da40: e581201c str r2, [r1, #28] 3000da44: e581c018 str ip, [r1, #24]
break;
3000da48: ea00000c b 3000da80 <IMFS_stat+0x7c>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
3000da4c: e283c050 add ip, r3, #80 ; 0x50
3000da50: e89c1800 ldm ip, {fp, ip}
3000da54: ea000001 b 3000da60 <IMFS_stat+0x5c>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
3000da58: e3a0b000 mov fp, #0 <== NOT EXECUTED 3000da5c: e3a0c000 mov ip, #0 <== NOT EXECUTED
3000da60: e581b020 str fp, [r1, #32] 3000da64: e581c024 str ip, [r1, #36] ; 0x24
break;
3000da68: ea000004 b 3000da80 <IMFS_stat+0x7c>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000da6c: eb000d94 bl 300110c4 <__errno> <== NOT EXECUTED
3000da70: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
3000da74: e5803000 str r3, [r0] <== NOT EXECUTED
3000da78: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000da7c: 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;
3000da80: e5902010 ldr r2, [r0, #16] 3000da84: e59f0050 ldr r0, [pc, #80] ; 3000dadc <IMFS_stat+0xd8>
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
3000da88: e5922034 ldr r2, [r2, #52] ; 0x34 3000da8c: 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 =
3000da90: e8810005 stm r1, {r0, r2}
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
3000da94: 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;
3000da98: 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;
3000da9c: e581200c str r2, [r1, #12]
buf->st_nlink = the_jnode->st_nlink;
3000daa0: e1d323b4 ldrh r2, [r3, #52] ; 0x34 3000daa4: e1c121b0 strh r2, [r1, #16]
buf->st_ino = the_jnode->st_ino;
3000daa8: e5932038 ldr r2, [r3, #56] ; 0x38 3000daac: e5812008 str r2, [r1, #8]
buf->st_uid = the_jnode->st_uid;
3000dab0: e1d323bc ldrh r2, [r3, #60] ; 0x3c 3000dab4: e1c121b2 strh r2, [r1, #18]
buf->st_gid = the_jnode->st_gid;
3000dab8: e1d323be ldrh r2, [r3, #62] ; 0x3e 3000dabc: e1c121b4 strh r2, [r1, #20]
buf->st_atime = the_jnode->stat_atime;
3000dac0: e5932040 ldr r2, [r3, #64] ; 0x40 3000dac4: e5812028 str r2, [r1, #40] ; 0x28
buf->st_mtime = the_jnode->stat_mtime;
3000dac8: e5932044 ldr r2, [r3, #68] ; 0x44
buf->st_ctime = the_jnode->stat_ctime;
3000dacc: 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;
3000dad0: e5812030 str r2, [r1, #48] ; 0x30
buf->st_ctime = the_jnode->stat_ctime;
3000dad4: e5813038 str r3, [r1, #56] ; 0x38
return 0;
}
3000dad8: 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: eb0030bd bl 3001206c <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: eb001eb3 bl 3000d85c <IMFS_get_token>
/*
* Duplicate link name
*/
info.sym_link.name = strdup(link_name);
30005d8c: e1a00006 mov r0, r6 30005d90: eb0030a1 bl 3001201c <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: eb001c3a bl 3000cea8 <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: eb002cbb bl 300110c4 <__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: eb002ca9 bl 300110c4 <__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: eb001c75 bl 3000d028 <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: eb002c79 bl 300110c4 <__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: eb002c73 bl 300110c4 <__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: eb0030a3 bl 300121b8 <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: 1b002d38 blne 30011a58 <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: eb000fc0 bl 3000a4a0 <_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: 0b000d58 bleq 30009b0c <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: eb001248 bl 3000aee0 <_Protected_heap_Get_size> 300065bc: e0800005 add r0, r0, r5 300065c0: e5840000 str r0, [r4]
}
300065c4: e8bd8070 pop {r4, r5, r6, pc}
300061d8 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
300061d8: 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);
300061dc: e59030bc ldr r3, [r0, #188] ; 0xbc <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
300061e0: e59070b8 ldr r7, [r0, #184] ; 0xb8 <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
300061e4: e2832010 add r2, r3, #16 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
300061e8: 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++)
300061ec: e3c71003 bic r1, r7, #3 <== NOT EXECUTED
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
300061f0: 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 );
300061f4: e590b0e8 ldr fp, [r0, #232] ; 0xe8 <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
300061f8: e2820010 add r0, r2, #16 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
300061fc: 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(
30006200: e2833020 add r3, r3, #32 <== NOT EXECUTED
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
30006204: e59f10c0 ldr r1, [pc, #192] ; 300062cc <Stack_check_Dump_threads_usage+0xf4><== NOT EXECUTED 30006208: ea000002 b 30006218 <Stack_check_Dump_threads_usage+0x40> <== NOT EXECUTED 3000620c: e493c004 ldr ip, [r3], #4 <== NOT EXECUTED 30006210: e15c0001 cmp ip, r1 <== NOT EXECUTED 30006214: 1a000004 bne 3000622c <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++)
30006218: e1530000 cmp r3, r0 <== NOT EXECUTED
if (*base != U32_PATTERN)
3000621c: 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++)
30006220: 3afffff9 bcc 3000620c <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;
30006224: e3a06000 mov r6, #0 <== NOT EXECUTED 30006228: ea000002 b 30006238 <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 )
3000622c: e3560000 cmp r6, #0 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
30006230: 10822007 addne r2, r2, r7 <== NOT EXECUTED 30006234: 10666002 rsbne r6, r6, r2 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
#endif
{
(*print_handler)(
30006238: e5958008 ldr r8, [r5, #8] <== NOT EXECUTED
3000623c: e59f408c ldr r4, [pc, #140] ; 300062d0 <Stack_check_Dump_threads_usage+0xf8><== NOT EXECUTED
30006240: e3a01005 mov r1, #5 <== NOT EXECUTED
30006244: e28d2008 add r2, sp, #8 <== NOT EXECUTED
30006248: e1a00008 mov r0, r8 <== NOT EXECUTED
3000624c: e8940600 ldm r4, {r9, sl} <== NOT EXECUTED
30006250: eb001642 bl 3000bb60 <rtems_object_get_name> <== NOT EXECUTED
30006254: e59f1078 ldr r1, [pc, #120] ; 300062d4 <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
30006258: e1a03000 mov r3, r0 <== NOT EXECUTED
3000625c: e1a02008 mov r2, r8 <== NOT EXECUTED
30006260: e1a0000a mov r0, sl <== NOT EXECUTED
30006264: e1a0e00f mov lr, pc <== NOT EXECUTED
30006268: e12fff19 bx r9 <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
3000626c: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30006270: e59520bc ldr r2, [r5, #188] ; 0xbc <== NOT EXECUTED 30006274: e2433001 sub r3, r3, #1 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
30006278: e0823003 add r3, r2, r3 <== NOT EXECUTED 3000627c: e58db000 str fp, [sp] <== NOT EXECUTED 30006280: e58d7004 str r7, [sp, #4] <== NOT EXECUTED 30006284: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30006288: e59f1048 ldr r1, [pc, #72] ; 300062d8 <Stack_check_Dump_threads_usage+0x100><== NOT EXECUTED 3000628c: e1a0e00f mov lr, pc <== NOT EXECUTED 30006290: e594f000 ldr pc, [r4] <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
30006294: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30006298: e3530000 cmp r3, #0 <== NOT EXECUTED 3000629c: 1a000004 bne 300062b4 <Stack_check_Dump_threads_usage+0xdc><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
300062a0: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 300062a4: e59f1030 ldr r1, [pc, #48] ; 300062dc <Stack_check_Dump_threads_usage+0x104><== NOT EXECUTED 300062a8: e1a0e00f mov lr, pc <== NOT EXECUTED 300062ac: e594f000 ldr pc, [r4] <== NOT EXECUTED 300062b0: ea000004 b 300062c8 <Stack_check_Dump_threads_usage+0xf0> <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
300062b4: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 300062b8: e59f1020 ldr r1, [pc, #32] ; 300062e0 <Stack_check_Dump_threads_usage+0x108><== NOT EXECUTED 300062bc: e1a02006 mov r2, r6 <== NOT EXECUTED 300062c0: e1a0e00f mov lr, pc <== NOT EXECUTED 300062c4: e594f000 ldr pc, [r4] <== NOT EXECUTED
}
}
300062c8: e8bd8fff pop {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}<== NOT EXECUTED
30006388 <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)
{
30006388: e92d40ff push {r0, r1, r2, r3, r4, r5, r6, r7, lr} <== NOT EXECUTED
3000638c: e1a06000 mov r6, r0 <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack);
30006390: e59040bc ldr r4, [r0, #188] ; 0xbc <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
30006394: e59f0078 ldr r0, [pc, #120] ; 30006414 <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)
{
30006398: 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");
3000639c: eb0006f1 bl 30007f68 <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
300063a0: e59f0070 ldr r0, [pc, #112] ; 30006418 <Stack_check_report_blown_task+0x90><== NOT EXECUTED 300063a4: e1a01006 mov r1, r6 <== NOT EXECUTED 300063a8: eb0006ee bl 30007f68 <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
300063ac: e59f0068 ldr r0, [pc, #104] ; 3000641c <Stack_check_report_blown_task+0x94><== NOT EXECUTED 300063b0: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 300063b4: eb0006eb bl 30007f68 <printk> <== NOT EXECUTED
printk(
300063b8: e59f0060 ldr r0, [pc, #96] ; 30006420 <Stack_check_report_blown_task+0x98><== NOT EXECUTED 300063bc: e596100c ldr r1, [r6, #12] <== NOT EXECUTED 300063c0: eb0006e8 bl 30007f68 <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
300063c4: e1a0200d mov r2, sp <== NOT EXECUTED 300063c8: e3a01020 mov r1, #32 <== NOT EXECUTED 300063cc: e5960008 ldr r0, [r6, #8] <== NOT EXECUTED 300063d0: eb0015e2 bl 3000bb60 <rtems_object_get_name> <== NOT EXECUTED 300063d4: e1a01000 mov r1, r0 <== NOT EXECUTED 300063d8: e59f0044 ldr r0, [pc, #68] ; 30006424 <Stack_check_report_blown_task+0x9c><== NOT EXECUTED 300063dc: eb0006e1 bl 30007f68 <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)
300063e0: e59620bc ldr r2, [r6, #188] ; 0xbc <== NOT EXECUTED 300063e4: e59610b8 ldr r1, [r6, #184] ; 0xb8 <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
300063e8: e59f0038 ldr r0, [pc, #56] ; 30006428 <Stack_check_report_blown_task+0xa0><== NOT EXECUTED 300063ec: e0823001 add r3, r2, r1 <== NOT EXECUTED 300063f0: eb0006dc bl 30007f68 <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) {
300063f4: e3550000 cmp r5, #0 <== NOT EXECUTED
printk(
300063f8: 059f002c ldreq r0, [pc, #44] ; 3000642c <Stack_check_report_blown_task+0xa4><== NOT EXECUTED 300063fc: 03a01010 moveq r1, #16 <== NOT EXECUTED 30006400: 02842008 addeq r2, r4, #8 <== NOT EXECUTED 30006404: 02843018 addeq r3, r4, #24 <== NOT EXECUTED 30006408: 0b0006d6 bleq 30007f68 <printk> <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
3000640c: e3a00081 mov r0, #129 ; 0x81 <== NOT EXECUTED 30006410: eb0017c8 bl 3000c338 <rtems_fatal_error_occurred> <== NOT EXECUTED
3000f314 <TOD_MICROSECONDS_TO_TICKS>:
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
return (microseconds / rtems_configuration_get_microseconds_per_tick());
3000f314: e59f300c ldr r3, [pc, #12] ; 3000f328 <TOD_MICROSECONDS_TO_TICKS+0x14><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
3000f318: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (microseconds / rtems_configuration_get_microseconds_per_tick());
3000f31c: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3000f320: eb004ff3 bl 300232f4 <__aeabi_uidiv> <== NOT EXECUTED
}
3000f324: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000af68 <TOD_MILLISECONDS_TO_TICKS>:
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000af68: e59f3020 ldr r3, [pc, #32] ; 3000af90 <TOD_MILLISECONDS_TO_TICKS+0x28><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000af6c: e92d4010 push {r4, lr} <== NOT EXECUTED
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000af70: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000af74: e1a04000 mov r4, r0 <== NOT EXECUTED
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000af78: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000af7c: eb004215 bl 3001b7d8 <__aeabi_uidiv> <== NOT EXECUTED 3000af80: e1a01000 mov r1, r0 <== NOT EXECUTED 3000af84: e1a00004 mov r0, r4 <== NOT EXECUTED 3000af88: eb004212 bl 3001b7d8 <__aeabi_uidiv> <== NOT EXECUTED
}
3000af8c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30010ef4 <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 /
30010ef4: e59f3010 ldr r3, [pc, #16] ; 30010f0c <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)
{
30010ef8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (TOD_MICROSECONDS_PER_SECOND /
30010efc: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 30010f00: e59f0008 ldr r0, [pc, #8] ; 30010f10 <TOD_TICKS_PER_SECOND_method+0x1c><== NOT EXECUTED 30010f04: eb000e31 bl 300147d0 <__aeabi_uidiv> <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
}
30010f08: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c5d4 <_CORE_RWLock_Initialize>:
CORE_RWLock_Control *the_rwlock,
CORE_RWLock_Attributes *the_rwlock_attributes
)
{
the_rwlock->Attributes = *the_rwlock_attributes;
3000c5d4: e5912000 ldr r2, [r1] <== NOT EXECUTED
the_rwlock->number_of_waiting_threads = 0;
*/
the_rwlock->number_of_readers = 0;
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
_Thread_queue_Initialize(
3000c5d8: e3a03003 mov r3, #3 <== NOT EXECUTED
the_rwlock->Attributes = *the_rwlock_attributes;
/*
the_rwlock->number_of_waiting_threads = 0;
*/
the_rwlock->number_of_readers = 0;
3000c5dc: e3a01000 mov r1, #0 <== NOT EXECUTED
CORE_RWLock_Control *the_rwlock,
CORE_RWLock_Attributes *the_rwlock_attributes
)
{
the_rwlock->Attributes = *the_rwlock_attributes;
3000c5e0: e5802040 str r2, [r0, #64] ; 0x40 <== NOT EXECUTED
the_rwlock->number_of_waiting_threads = 0;
*/
the_rwlock->number_of_readers = 0;
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
_Thread_queue_Initialize(
3000c5e4: e3a02802 mov r2, #131072 ; 0x20000 <== NOT EXECUTED
the_rwlock->Attributes = *the_rwlock_attributes;
/*
the_rwlock->number_of_waiting_threads = 0;
*/
the_rwlock->number_of_readers = 0;
3000c5e8: e5801048 str r1, [r0, #72] ; 0x48 <== NOT EXECUTED
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
3000c5ec: e5801044 str r1, [r0, #68] ; 0x44 <== NOT EXECUTED
_Thread_queue_Initialize(
3000c5f0: ea000858 b 3000e758 <_Thread_queue_Initialize> <== NOT EXECUTED
3000c5f4 <_CORE_RWLock_Obtain_for_reading>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000c5f4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3000c5f8: e1a08003 mov r8, r3 <== NOT EXECUTED
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000c5fc: e59f30b8 ldr r3, [pc, #184] ; 3000c6bc <_CORE_RWLock_Obtain_for_reading+0xc8><== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000c600: e1a04000 mov r4, r0 <== NOT EXECUTED
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000c604: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000c608: e1a05001 mov r5, r1 <== NOT EXECUTED 3000c60c: e202a0ff and sl, r2, #255 ; 0xff <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c610: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000c614: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3000c618: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
switch ( the_rwlock->current_state ) {
3000c61c: e590c044 ldr ip, [r0, #68] ; 0x44 <== NOT EXECUTED 3000c620: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000c624: 0a000002 beq 3000c634 <_CORE_RWLock_Obtain_for_reading+0x40><== NOT EXECUTED 3000c628: e35c0001 cmp ip, #1 <== NOT EXECUTED 3000c62c: 1a000010 bne 3000c674 <_CORE_RWLock_Obtain_for_reading+0x80><== NOT EXECUTED 3000c630: ea000005 b 3000c64c <_CORE_RWLock_Obtain_for_reading+0x58> <== NOT EXECUTED
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
3000c634: e3a03001 mov r3, #1 <== NOT EXECUTED 3000c638: e5803044 str r3, [r0, #68] ; 0x44 <== NOT EXECUTED
the_rwlock->number_of_readers += 1;
3000c63c: e5903048 ldr r3, [r0, #72] ; 0x48 <== NOT EXECUTED 3000c640: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000c644: e5803048 str r3, [r0, #72] ; 0x48 <== NOT EXECUTED
_ISR_Enable( level );
3000c648: ea000005 b 3000c664 <_CORE_RWLock_Obtain_for_reading+0x70> <== NOT EXECUTED
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
return;
case CORE_RWLOCK_LOCKED_FOR_READING: {
Thread_Control *waiter;
waiter = _Thread_queue_First( &the_rwlock->Wait_queue );
3000c64c: eb00081a bl 3000e6bc <_Thread_queue_First> <== NOT EXECUTED
if ( !waiter ) {
3000c650: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c654: 1a000006 bne 3000c674 <_CORE_RWLock_Obtain_for_reading+0x80><== NOT EXECUTED
the_rwlock->number_of_readers += 1;
3000c658: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED 3000c65c: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000c660: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c664: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000c668: e3a03000 mov r3, #0 <== NOT EXECUTED 3000c66c: e5863034 str r3, [r6, #52] ; 0x34 <== NOT EXECUTED
return;
3000c670: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
3000c674: e35a0000 cmp sl, #0 <== NOT EXECUTED 3000c678: 1a000002 bne 3000c688 <_CORE_RWLock_Obtain_for_reading+0x94><== NOT EXECUTED 3000c67c: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
3000c680: e3a03002 mov r3, #2 <== NOT EXECUTED 3000c684: eafffff8 b 3000c66c <_CORE_RWLock_Obtain_for_reading+0x78> <== NOT EXECUTED 3000c688: e3a03001 mov r3, #1 <== NOT EXECUTED 3000c68c: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
3000c690: e3a03000 mov r3, #0 <== NOT EXECUTED
/*
* We need to wait to enter this critical section
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
3000c694: e5864044 str r4, [r6, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
3000c698: e5865020 str r5, [r6, #32] <== NOT EXECUTED
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
3000c69c: e5863030 str r3, [r6, #48] ; 0x30 <== NOT EXECUTED
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000c6a0: e5863034 str r3, [r6, #52] ; 0x34 <== NOT EXECUTED 3000c6a4: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
3000c6a8: e59f2010 ldr r2, [pc, #16] ; 3000c6c0 <_CORE_RWLock_Obtain_for_reading+0xcc><== NOT EXECUTED 3000c6ac: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c6b0: e1a01008 mov r1, r8 <== NOT EXECUTED
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
3000c6b4: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
3000c6b8: ea000729 b 3000e364 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
3000c6c4 <_CORE_RWLock_Obtain_for_writing>:
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
3000c6c4: e59fc07c ldr ip, [pc, #124] ; 3000c748 <_CORE_RWLock_Obtain_for_writing+0x84><== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000c6c8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000c6cc: e59cc004 ldr ip, [ip, #4] <== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000c6d0: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c6d4: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000c6d8: e3845080 orr r5, r4, #128 ; 0x80 <== NOT EXECUTED 3000c6dc: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
switch ( the_rwlock->current_state ) {
3000c6e0: e5905044 ldr r5, [r0, #68] ; 0x44 <== NOT EXECUTED 3000c6e4: e3550000 cmp r5, #0 <== NOT EXECUTED 3000c6e8: 1a000004 bne 3000c700 <_CORE_RWLock_Obtain_for_writing+0x3c><== NOT EXECUTED
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
3000c6ec: e3a03002 mov r3, #2 <== NOT EXECUTED 3000c6f0: e5803044 str r3, [r0, #68] ; 0x44 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c6f4: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000c6f8: e3a03000 mov r3, #0 <== NOT EXECUTED 3000c6fc: ea000003 b 3000c710 <_CORE_RWLock_Obtain_for_writing+0x4c> <== NOT EXECUTED
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
3000c700: e3520000 cmp r2, #0 <== NOT EXECUTED 3000c704: 1a000003 bne 3000c718 <_CORE_RWLock_Obtain_for_writing+0x54><== NOT EXECUTED 3000c708: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
3000c70c: e3a03002 mov r3, #2 <== NOT EXECUTED
3000c710: e58c3034 str r3, [ip, #52] ; 0x34 <== NOT EXECUTED
3000c714: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000c718: e3a02001 mov r2, #1 <== NOT EXECUTED
3000c71c: e5802030 str r2, [r0, #48] ; 0x30 <== NOT EXECUTED
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
3000c720: e58c2030 str r2, [ip, #48] ; 0x30 <== NOT EXECUTED
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000c724: e3a02000 mov r2, #0 <== NOT EXECUTED
/*
* We need to wait to enter this critical section
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
3000c728: e58c0044 str r0, [ip, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
3000c72c: e58c1020 str r1, [ip, #32] <== NOT EXECUTED
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000c730: e58c2034 str r2, [ip, #52] ; 0x34 <== NOT EXECUTED 3000c734: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
3000c738: e59f200c ldr r2, [pc, #12] ; 3000c74c <_CORE_RWLock_Obtain_for_writing+0x88><== NOT EXECUTED 3000c73c: e1a01003 mov r1, r3 <== NOT EXECUTED
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
3000c740: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
3000c744: ea000706 b 3000e364 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
3000c750 <_CORE_RWLock_Release>:
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
3000c750: e59f30d8 ldr r3, [pc, #216] ; 3000c830 <_CORE_RWLock_Release+0xe0><== NOT EXECUTED
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
3000c754: e92d4010 push {r4, lr} <== NOT EXECUTED
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000c758: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
3000c75c: e1a04000 mov r4, r0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c760: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000c764: e3831080 orr r1, r3, #128 ; 0x80 <== NOT EXECUTED 3000c768: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
3000c76c: e5901044 ldr r1, [r0, #68] ; 0x44 <== NOT EXECUTED 3000c770: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c774: 1a000003 bne 3000c788 <_CORE_RWLock_Release+0x38> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c778: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
3000c77c: e3a03002 mov r3, #2 <== NOT EXECUTED 3000c780: e5823034 str r3, [r2, #52] ; 0x34 <== NOT EXECUTED
return CORE_RWLOCK_SUCCESSFUL;
3000c784: ea000027 b 3000c828 <_CORE_RWLock_Release+0xd8> <== NOT EXECUTED
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
3000c788: e3510001 cmp r1, #1 <== NOT EXECUTED 3000c78c: 1a000006 bne 3000c7ac <_CORE_RWLock_Release+0x5c> <== NOT EXECUTED
the_rwlock->number_of_readers -= 1;
3000c790: e5901048 ldr r1, [r0, #72] ; 0x48 <== NOT EXECUTED 3000c794: e2411001 sub r1, r1, #1 <== NOT EXECUTED
if ( the_rwlock->number_of_readers != 0 ) {
3000c798: e3510000 cmp r1, #0 <== NOT EXECUTED
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
the_rwlock->number_of_readers -= 1;
3000c79c: e5801048 str r1, [r0, #72] ; 0x48 <== NOT EXECUTED
if ( the_rwlock->number_of_readers != 0 ) {
3000c7a0: 0a000001 beq 3000c7ac <_CORE_RWLock_Release+0x5c> <== NOT EXECUTED 3000c7a4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* must be unlocked again */
_ISR_Enable( level );
return CORE_RWLOCK_SUCCESSFUL;
3000c7a8: ea00001e b 3000c828 <_CORE_RWLock_Release+0xd8> <== NOT EXECUTED
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000c7ac: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c7b0: e5821034 str r1, [r2, #52] ; 0x34 <== NOT EXECUTED
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
3000c7b4: e5841044 str r1, [r4, #68] ; 0x44 <== NOT EXECUTED 3000c7b8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
3000c7bc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c7c0: eb00068c bl 3000e1f8 <_Thread_queue_Dequeue> <== NOT EXECUTED
if ( next ) {
3000c7c4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c7c8: 0a000016 beq 3000c828 <_CORE_RWLock_Release+0xd8> <== NOT EXECUTED
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
3000c7cc: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000c7d0: e3530001 cmp r3, #1 <== NOT EXECUTED
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
3000c7d4: 02833001 addeq r3, r3, #1 <== NOT EXECUTED 3000c7d8: 05843044 streq r3, [r4, #68] ; 0x44 <== NOT EXECUTED
_ISR_Enable( level );
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
if ( next ) {
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
3000c7dc: 0a000011 beq 3000c828 <_CORE_RWLock_Release+0xd8> <== NOT EXECUTED
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
3000c7e0: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED 3000c7e4: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000c7e8: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
3000c7ec: e3a03001 mov r3, #1 <== NOT EXECUTED 3000c7f0: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
3000c7f4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c7f8: eb0007af bl 3000e6bc <_Thread_queue_First> <== NOT EXECUTED
if ( !next ||
3000c7fc: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000c800: 0a000008 beq 3000c828 <_CORE_RWLock_Release+0xd8> <== NOT EXECUTED 3000c804: e5913030 ldr r3, [r1, #48] ; 0x30 <== NOT EXECUTED 3000c808: e3530001 cmp r3, #1 <== NOT EXECUTED 3000c80c: 0a000005 beq 3000c828 <_CORE_RWLock_Release+0xd8> <== NOT EXECUTED
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
3000c810: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
3000c814: e1a00004 mov r0, r4 <== NOT EXECUTED
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
3000c818: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000c81c: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
3000c820: eb00075d bl 3000e59c <_Thread_queue_Extract> <== NOT EXECUTED
}
3000c824: eafffff2 b 3000c7f4 <_CORE_RWLock_Release+0xa4> <== NOT EXECUTED
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
3000c828: e3a00000 mov r0, #0 <== NOT EXECUTED
3000c82c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c834 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
3000c834: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000c838: e1a0100d mov r1, sp <== NOT EXECUTED 3000c83c: eb0005ac bl 3000def4 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000c840: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000c844: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c848: 1a000004 bne 3000c860 <_CORE_RWLock_Timeout+0x2c> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
3000c84c: eb0007db bl 3000e7c0 <_Thread_queue_Process_timeout> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000c850: e59f300c ldr r3, [pc, #12] ; 3000c864 <_CORE_RWLock_Timeout+0x30><== NOT EXECUTED 3000c854: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c858: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000c85c: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000c860: e8bd8008 pop {r3, pc} <== NOT EXECUTED
3000b14c <_CORE_barrier_Wait>:
)
{
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
3000b14c: e59fc078 ldr ip, [pc, #120] ; 3000b1cc <_CORE_barrier_Wait+0x80>
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
3000b150: e92d4070 push {r4, r5, r6, lr}
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
3000b154: e59cc004 ldr ip, [ip, #4]
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
3000b158: e3a04000 mov r4, #0 3000b15c: e58c4034 str r4, [ip, #52] ; 0x34
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
3000b160: e59d2010 ldr r2, [sp, #16]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b164: e10f4000 mrs r4, CPSR 3000b168: e3845080 orr r5, r4, #128 ; 0x80 3000b16c: 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++;
3000b170: e5905048 ldr r5, [r0, #72] ; 0x48
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
3000b174: 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++;
3000b178: e2855001 add r5, r5, #1
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
3000b17c: 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++;
3000b180: e5805048 str r5, [r0, #72] ; 0x48
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
3000b184: 1a000007 bne 3000b1a8 <_CORE_barrier_Wait+0x5c>
if ( the_barrier->number_of_waiting_threads ==
3000b188: e5906044 ldr r6, [r0, #68] ; 0x44 <== NOT EXECUTED 3000b18c: e1550006 cmp r5, r6 <== NOT EXECUTED 3000b190: 1a000004 bne 3000b1a8 <_CORE_barrier_Wait+0x5c> <== NOT EXECUTED
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
3000b194: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b198: e58c3034 str r3, [ip, #52] ; 0x34 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b19c: 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 );
}
3000b1a0: 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 );
3000b1a4: ea001425 b 30010240 <_CORE_barrier_Release> <== 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;
3000b1a8: e3a02001 mov r2, #1 3000b1ac: e5802030 str r2, [r0, #48] ; 0x30
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
3000b1b0: e58c0044 str r0, [ip, #68] ; 0x44
executing->Wait.id = id;
3000b1b4: e58c1020 str r1, [ip, #32] 3000b1b8: e129f004 msr CPSR_fc, r4
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
3000b1bc: e59f200c ldr r2, [pc, #12] ; 3000b1d0 <_CORE_barrier_Wait+0x84> 3000b1c0: e1a01003 mov r1, r3
}
3000b1c4: 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 );
3000b1c8: ea000777 b 3000cfac <_Thread_queue_Enqueue_with_handler>
30019238 <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
30019238: 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
)
{
3001923c: 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 ) {
30019240: 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
)
{
30019244: e1a06000 mov r6, r0 30019248: e1a0a001 mov sl, r1 3001924c: e1a07002 mov r7, r2 30019250: 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 ) {
30019254: 8a000013 bhi 300192a8 <_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 ) {
30019258: e5905048 ldr r5, [r0, #72] ; 0x48 3001925c: e3550000 cmp r5, #0
*count = 0;
30019260: 13a00000 movne r0, #0 30019264: 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 ) {
30019268: 0a000007 beq 3001928c <_CORE_message_queue_Broadcast+0x54>
3001926c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30019270: e594002c ldr r0, [r4, #44] ; 0x2c 30019274: e1a0100a mov r1, sl 30019278: e1a02007 mov r2, r7 3001927c: eb0021e5 bl 30021a18 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30019280: 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;
30019284: e2855001 add r5, r5, #1
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30019288: 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 =
3001928c: e1a00006 mov r0, r6 30019290: eb000ad0 bl 3001bdd8 <_Thread_queue_Dequeue> 30019294: e2504000 subs r4, r0, #0
30019298: 1afffff4 bne 30019270 <_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;
3001929c: e5885000 str r5, [r8]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
300192a0: e1a00004 mov r0, r4
300192a4: 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;
300192a8: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
300192ac: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30012234 <_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
)
{
30012234: 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)) {
30012238: 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
)
{
3001223c: 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;
30012240: 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
)
{
30012244: e1a06002 mov r6, r2
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
30012248: 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
)
{
3001224c: 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;
30012250: e5840048 str r0, [r4, #72] ; 0x48
the_message_queue->maximum_message_size = maximum_message_size;
30012254: e584304c str r3, [r4, #76] ; 0x4c
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
30012258: e5840060 str r0, [r4, #96] ; 0x60
the_message_queue->notify_argument = the_argument;
3001225c: e5840064 str r0, [r4, #100] ; 0x64
/*
* 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)) {
30012260: 01a02003 moveq r2, r3
30012264: 0a000003 beq 30012278 <_CORE_message_queue_Initialize+0x44>
allocated_message_size += sizeof(uint32_t);
30012268: e2832004 add r2, r3, #4 <== NOT EXECUTED
allocated_message_size &= ~(sizeof(uint32_t) - 1);
3001226c: e3c22003 bic r2, r2, #3 <== NOT EXECUTED
}
if (allocated_message_size < maximum_message_size)
30012270: e1520003 cmp r2, r3 <== NOT EXECUTED
30012274: 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));
30012278: e2827014 add r7, r2, #20
/*
* 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 *
3001227c: e0000796 mul r0, r6, r7
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
30012280: e1500002 cmp r0, r2
return false;
30012284: 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)
30012288: 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 );
3001228c: eb000b6f bl 30015050 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
30012290: e3500000 cmp r0, #0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
30012294: e1a01000 mov r1, r0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
30012298: e584005c str r0, [r4, #92] ; 0x5c
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
3001229c: 0a000013 beq 300122f0 <_CORE_message_queue_Initialize+0xbc>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
300122a0: e2840068 add r0, r4, #104 ; 0x68 300122a4: e1a02006 mov r2, r6 300122a8: e1a03007 mov r3, r7 300122ac: eb0014e5 bl 30017648 <_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 );
300122b0: e2843054 add r3, r4, #84 ; 0x54
head->next = tail;
300122b4: e5843050 str r3, [r4, #80] ; 0x50
head->previous = NULL;
300122b8: e3a03000 mov r3, #0 300122bc: e5843054 str r3, [r4, #84] ; 0x54
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
300122c0: e2843050 add r3, r4, #80 ; 0x50
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
300122c4: 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(
300122c8: e5951000 ldr r1, [r5] 300122cc: e1a00004 mov r0, r4 300122d0: e3510001 cmp r1, #1 300122d4: 13a01000 movne r1, #0 300122d8: 03a01001 moveq r1, #1 300122dc: e3a02080 mov r2, #128 ; 0x80 300122e0: e3a03006 mov r3, #6 300122e4: eb0008fa bl 300146d4 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
300122e8: e3a00001 mov r0, #1
300122ec: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
300122f0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30017698 <_CORE_message_queue_Insert_message>:
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
else
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
30017698: e3720106 cmn r2, #-2147483647 ; 0x80000001
void _CORE_message_queue_Insert_message(
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message,
CORE_message_queue_Submit_types submit_type
)
{
3001769c: e92d4070 push {r4, r5, r6, lr}
300176a0: e1a04000 mov r4, r0
300176a4: e1a05001 mov r5, r1
300176a8: e5812008 str r2, [r1, #8]
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
else
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
300176ac: 1a00000c bne 300176e4 <_CORE_message_queue_Insert_message+0x4c>
_ISR_Disable( level );
300176b0: ebfffff4 bl 30017688 <arm_interrupt_disable>
SET_NOTIFY();
300176b4: e5942048 ldr r2, [r4, #72] ; 0x48
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
300176b8: e2841054 add r1, r4, #84 ; 0x54
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
300176bc: e2723001 rsbs r3, r2, #1 300176c0: 33a03000 movcc r3, #0
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
300176c4: e2822001 add r2, r2, #1 300176c8: e5842048 str r2, [r4, #72] ; 0x48
Chain_Node *old_last = tail->previous;
300176cc: e5942058 ldr r2, [r4, #88] ; 0x58
the_node->next = tail;
300176d0: e5851000 str r1, [r5]
tail->previous = the_node;
300176d4: e5845058 str r5, [r4, #88] ; 0x58
old_last->next = the_node;
300176d8: e5825000 str r5, [r2]
the_node->previous = old_last;
300176dc: e5852004 str r2, [r5, #4]
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
300176e0: ea000022 b 30017770 <_CORE_message_queue_Insert_message+0xd8>
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
300176e4: e3520102 cmp r2, #-2147483648 ; 0x80000000
* the message is actually in the queue at this point.
*/
if ( notify && the_message_queue->notify_handler )
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
#endif
}
300176e8: 15906050 ldrne r6, [r0, #80] ; 0x50
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
300176ec: 12803054 addne r3, r0, #84 ; 0x54
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
300176f0: 1a000010 bne 30017738 <_CORE_message_queue_Insert_message+0xa0>
_ISR_Disable( level );
300176f4: ebffffe3 bl 30017688 <arm_interrupt_disable>
SET_NOTIFY();
300176f8: e5942048 ldr r2, [r4, #72] ; 0x48
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
300176fc: e2723001 rsbs r3, r2, #1 30017700: 33a03000 movcc r3, #0
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
30017704: e2822001 add r2, r2, #1 30017708: e5842048 str r2, [r4, #72] ; 0x48
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
3001770c: e2842050 add r2, r4, #80 ; 0x50
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
30017710: e5852004 str r2, [r5, #4]
before_node = after_node->next;
30017714: e5942050 ldr r2, [r4, #80] ; 0x50
after_node->next = the_node;
30017718: e5845050 str r5, [r4, #80] ; 0x50
the_node->next = before_node; before_node->previous = the_node;
3001771c: e5825004 str r5, [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;
30017720: e5852000 str r2, [r5]
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
30017724: ea000011 b 30017770 <_CORE_message_queue_Insert_message+0xd8>
this_message = (CORE_message_queue_Buffer_control *) the_node;
this_priority = _CORE_message_queue_Get_message_priority(this_message);
if ( this_priority <= the_priority ) {
30017728: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 3001772c: e1510002 cmp r1, r2 <== NOT EXECUTED 30017730: ca000002 bgt 30017740 <_CORE_message_queue_Insert_message+0xa8><== NOT EXECUTED
the_node = the_node->next;
30017734: e5966000 ldr r6, [r6] <== NOT EXECUTED
int the_priority;
the_priority = _CORE_message_queue_Get_message_priority(the_message);
the_header = &the_message_queue->Pending_messages;
the_node = _Chain_First( the_header );
while ( !_Chain_Is_tail( the_header, the_node ) ) {
30017738: e1560003 cmp r6, r3 <== NOT EXECUTED 3001773c: 1afffff9 bne 30017728 <_CORE_message_queue_Insert_message+0x90><== NOT EXECUTED
the_node = the_node->next;
continue;
}
break;
}
_ISR_Disable( level );
30017740: ebffffd0 bl 30017688 <arm_interrupt_disable> <== NOT EXECUTED
SET_NOTIFY();
30017744: e5942048 ldr r2, [r4, #72] ; 0x48 <== NOT EXECUTED
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
30017748: e2723001 rsbs r3, r2, #1 <== NOT EXECUTED 3001774c: 33a03000 movcc r3, #0 <== NOT EXECUTED
}
break;
}
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
30017750: e2822001 add r2, r2, #1 <== NOT EXECUTED 30017754: e5842048 str r2, [r4, #72] ; 0x48 <== NOT EXECUTED
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
30017758: e5962004 ldr r2, [r6, #4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3001775c: e5921000 ldr r1, [r2] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
30017760: e5852004 str r2, [r5, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
30017764: e5825000 str r5, [r2] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
30017768: e5815004 str r5, [r1, #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;
3001776c: e5851000 str r1, [r5] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30017770: e129f000 msr CPSR_fc, r0
/*
* According to POSIX, does this happen before or after the message
* is actually enqueued. It is logical to think afterwards, because
* the message is actually in the queue at this point.
*/
if ( notify && the_message_queue->notify_handler )
30017774: e3530000 cmp r3, #0
30017778: 08bd8070 popeq {r4, r5, r6, pc}
3001777c: e5943060 ldr r3, [r4, #96] ; 0x60
30017780: e3530000 cmp r3, #0
30017784: 08bd8070 popeq {r4, r5, r6, pc}
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
30017788: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
3001778c: e1a0e00f mov lr, pc <== NOT EXECUTED
30017790: e12fff13 bx r3 <== NOT EXECUTED
30017794: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300122f4 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
300122f4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
300122f8: e1a04000 mov r4, r0
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
300122fc: e59f0118 ldr r0, [pc, #280] ; 3001241c <_CORE_message_queue_Seize+0x128>
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30012300: e3a05000 mov r5, #0
{
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
30012304: e5900004 ldr r0, [r0, #4]
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
30012308: e59dc020 ldr ip, [sp, #32] 3001230c: e5dda01c ldrb sl, [sp, #28]
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30012310: e5805034 str r5, [r0, #52] ; 0x34
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30012314: e10f6000 mrs r6, CPSR 30012318: e3865080 orr r5, r6, #128 ; 0x80 3001231c: e129f005 msr CPSR_fc, r5
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
30012320: e5945050 ldr r5, [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 );
30012324: e2847054 add r7, r4, #84 ; 0x54
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
30012328: e1550007 cmp r5, r7
3001232c: 0a000028 beq 300123d4 <_CORE_message_queue_Seize+0xe0>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
30012330: e5958000 ldr r8, [r5]
head->next = new_first;
30012334: e1a07004 mov r7, r4 30012338: e5a78050 str r8, [r7, #80]! ; 0x50
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
3001233c: e3550000 cmp r5, #0
new_first->previous = head;
30012340: e5887004 str r7, [r8, #4]
30012344: 0a000022 beq 300123d4 <_CORE_message_queue_Seize+0xe0>
the_message_queue->number_of_pending_messages -= 1;
30012348: e5941048 ldr r1, [r4, #72] ; 0x48 3001234c: e2411001 sub r1, r1, #1 30012350: e5841048 str r1, [r4, #72] ; 0x48
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30012354: e129f006 msr CPSR_fc, r6
_ISR_Enable( level );
*size_p = the_message->Contents.size;
30012358: e595100c ldr r1, [r5, #12]
_Thread_Executing->Wait.count =
3001235c: e5950008 ldr r0, [r5, #8]
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
_ISR_Enable( level );
*size_p = the_message->Contents.size;
30012360: e5831000 str r1, [r3]
_Thread_Executing->Wait.count =
30012364: e59f10b0 ldr r1, [pc, #176] ; 3001241c <_CORE_message_queue_Seize+0x128>
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
30012368: e2856010 add r6, r5, #16
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
_ISR_Enable( level );
*size_p = the_message->Contents.size;
_Thread_Executing->Wait.count =
3001236c: e5911004 ldr r1, [r1, #4] 30012370: e5810024 str r0, [r1, #36] ; 0x24
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30012374: e1a00002 mov r0, r2 30012378: e1a01006 mov r1, r6 3001237c: e5932000 ldr r2, [r3] 30012380: eb001f99 bl 3001a1ec <memcpy>
* is not, then we can go ahead and free the buffer.
*
* NOTE: If we note that the queue was not full before this receive,
* then we can avoid this dequeue.
*/
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
30012384: e1a00004 mov r0, r4 30012388: eb0007d2 bl 300142d8 <_Thread_queue_Dequeue>
if ( !the_thread ) {
3001238c: e2503000 subs r3, r0, #0
30012390: 1a000003 bne 300123a4 <_CORE_message_queue_Seize+0xb0>
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message
)
{
_Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
30012394: e2840068 add r0, r4, #104 ; 0x68 30012398: e1a01005 mov r1, r5
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
3001239c: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
300123a0: eaffff79 b 3001218c <_Chain_Append>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
300123a4: e5932024 ldr r2, [r3, #36] ; 0x24 <== NOT EXECUTED
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
300123a8: e593102c ldr r1, [r3, #44] ; 0x2c <== NOT EXECUTED
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
300123ac: e5852008 str r2, [r5, #8] <== NOT EXECUTED
*/
_CORE_message_queue_Set_message_priority(
the_message,
the_thread->Wait.count
);
the_message->Contents.size = (size_t) the_thread->Wait.option;
300123b0: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
300123b4: e1a00006 mov r0, r6 <== NOT EXECUTED 300123b8: e585200c str r2, [r5, #12] <== NOT EXECUTED 300123bc: eb001f8a bl 3001a1ec <memcpy> <== NOT EXECUTED
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
300123c0: e5952008 ldr r2, [r5, #8] <== NOT EXECUTED 300123c4: e1a00004 mov r0, r4 <== NOT EXECUTED 300123c8: e1a01005 mov r1, r5 <== NOT EXECUTED
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
300123cc: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
300123d0: ea0014b0 b 30017698 <_CORE_message_queue_Insert_message> <== NOT EXECUTED
return;
}
#endif
}
if ( !wait ) {
300123d4: e35a0000 cmp sl, #0
300123d8: 1a000003 bne 300123ec <_CORE_message_queue_Seize+0xf8>
300123dc: e129f006 msr CPSR_fc, r6
_ISR_Enable( level );
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
300123e0: e3a03004 mov r3, #4 300123e4: e5803034 str r3, [r0, #52] ; 0x34
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
300123e8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
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;
300123ec: e3a05001 mov r5, #1 300123f0: e5845030 str r5, [r4, #48] ; 0x30
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
return;
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
300123f4: e5804044 str r4, [r0, #68] ; 0x44
executing->Wait.id = id;
300123f8: e5801020 str r1, [r0, #32]
executing->Wait.return_argument_second.mutable_object = buffer;
300123fc: e580202c str r2, [r0, #44] ; 0x2c
executing->Wait.return_argument = size_p;
30012400: e5803028 str r3, [r0, #40] ; 0x28 30012404: e129f006 msr CPSR_fc, r6
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
30012408: e59f2010 ldr r2, [pc, #16] ; 30012420 <_CORE_message_queue_Seize+0x12c> 3001240c: e1a00004 mov r0, r4 30012410: e1a0100c mov r1, ip
}
30012414: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
30012418: ea000809 b 30014444 <_Thread_queue_Enqueue_with_handler>
30012424 <_CORE_message_queue_Submit>:
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30012424: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30012428: e1a09003 mov r9, r3
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
3001242c: e590304c ldr r3, [r0, #76] ; 0x4c
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30012430: e1a04000 mov r4, r0
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30012434: e1520003 cmp r2, r3
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30012438: e1a08001 mov r8, r1 3001243c: e1a05002 mov r5, r2 30012440: e59d6028 ldr r6, [sp, #40] ; 0x28 30012444: e5ddb02c ldrb fp, [sp, #44] ; 0x2c
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;
30012448: 83a00001 movhi r0, #1
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
3001244c: 88bd8ff0 pophi {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
30012450: e594a048 ldr sl, [r4, #72] ; 0x48 30012454: e35a0000 cmp sl, #0
30012458: 1a00000b bne 3001248c <_CORE_message_queue_Submit+0x68>
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
3001245c: eb00079d bl 300142d8 <_Thread_queue_Dequeue>
if ( the_thread ) {
30012460: e2507000 subs r7, r0, #0
30012464: 0a000008 beq 3001248c <_CORE_message_queue_Submit+0x68>
30012468: e597002c ldr r0, [r7, #44] ; 0x2c 3001246c: e1a01008 mov r1, r8 30012470: e1a02005 mov r2, r5 30012474: eb001f5c bl 3001a1ec <memcpy>
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30012478: e5973028 ldr r3, [r7, #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;
3001247c: e1a0000a mov r0, sl
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30012480: e5835000 str r5, [r3]
the_thread->Wait.count = (uint32_t) submit_type;
30012484: e5876024 str r6, [r7, #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;
30012488: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, 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 <
3001248c: e5942048 ldr r2, [r4, #72] ; 0x48 30012490: e5943044 ldr r3, [r4, #68] ; 0x44 30012494: e1520003 cmp r2, r3
30012498: 2a00000e bcs 300124d8 <_CORE_message_queue_Submit+0xb4>
_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 );
3001249c: e2840068 add r0, r4, #104 ; 0x68 300124a0: ebffff4c bl 300121d8 <_Chain_Get>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
300124a4: e1a01008 mov r1, r8
_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 );
300124a8: e1a07000 mov r7, r0
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
300124ac: e1a02005 mov r2, r5 300124b0: e2800010 add r0, r0, #16 300124b4: eb001f4c bl 3001a1ec <memcpy>
size
);
the_message->Contents.size = size;
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
300124b8: e1a00004 mov r0, r4
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
300124bc: e587500c str r5, [r7, #12]
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
300124c0: e5876008 str r6, [r7, #8]
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
300124c4: e1a01007 mov r1, r7 300124c8: e1a02006 mov r2, r6 300124cc: eb001471 bl 30017698 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
300124d0: e3a00000 mov r0, #0
300124d4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* No message buffers were available so we may need to return an
* overflow error or block the sender until the message is placed
* on the queue.
*/
if ( !wait ) {
300124d8: e35b0000 cmp fp, #0 <== NOT EXECUTED
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
300124dc: 03a00002 moveq r0, #2 <== NOT EXECUTED
/*
* No message buffers were available so we may need to return an
* overflow error or block the sender until the message is placed
* on the queue.
*/
if ( !wait ) {
300124e0: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/*
* Do NOT block on a send if the caller is in an ISR. It is
* deadly to block in an ISR.
*/
if ( _ISR_Is_in_progress() ) {
300124e4: e59f3058 ldr r3, [pc, #88] ; 30012544 <_CORE_message_queue_Submit+0x120><== NOT EXECUTED 300124e8: e5932000 ldr r2, [r3] <== NOT EXECUTED 300124ec: e3520000 cmp r2, #0 <== NOT EXECUTED 300124f0: 1a000011 bne 3001253c <_CORE_message_queue_Submit+0x118> <== NOT EXECUTED
* Thus the unusual choice to open a new scope and declare
* it as a variable. Doing this emphasizes how dangerous it
* would be to use this variable prior to here.
*/
{
Thread_Control *executing = _Thread_Executing;
300124f4: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300124f8: e10f2000 mrs r2, CPSR <== NOT EXECUTED 300124fc: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30012500: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 30012504: e3a01001 mov r1, #1 <== NOT EXECUTED 30012508: e5841030 str r1, [r4, #48] ; 0x30 <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
3001250c: e5834044 str r4, [r3, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
30012510: e5839020 str r9, [r3, #32] <== NOT EXECUTED
executing->Wait.return_argument_second.immutable_object = buffer;
30012514: e583802c str r8, [r3, #44] ; 0x2c <== NOT EXECUTED
executing->Wait.option = (uint32_t) size;
30012518: e5835030 str r5, [r3, #48] ; 0x30 <== NOT EXECUTED
executing->Wait.count = submit_type;
3001251c: e5836024 str r6, [r3, #36] ; 0x24 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30012520: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
30012524: e59f201c ldr r2, [pc, #28] ; 30012548 <_CORE_message_queue_Submit+0x124><== NOT EXECUTED 30012528: e1a00004 mov r0, r4 <== NOT EXECUTED 3001252c: e59d1030 ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED 30012530: eb0007c3 bl 30014444 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
30012534: e3a00007 mov r0, #7 <== NOT EXECUTED
30012538: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/*
* Do NOT block on a send if the caller is in an ISR. It is
* deadly to block in an ISR.
*/
if ( _ISR_Is_in_progress() ) {
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
3001253c: e3a00003 mov r0, #3 <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
30012540: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30009fa4 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
30009fa4: e92d40f0 push {r4, r5, r6, r7, lr}
30009fa8: e1a07003 mov r7, r3
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
30009fac: e59f30ac ldr r3, [pc, #172] ; 3000a060 <_CORE_mutex_Seize+0xbc>
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
30009fb0: e1a04000 mov r4, r0
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
30009fb4: e5933000 ldr r3, [r3]
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
30009fb8: e1a05001 mov r5, r1
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
30009fbc: e3530000 cmp r3, #0
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
30009fc0: e20260ff and r6, r2, #255 ; 0xff
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 30009fc4: 0a000008 beq 30009fec <_CORE_mutex_Seize+0x48>
30009fc8: e3560000 cmp r6, #0
30009fcc: 0a000006 beq 30009fec <_CORE_mutex_Seize+0x48>
30009fd0: e59f308c ldr r3, [pc, #140] ; 3000a064 <_CORE_mutex_Seize+0xc0>
30009fd4: e5933000 ldr r3, [r3]
30009fd8: e3530001 cmp r3, #1
30009fdc: 83a00000 movhi r0, #0
30009fe0: 81a01000 movhi r1, r0
30009fe4: 83a02012 movhi r2, #18
30009fe8: 8b0001bf blhi 3000a6ec <_Internal_error_Occurred>
30009fec: e1a00004 mov r0, r4
30009ff0: e28d1014 add r1, sp, #20
30009ff4: eb0013c8 bl 3000ef1c <_CORE_mutex_Seize_interrupt_trylock>
30009ff8: e3500000 cmp r0, #0
30009ffc: 08bd80f0 popeq {r4, r5, r6, r7, pc}
3000a000: e3560000 cmp r6, #0
3000a004: e59f305c ldr r3, [pc, #92] ; 3000a068 <_CORE_mutex_Seize+0xc4>
3000a008: 1a000005 bne 3000a024 <_CORE_mutex_Seize+0x80>
3000a00c: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
3000a010: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
3000a014: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
3000a018: e3a02001 mov r2, #1 <== NOT EXECUTED
3000a01c: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
3000a020: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000a024: 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;
3000a028: e3a02001 mov r2, #1
3000a02c: e5842030 str r2, [r4, #48] ; 0x30
3000a030: e5834044 str r4, [r3, #68] ; 0x44
3000a034: e5835020 str r5, [r3, #32]
3000a038: e59f3020 ldr r3, [pc, #32] ; 3000a060 <_CORE_mutex_Seize+0xbc>
3000a03c: e5932000 ldr r2, [r3]
3000a040: e2822001 add r2, r2, #1
3000a044: e5832000 str r2, [r3]
3000a048: e59d3014 ldr r3, [sp, #20]
3000a04c: e129f003 msr CPSR_fc, r3
3000a050: e1a00004 mov r0, r4
3000a054: e1a01007 mov r1, r7
3000a058: ebffffb8 bl 30009f40 <_CORE_mutex_Seize_interrupt_blocking>
3000a05c: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000ef1c <_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
)
{
3000ef1c: e1a03000 mov r3, r0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000ef20: e59f2124 ldr r2, [pc, #292] ; 3000f04c <_CORE_mutex_Seize_interrupt_trylock+0x130>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000ef24: 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;
3000ef28: e3a00000 mov r0, #0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000ef2c: e5922004 ldr r2, [r2, #4]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000ef30: e15c0000 cmp ip, r0
3000ef34: e92d4010 push {r4, lr}
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000ef38: e5820034 str r0, [r2, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000ef3c: 0a00002c beq 3000eff4 <_CORE_mutex_Seize_interrupt_trylock+0xd8>
the_mutex->lock = CORE_MUTEX_LOCKED;
3000ef40: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
3000ef44: 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;
3000ef48: e583205c str r2, [r3, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
3000ef4c: e5830060 str r0, [r3, #96] ; 0x60
the_mutex->nest_count = 1;
3000ef50: e3a00001 mov r0, #1 3000ef54: e5830054 str r0, [r3, #84] ; 0x54
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
3000ef58: e5930048 ldr r0, [r3, #72] ; 0x48
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000ef5c: e3500002 cmp r0, #2
3000ef60: 0a000001 beq 3000ef6c <_CORE_mutex_Seize_interrupt_trylock+0x50>
3000ef64: e3500003 cmp r0, #3
3000ef68: 1a000004 bne 3000ef80 <_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++;
3000ef6c: e592c01c ldr ip, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
3000ef70: 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++;
3000ef74: e28c4001 add r4, ip, #1 3000ef78: e582401c str r4, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
3000ef7c: 0a000000 beq 3000ef84 <_CORE_mutex_Seize_interrupt_trylock+0x68>
_ISR_Enable( *level_p );
3000ef80: ea00002b b 3000f034 <_CORE_mutex_Seize_interrupt_trylock+0x118>
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
3000ef84: e593004c ldr r0, [r3, #76] ; 0x4c
current = executing->current_priority;
3000ef88: e5924014 ldr r4, [r2, #20]
if ( current == ceiling ) {
3000ef8c: e1540000 cmp r4, r0
3000ef90: 1a000000 bne 3000ef98 <_CORE_mutex_Seize_interrupt_trylock+0x7c>
_ISR_Enable( *level_p );
3000ef94: ea000026 b 3000f034 <_CORE_mutex_Seize_interrupt_trylock+0x118><== NOT EXECUTED
return 0;
}
if ( current > ceiling ) {
3000ef98: 9a00000b bls 3000efcc <_CORE_mutex_Seize_interrupt_trylock+0xb0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000ef9c: e59f20ac ldr r2, [pc, #172] ; 3000f050 <_CORE_mutex_Seize_interrupt_trylock+0x134><== NOT EXECUTED 3000efa0: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000efa4: e2800001 add r0, r0, #1 <== NOT EXECUTED 3000efa8: e5820000 str r0, [r2] <== NOT EXECUTED 3000efac: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000efb0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
3000efb4: e3a02000 mov r2, #0 <== NOT EXECUTED 3000efb8: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED 3000efbc: e593104c ldr r1, [r3, #76] ; 0x4c <== NOT EXECUTED 3000efc0: ebfff11e bl 3000b440 <_Thread_Change_priority> <== NOT EXECUTED
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
3000efc4: ebfff221 bl 3000b850 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000efc8: ea00001b b 3000f03c <_CORE_mutex_Seize_interrupt_trylock+0x120><== NOT EXECUTED
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
3000efcc: e3a00006 mov r0, #6 3000efd0: e5820034 str r0, [r2, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000efd4: e3a00001 mov r0, #1 3000efd8: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
3000efdc: e3a00000 mov r0, #0 3000efe0: e5830054 str r0, [r3, #84] ; 0x54
executing->resource_count--; /* undo locking above */
3000efe4: e582c01c str ip, [r2, #28]
3000efe8: e5913000 ldr r3, [r1]
3000efec: e129f003 msr CPSR_fc, r3
3000eff0: 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 ) ) {
3000eff4: e593005c ldr r0, [r3, #92] ; 0x5c 3000eff8: e1500002 cmp r0, r2
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000effc: 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 ) ) {
3000f000: 18bd8010 popne {r4, pc}
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
3000f004: e5932040 ldr r2, [r3, #64] ; 0x40 3000f008: e3520000 cmp r2, #0
3000f00c: 0a000002 beq 3000f01c <_CORE_mutex_Seize_interrupt_trylock+0x100>
3000f010: e3520001 cmp r2, #1
3000f014: 1a00000a bne 3000f044 <_CORE_mutex_Seize_interrupt_trylock+0x128>
3000f018: ea000003 b 3000f02c <_CORE_mutex_Seize_interrupt_trylock+0x110><== NOT EXECUTED
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
3000f01c: e5932054 ldr r2, [r3, #84] ; 0x54 3000f020: e2822001 add r2, r2, #1 3000f024: e5832054 str r2, [r3, #84] ; 0x54
_ISR_Enable( *level_p );
3000f028: ea000001 b 3000f034 <_CORE_mutex_Seize_interrupt_trylock+0x118>
return 0;
#if defined(RTEMS_POSIX_API)
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
3000f02c: e3a03002 mov r3, #2 <== NOT EXECUTED 3000f030: e5803034 str r3, [r0, #52] ; 0x34 <== NOT EXECUTED
3000f034: e5913000 ldr r3, [r1] 3000f038: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
3000f03c: e3a00000 mov r0, #0
3000f040: e8bd8010 pop {r4, pc}
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000f044: e3a00001 mov r0, #1
3000f048: e8bd8010 pop {r4, pc}
3000a06c <_CORE_mutex_Surrender>:
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
3000a06c: e92d4030 push {r4, r5, lr}
3000a070: 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 ) {
3000a074: e5d43044 ldrb r3, [r4, #68] ; 0x44
)
{
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
3000a078: 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 ) {
3000a07c: e3530000 cmp r3, #0
3000a080: 0a000004 beq 3000a098 <_CORE_mutex_Surrender+0x2c>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000a084: e59f30ec ldr r3, [pc, #236] ; 3000a178 <_CORE_mutex_Surrender+0x10c>
if ( !_Thread_Is_executing( holder ) )
3000a088: e5933004 ldr r3, [r3, #4] 3000a08c: e1500003 cmp r0, r3
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
3000a090: 13a05003 movne r5, #3
* 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 ) )
3000a094: 1a000035 bne 3000a170 <_CORE_mutex_Surrender+0x104>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
3000a098: e5945054 ldr r5, [r4, #84] ; 0x54 3000a09c: e3550000 cmp r5, #0
3000a0a0: 0a000032 beq 3000a170 <_CORE_mutex_Surrender+0x104>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000a0a4: e2455001 sub r5, r5, #1
if ( the_mutex->nest_count != 0 ) {
3000a0a8: e3550000 cmp r5, #0
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000a0ac: 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;
3000a0b0: 13a05000 movne r5, #0
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
3000a0b4: 1a00002d bne 3000a170 <_CORE_mutex_Surrender+0x104>
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
3000a0b8: 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 ) ||
3000a0bc: e3530002 cmp r3, #2
3000a0c0: 0a000001 beq 3000a0cc <_CORE_mutex_Surrender+0x60>
3000a0c4: e3530003 cmp r3, #3
3000a0c8: 1a000009 bne 3000a0f4 <_CORE_mutex_Surrender+0x88>
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000a0cc: e590301c ldr r3, [r0, #28] 3000a0d0: 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 &&
3000a0d4: e3530000 cmp r3, #0
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000a0d8: 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 &&
3000a0dc: 1a000004 bne 3000a0f4 <_CORE_mutex_Surrender+0x88>
holder->real_priority != holder->current_priority ) {
3000a0e0: 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 &&
3000a0e4: e5903014 ldr r3, [r0, #20] 3000a0e8: e1510003 cmp r1, r3
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
3000a0ec: 13a02001 movne r2, #1 3000a0f0: 1b0004d2 blne 3000b440 <_Thread_Change_priority>
}
}
the_mutex->holder = NULL;
3000a0f4: e3a05000 mov r5, #0 3000a0f8: e584505c str r5, [r4, #92] ; 0x5c
the_mutex->holder_id = 0;
3000a0fc: 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 ) ) ) {
3000a100: e1a00004 mov r0, r4 3000a104: eb00069b bl 3000bb78 <_Thread_queue_Dequeue> 3000a108: e2503000 subs r3, r0, #0
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000a10c: 03a02001 moveq r2, #1 3000a110: 05842050 streq r2, [r4, #80] ; 0x50
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a114: 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 ) ) ) {
3000a118: 0a000014 beq 3000a170 <_CORE_mutex_Surrender+0x104>
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000a11c: e5932008 ldr r2, [r3, #8]
} else
#endif
{
the_mutex->holder = the_thread;
3000a120: e584305c str r3, [r4, #92] ; 0x5c
the_mutex->holder_id = the_thread->Object.id;
3000a124: e5842060 str r2, [r4, #96] ; 0x60
the_mutex->nest_count = 1;
3000a128: e3a02001 mov r2, #1 3000a12c: e5842054 str r2, [r4, #84] ; 0x54
switch ( the_mutex->Attributes.discipline ) {
3000a130: e5942048 ldr r2, [r4, #72] ; 0x48 3000a134: 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++;
3000a138: 0593201c ldreq r2, [r3, #28] 3000a13c: 02822001 addeq r2, r2, #1 3000a140: 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 ) {
3000a144: 0a000009 beq 3000a170 <_CORE_mutex_Surrender+0x104>
3000a148: e3520003 cmp r2, #3 <== NOT EXECUTED 3000a14c: 1a000007 bne 3000a170 <_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++;
3000a150: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000a154: 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++;
3000a158: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000a15c: e583201c str r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000a160: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED 3000a164: e1510003 cmp r1, r3 <== NOT EXECUTED
the_thread->current_priority){
_Thread_Change_priority(
3000a168: 31a02005 movcc r2, r5 <== NOT EXECUTED 3000a16c: 3b0004b3 blcc 3000b440 <_Thread_Change_priority> <== NOT EXECUTED
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
3000a170: e1a00005 mov r0, r5
3000a174: e8bd8030 pop {r4, r5, pc}
30012e38 <_CORE_semaphore_Seize>:
)
{
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
30012e38: e59fc074 ldr ip, [pc, #116] ; 30012eb4 <_CORE_semaphore_Seize+0x7c><== NOT EXECUTED
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
bool wait,
Watchdog_Interval timeout
)
{
30012e3c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
30012e40: e59cc004 ldr ip, [ip, #4] <== NOT EXECUTED
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
30012e44: e3a04000 mov r4, #0 <== NOT EXECUTED 30012e48: e58c4034 str r4, [ip, #52] ; 0x34 <== NOT EXECUTED
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
bool wait,
Watchdog_Interval timeout
)
{
30012e4c: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30012e50: e10f4000 mrs r4, CPSR <== NOT EXECUTED 30012e54: e3845080 orr r5, r4, #128 ; 0x80 <== NOT EXECUTED 30012e58: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
if ( the_semaphore->count != 0 ) {
30012e5c: e5905048 ldr r5, [r0, #72] ; 0x48 <== NOT EXECUTED 30012e60: e3550000 cmp r5, #0 <== NOT EXECUTED 30012e64: 0a000003 beq 30012e78 <_CORE_semaphore_Seize+0x40> <== NOT EXECUTED
the_semaphore->count -= 1;
30012e68: e2455001 sub r5, r5, #1 <== NOT EXECUTED 30012e6c: e5805048 str r5, [r0, #72] ; 0x48 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30012e70: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
30012e74: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* If the semaphore was not available and the caller was not willing
* to block, then return immediately with a status indicating that
* the semaphore was not available and the caller never blocked.
*/
if ( !wait ) {
30012e78: e3520000 cmp r2, #0 <== NOT EXECUTED 30012e7c: 1a000003 bne 30012e90 <_CORE_semaphore_Seize+0x58> <== NOT EXECUTED 30012e80: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level );
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
30012e84: e3a03001 mov r3, #1 <== NOT EXECUTED
30012e88: e58c3034 str r3, [ip, #52] ; 0x34 <== NOT EXECUTED
30012e8c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30012e90: e3a02001 mov r2, #1 <== NOT EXECUTED
30012e94: e5802030 str r2, [r0, #48] ; 0x30 <== NOT EXECUTED
/* * If the semaphore is not available and the caller is willing to * block, then we now block the caller with optional timeout. */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue;
30012e98: e58c0044 str r0, [ip, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
30012e9c: e58c1020 str r1, [ip, #32] <== NOT EXECUTED 30012ea0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
30012ea4: e59f200c ldr r2, [pc, #12] ; 30012eb8 <_CORE_semaphore_Seize+0x80><== NOT EXECUTED 30012ea8: e1a01003 mov r1, r3 <== NOT EXECUTED
}
30012eac: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
*/ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
30012eb0: eafff197 b 3000f514 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
3000ace8 <_CORE_spinlock_Initialize>:
CORE_spinlock_Control *the_spinlock,
CORE_spinlock_Attributes *the_spinlock_attributes
)
{
the_spinlock->Attributes = *the_spinlock_attributes;
3000ace8: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000acec: e5803000 str r3, [r0] <== NOT EXECUTED
the_spinlock->lock = 0;
3000acf0: e3a03000 mov r3, #0 <== NOT EXECUTED 3000acf4: e5803004 str r3, [r0, #4] <== NOT EXECUTED
the_spinlock->users = 0;
3000acf8: e5803008 str r3, [r0, #8] <== NOT EXECUTED
the_spinlock->holder = 0;
3000acfc: e580300c str r3, [r0, #12] <== NOT EXECUTED
}
3000ad00: e12fff1e bx lr <== NOT EXECUTED
3000ad04 <_CORE_spinlock_Release>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ad04: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000ad08: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000ad0c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Disable( level );
/*
* It must locked before it can be unlocked.
*/
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
3000ad10: e5902004 ldr r2, [r0, #4] <== NOT EXECUTED 3000ad14: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ad18: 1a000002 bne 3000ad28 <_CORE_spinlock_Release+0x24> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ad1c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_NOT_LOCKED;
3000ad20: e3a00006 mov r0, #6 <== NOT EXECUTED 3000ad24: e12fff1e bx lr <== NOT EXECUTED
}
/*
* It must locked by the current thread before it can be unlocked.
*/
if ( the_spinlock->holder != _Thread_Executing->Object.id ) {
3000ad28: e59f2040 ldr r2, [pc, #64] ; 3000ad70 <_CORE_spinlock_Release+0x6c><== NOT EXECUTED 3000ad2c: e590100c ldr r1, [r0, #12] <== NOT EXECUTED 3000ad30: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 3000ad34: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000ad38: e1510002 cmp r1, r2 <== NOT EXECUTED 3000ad3c: 0a000002 beq 3000ad4c <_CORE_spinlock_Release+0x48> <== NOT EXECUTED 3000ad40: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_NOT_HOLDER;
3000ad44: e3a00002 mov r0, #2 <== NOT EXECUTED 3000ad48: e12fff1e bx lr <== NOT EXECUTED
}
/*
* Let it be unlocked.
*/
the_spinlock->users -= 1;
3000ad4c: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED 3000ad50: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000ad54: e5802008 str r2, [r0, #8] <== NOT EXECUTED
the_spinlock->lock = CORE_SPINLOCK_UNLOCKED;
3000ad58: e3a02000 mov r2, #0 <== NOT EXECUTED 3000ad5c: e5802004 str r2, [r0, #4] <== NOT EXECUTED
the_spinlock->holder = 0;
3000ad60: e580200c str r2, [r0, #12] <== NOT EXECUTED 3000ad64: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_SUCCESSFUL;
3000ad68: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000ad6c: e12fff1e bx lr <== NOT EXECUTED
3000ad74 <_CORE_spinlock_Wait>:
CORE_spinlock_Status _CORE_spinlock_Wait(
CORE_spinlock_Control *the_spinlock,
bool wait,
Watchdog_Interval timeout
)
{
3000ad74: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000ad78: e1a04000 mov r4, r0 <== NOT EXECUTED
3000ad7c: e20160ff and r6, r1, #255 ; 0xff <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ad80: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000ad84: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000ad88: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout;
#endif
_ISR_Disable( level );
if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) &&
3000ad8c: e5902004 ldr r2, [r0, #4] <== NOT EXECUTED 3000ad90: e3520001 cmp r2, #1 <== NOT EXECUTED 3000ad94: 1a000008 bne 3000adbc <_CORE_spinlock_Wait+0x48> <== NOT EXECUTED
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
3000ad98: e59f20a0 ldr r2, [pc, #160] ; 3000ae40 <_CORE_spinlock_Wait+0xcc><== NOT EXECUTED 3000ad9c: e590100c ldr r1, [r0, #12] <== NOT EXECUTED 3000ada0: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout;
#endif
_ISR_Disable( level );
if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) &&
3000ada4: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000ada8: e1510002 cmp r1, r2 <== NOT EXECUTED 3000adac: 1a000002 bne 3000adbc <_CORE_spinlock_Wait+0x48> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000adb0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
_ISR_Enable( level );
return CORE_SPINLOCK_HOLDER_RELOCKING;
3000adb4: e3a00001 mov r0, #1 <== NOT EXECUTED
3000adb8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
}
the_spinlock->users += 1;
3000adbc: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000adc0: e59f507c ldr r5, [pc, #124] ; 3000ae44 <_CORE_spinlock_Wait+0xd0><== NOT EXECUTED 3000adc4: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000adc8: e5842008 str r2, [r4, #8] <== NOT EXECUTED
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
3000adcc: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000add0: e3520000 cmp r2, #0 <== NOT EXECUTED 3000add4: 1a000008 bne 3000adfc <_CORE_spinlock_Wait+0x88> <== NOT EXECUTED
the_spinlock->lock = CORE_SPINLOCK_LOCKED;
3000add8: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000addc: e5842004 str r2, [r4, #4] <== NOT EXECUTED
the_spinlock->holder = _Thread_Executing->Object.id;
3000ade0: e59f2058 ldr r2, [pc, #88] ; 3000ae40 <_CORE_spinlock_Wait+0xcc><== NOT EXECUTED 3000ade4: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 3000ade8: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000adec: e584200c str r2, [r4, #12] <== NOT EXECUTED 3000adf0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_SUCCESSFUL;
3000adf4: e3a00000 mov r0, #0 <== NOT EXECUTED
3000adf8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
}
/*
* Spinlock is unavailable. If not willing to wait, return.
*/
if ( !wait ) {
3000adfc: e3560000 cmp r6, #0 <== NOT EXECUTED 3000ae00: 1a000005 bne 3000ae1c <_CORE_spinlock_Wait+0xa8> <== NOT EXECUTED
the_spinlock->users -= 1;
3000ae04: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3000ae08: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000ae0c: e5842008 str r2, [r4, #8] <== NOT EXECUTED 3000ae10: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_UNAVAILABLE;
3000ae14: e3a00005 mov r0, #5 <== NOT EXECUTED
3000ae18: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000ae1c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
*/
_ISR_Enable( level );
/* An ISR could occur here */
_Thread_Enable_dispatch();
3000ae20: eb00057b bl 3000c414 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000ae24: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000ae28: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000ae2c: e5853000 str r3, [r5] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ae30: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000ae34: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000ae38: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
/* Reenter the critical sections so we can attempt the lock again. */
_Thread_Disable_dispatch();
_ISR_Disable( level );
}
3000ae3c: eaffffe2 b 3000adcc <_CORE_spinlock_Wait+0x58> <== NOT EXECUTED
3000a77c <_Chain_Append_with_empty_check>:
bool _Chain_Append_with_empty_check(
Chain_Control *chain,
Chain_Node *node
)
{
3000a77c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000a780: e1a03000 mov r3, r0 <== NOT EXECUTED
3000a784: e10f4000 mrs r4, CPSR <== NOT EXECUTED
3000a788: e3842080 orr r2, r4, #128 ; 0x80 <== NOT EXECUTED
3000a78c: 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;
3000a790: 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 );
3000a794: 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 )
3000a798: 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;
3000a79c: e5831008 str r1, [r3, #8] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3000a7a0: e581c000 str ip, [r1] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
3000a7a4: 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;
3000a7a8: e5821000 str r1, [r2] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000a7ac: e150000c cmp r0, ip <== NOT EXECUTED 3000a7b0: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a7b4: 03a00001 moveq r0, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a7b8: 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;
}
3000a7bc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a80c <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
3000a80c: e92d4010 push {r4, lr} <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a810: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000a814: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000a818: 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;
3000a81c: 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 );
3000a820: e280c004 add ip, r0, #4 <== NOT EXECUTED
Chain_Node *old_first = head->next;
if ( old_first != tail ) {
3000a824: e152000c cmp r2, ip <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
} else
*the_node = NULL;
3000a828: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000a82c: 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;
3000a830: 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 ) {
3000a834: 0a000006 beq 3000a854 <_Chain_Get_with_empty_check+0x48> <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
3000a838: e5923000 ldr r3, [r2] <== NOT EXECUTED
head->next = new_first;
3000a83c: e5803000 str r3, [r0] <== NOT EXECUTED
new_first->previous = head;
3000a840: e5830004 str r0, [r3, #4] <== NOT EXECUTED
*the_node = old_first;
3000a844: e5812000 str r2, [r1] <== NOT EXECUTED
is_empty_now = new_first == tail;
3000a848: e153000c cmp r3, ip <== NOT EXECUTED 3000a84c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a850: 03a00001 moveq r0, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a854: 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;
}
3000a858: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a8b8 <_Chain_Prepend_with_empty_check>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a8b8: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000a8bc: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000a8c0: 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;
}
3000a8c4: e5903000 ldr r3, [r0] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000a8c8: e5810004 str r0, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000a8cc: e4801004 str r1, [r0], #4 <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000a8d0: 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;
3000a8d4: e5813000 str r3, [r1] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a8d8: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3000a8dc: e1530000 cmp r3, r0 <== NOT EXECUTED 3000a8e0: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a8e4: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000a8e8: 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: e59470f8 ldr r7, [r4, #248] ; 0xf8
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: eb000d7f bl 3000c604 <_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: eb000c1e bl 3000c08c <_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: ea0008ea b 3000b3f4 <_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: e590c0f8 ldr ip, [r0, #248] ; 0xf8
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: eb000d6c bl 3000c764 <_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: ea0008de b 3000b53c <_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: eb0009a4 bl 3000b874 <_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: eb0008c1 bl 3000b53c <_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
3000f0b0 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f0b0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000f0b4: 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;
3000f0b8: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f0bc: e24dd01c sub sp, sp, #28 3000f0c0: 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 ) {
3000f0c4: e2913004 adds r3, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f0c8: e1a05000 mov r5, r0 3000f0cc: 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;
3000f0d0: 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 ) {
3000f0d4: e58d300c str r3, [sp, #12]
3000f0d8: 2a00006a bcs 3000f288 <_Heap_Allocate_aligned_with_boundary+0x1d8>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
3000f0dc: e35b0000 cmp fp, #0
3000f0e0: 0a000003 beq 3000f0f4 <_Heap_Allocate_aligned_with_boundary+0x44>
if ( boundary < alloc_size ) {
3000f0e4: e15b0001 cmp fp, r1 <== NOT EXECUTED 3000f0e8: 3a000066 bcc 3000f288 <_Heap_Allocate_aligned_with_boundary+0x1d8><== NOT EXECUTED
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
3000f0ec: e3580000 cmp r8, #0 <== NOT EXECUTED 3000f0f0: 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
3000f0f4: e59d2000 ldr r2, [sp]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000f0f8: 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
3000f0fc: e2822007 add r2, r2, #7
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000f100: 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 ) {
3000f104: 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
3000f108: e58d2014 str r2, [sp, #20]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000f10c: 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 ) {
3000f110: ea000048 b 3000f238 <_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 ) {
3000f114: e59a4004 ldr r4, [sl, #4] 3000f118: e59d200c ldr r2, [sp, #12] 3000f11c: e1540002 cmp r4, r2
3000f120: 9a00003f bls 3000f224 <_Heap_Allocate_aligned_with_boundary+0x174>
3000f124: e28a3008 add r3, sl, #8
if ( alignment == 0 ) {
3000f128: e3580000 cmp r8, #0 3000f12c: 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;
3000f130: 01a04003 moveq r4, r3
3000f134: 0a00003b beq 3000f228 <_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;
3000f138: 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;
3000f13c: 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;
3000f140: 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;
3000f144: 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;
3000f148: e3c44001 bic r4, r4, #1
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000f14c: 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;
3000f150: 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
3000f154: 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;
3000f158: e0824004 add r4, r2, r4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000f15c: e1a00004 mov r0, r4 3000f160: e1a01008 mov r1, r8 3000f164: eb001631 bl 30014a30 <__umodsi3> 3000f168: 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 ) {
3000f16c: e1540009 cmp r4, r9
3000f170: 9a000003 bls 3000f184 <_Heap_Allocate_aligned_with_boundary+0xd4>
3000f174: e1a00009 mov r0, r9 3000f178: e1a01008 mov r1, r8 3000f17c: eb00162b bl 30014a30 <__umodsi3> 3000f180: e0604009 rsb r4, r0, r9
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
3000f184: e35b0000 cmp fp, #0
3000f188: 0a000014 beq 3000f1e0 <_Heap_Allocate_aligned_with_boundary+0x130>
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000f18c: 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;
3000f190: e0849006 add r9, r4, r6 <== NOT EXECUTED
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000f194: e0833006 add r3, r3, r6 <== NOT EXECUTED 3000f198: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 3000f19c: ea000008 b 3000f1c4 <_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 ) {
3000f1a0: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000f1a4: e1500002 cmp r0, r2 <== NOT EXECUTED 3000f1a8: 3a00001d bcc 3000f224 <_Heap_Allocate_aligned_with_boundary+0x174><== NOT EXECUTED
return 0;
}
alloc_begin = boundary_line - alloc_size;
3000f1ac: e0664000 rsb r4, r6, r0 <== NOT EXECUTED 3000f1b0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f1b4: e1a01008 mov r1, r8 <== NOT EXECUTED 3000f1b8: eb00161c bl 30014a30 <__umodsi3> <== NOT EXECUTED 3000f1bc: e0604004 rsb r4, r0, r4 <== NOT EXECUTED
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
3000f1c0: e0849006 add r9, r4, r6 <== NOT EXECUTED 3000f1c4: e1a00009 mov r0, r9 <== NOT EXECUTED 3000f1c8: e1a0100b mov r1, fp <== NOT EXECUTED 3000f1cc: eb001617 bl 30014a30 <__umodsi3> <== NOT EXECUTED 3000f1d0: 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 ) {
3000f1d4: e1500009 cmp r0, r9 <== NOT EXECUTED 3000f1d8: 31540000 cmpcc r4, r0 <== NOT EXECUTED 3000f1dc: 3affffef bcc 3000f1a0 <_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 ) {
3000f1e0: e59d3008 ldr r3, [sp, #8] 3000f1e4: e1540003 cmp r4, r3
3000f1e8: 3a00000d bcc 3000f224 <_Heap_Allocate_aligned_with_boundary+0x174>
3000f1ec: e1a00004 mov r0, r4 3000f1f0: e59d1000 ldr r1, [sp] 3000f1f4: eb00160d bl 30014a30 <__umodsi3> 3000f1f8: e3e09007 mvn r9, #7 3000f1fc: 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);
3000f200: e0899004 add r9, r9, r4
if ( free_size >= min_block_size || free_size == 0 ) {
return alloc_begin;
}
}
return 0;
3000f204: 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 ) {
3000f208: e0603009 rsb r3, r0, r9
return alloc_begin;
}
}
return 0;
3000f20c: e1590000 cmp r9, r0 3000f210: 11530002 cmpne r3, r2 3000f214: 33a09000 movcc r9, #0 3000f218: 23a09001 movcs r9, #1 3000f21c: 31a04009 movcc r4, r9 3000f220: ea000000 b 3000f228 <_Heap_Allocate_aligned_with_boundary+0x178> 3000f224: e3a04000 mov r4, #0
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
3000f228: e3540000 cmp r4, #0
);
}
}
/* Statistics */
++search_count;
3000f22c: e2877001 add r7, r7, #1
if ( alloc_begin != 0 ) {
3000f230: 1a000004 bne 3000f248 <_Heap_Allocate_aligned_with_boundary+0x198>
break;
}
block = block->next;
3000f234: 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 ) {
3000f238: e15a0005 cmp sl, r5
3000f23c: 1affffb4 bne 3000f114 <_Heap_Allocate_aligned_with_boundary+0x64>
3000f240: e3a04000 mov r4, #0 3000f244: ea00000a b 3000f274 <_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;
3000f248: e5953048 ldr r3, [r5, #72] ; 0x48
stats->searches += search_count;
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000f24c: e1a00005 mov r0, r5
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000f250: e2833001 add r3, r3, #1 3000f254: e5853048 str r3, [r5, #72] ; 0x48
stats->searches += search_count;
3000f258: e595304c ldr r3, [r5, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000f25c: e1a0100a mov r1, sl
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
stats->searches += search_count;
3000f260: e0833007 add r3, r3, r7 3000f264: e585304c str r3, [r5, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000f268: e1a02004 mov r2, r4 3000f26c: e1a03006 mov r3, r6 3000f270: ebffecd2 bl 3000a5c0 <_Heap_Block_allocate>
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000f274: e5953044 ldr r3, [r5, #68] ; 0x44
stats->max_search = search_count;
}
return (void *) alloc_begin;
3000f278: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000f27c: e1530007 cmp r3, r7
stats->max_search = search_count;
3000f280: 35857044 strcc r7, [r5, #68] ; 0x44
}
return (void *) alloc_begin;
3000f284: ea000000 b 3000f28c <_Heap_Allocate_aligned_with_boundary+0x1dc>
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
3000f288: e3a00000 mov r0, #0
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000f28c: e28dd01c add sp, sp, #28
3000f290: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000a5c0 <_Heap_Block_allocate>:
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000a5c0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000a5c4: 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;
3000a5c8: e2426008 sub r6, r2, #8
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000a5cc: e1a04001 mov r4, r1 3000a5d0: 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;
3000a5d4: 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;
3000a5d8: 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);
3000a5dc: e0849001 add r9, r4, r1
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000a5e0: 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;
3000a5e4: e5990004 ldr r0, [r9, #4]
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000a5e8: 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 );
3000a5ec: 11a08005 movne r8, r5
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000a5f0: 1a00000c bne 3000a628 <_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;
3000a5f4: e5940008 ldr r0, [r4, #8]
free_list_anchor = block->prev;
3000a5f8: e594800c ldr r8, [r4, #12]
Heap_Block *prev = block->prev;
prev->next = next;
3000a5fc: e5880008 str r0, [r8, #8]
next->prev = prev;
3000a600: e580800c str r8, [r0, #12]
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000a604: e5950038 ldr r0, [r5, #56] ; 0x38 3000a608: e2400001 sub r0, r0, #1 3000a60c: e5850038 str r0, [r5, #56] ; 0x38
++stats->used_blocks;
3000a610: e5950040 ldr r0, [r5, #64] ; 0x40 3000a614: e2800001 add r0, r0, #1 3000a618: e5850040 str r0, [r5, #64] ; 0x40
stats->free_size -= _Heap_Block_size( block );
3000a61c: e5950030 ldr r0, [r5, #48] ; 0x30 3000a620: e0611000 rsb r1, r1, r0 3000a624: e5851030 str r1, [r5, #48] ; 0x30
} else {
free_list_anchor = _Heap_Free_list_head( heap );
}
if ( alloc_area_offset < heap->page_size ) {
3000a628: e5951010 ldr r1, [r5, #16] 3000a62c: e1530001 cmp r3, r1
3000a630: 2a000005 bcs 3000a64c <_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 );
3000a634: e1a00005 mov r0, r5 3000a638: e1a01004 mov r1, r4 3000a63c: e1a02008 mov r2, r8 3000a640: e0833007 add r3, r3, r7 3000a644: ebffff31 bl 3000a310 <_Heap_Block_split> 3000a648: ea000021 b 3000a6d4 <_Heap_Block_allocate+0x114>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000a64c: e1a00002 mov r0, r2 3000a650: eb0028f6 bl 30014a30 <__umodsi3>
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000a654: 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);
3000a658: 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;
3000a65c: 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;
3000a660: e0822003 add r2, r2, r3
if ( _Heap_Is_prev_used( block ) ) {
3000a664: 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;
3000a668: 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;
3000a66c: e5852030 str r2, [r5, #48] ; 0x30
if ( _Heap_Is_prev_used( block ) ) {
3000a670: 0a000009 beq 3000a69c <_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;
3000a674: e5982008 ldr r2, [r8, #8]
new_block->next = next;
new_block->prev = block_before;
3000a678: e584800c str r8, [r4, #12]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
3000a67c: e5842008 str r2, [r4, #8]
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
3000a680: e582400c str r4, [r2, #12]
_Heap_Free_list_insert_after( free_list_anchor, block );
free_list_anchor = block;
/* Statistics */
++stats->free_blocks;
3000a684: 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;
3000a688: e5884008 str r4, [r8, #8] 3000a68c: e2822001 add r2, r2, #1 3000a690: e5852038 str r2, [r5, #56] ; 0x38 3000a694: e1a02004 mov r2, r4 3000a698: ea000005 b 3000a6b4 <_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);
3000a69c: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000a6a0: 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;
3000a6a4: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000a6a8: 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;
3000a6ac: e0833002 add r3, r3, r2 <== NOT EXECUTED 3000a6b0: e1a02008 mov r2, r8 <== NOT EXECUTED
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
3000a6b4: e3831001 orr r1, r3, #1 3000a6b8: e5841004 str r1, [r4, #4]
new_block->prev_size = block_size;
3000a6bc: e8860208 stm r6, {r3, r9}
new_block->size_and_flag = new_block_size;
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
3000a6c0: e1a00005 mov r0, r5 3000a6c4: e1a01006 mov r1, r6 3000a6c8: e1a03007 mov r3, r7 3000a6cc: ebffff0f bl 3000a310 <_Heap_Block_split> 3000a6d0: e1a04006 mov r4, r6
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000a6d4: e5953030 ldr r3, [r5, #48] ; 0x30 3000a6d8: e5952034 ldr r2, [r5, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000a6dc: e1a00004 mov r0, r4
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000a6e0: e1520003 cmp r2, r3
stats->min_free_size = stats->free_size;
3000a6e4: 85853034 strhi r3, [r5, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000a6e8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
3000a310 <_Heap_Block_split>:
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000a310: 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;
3000a314: e5908014 ldr r8, [r0, #20]
uintptr_t alloc_size
)
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const page_size = heap->page_size;
3000a318: 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;
3000a31c: 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;
3000a320: e153000b cmp r3, fp 3000a324: 21a0b003 movcs fp, r3
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const used_size =
3000a328: e28bb008 add fp, fp, #8
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000a32c: e1a05001 mov r5, r1
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000a330: e5919004 ldr r9, [r1, #4]
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000a334: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000a338: e1a0100a mov r1, sl 3000a33c: e1a0000b mov r0, fp 3000a340: e1a06002 mov r6, r2 3000a344: eb0029b9 bl 30014a30 <__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;
3000a348: e3c97001 bic r7, r9, #1
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
3000a34c: 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;
3000a350: e2872004 add r2, r7, #4
return value - remainder + alignment;
3000a354: 108ba00a addne sl, fp, sl
} else {
return value;
3000a358: 01a0a00b moveq sl, fp
uintptr_t const free_size_limit = min_block_size + HEAP_ALLOC_BONUS;
3000a35c: 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;
3000a360: e06bb002 rsb fp, fp, r2
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
3000a364: 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);
3000a368: 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 ) {
3000a36c: 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;
3000a370: 35932004 ldrcc r2, [r3, #4] 3000a374: 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 ) {
3000a378: 3a000023 bcc 3000a40c <_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;
3000a37c: 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;
3000a380: 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;
3000a384: 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);
3000a388: 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;
3000a38c: e18aa009 orr sl, sl, r9 3000a390: 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;
3000a394: e0811007 add r1, r1, r7 3000a398: 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;
3000a39c: e5931004 ldr r1, [r3, #4] 3000a3a0: e3c11001 bic r1, r1, #1
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000a3a4: 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;
3000a3a8: 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 ) ) {
3000a3ac: e3100001 tst r0, #1
3000a3b0: 0a000008 beq 3000a3d8 <_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;
3000a3b4: e5961008 ldr r1, [r6, #8]
new_block->next = next;
new_block->prev = block_before;
3000a3b8: e582600c str r6, [r2, #12]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
3000a3bc: e5821008 str r1, [r2, #8]
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
3000a3c0: e581200c str r2, [r1, #12]
_Heap_Free_list_insert_after( free_list_anchor, free_block );
/* Statistics */
++stats->free_blocks;
3000a3c4: 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;
3000a3c8: e5862008 str r2, [r6, #8] 3000a3cc: e2811001 add r1, r1, #1 3000a3d0: e5841038 str r1, [r4, #56] ; 0x38 3000a3d4: ea000007 b 3000a3f8 <_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;
3000a3d8: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
Heap_Block *prev = old_block->prev;
3000a3dc: 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;
3000a3e0: e0877001 add r7, r7, r1 <== NOT EXECUTED
new_block->next = next;
new_block->prev = prev;
3000a3e4: e582300c str r3, [r2, #12] <== NOT EXECUTED
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
3000a3e8: e5820008 str r0, [r2, #8] <== NOT EXECUTED
new_block->prev = prev;
next->prev = new_block;
3000a3ec: e580200c str r2, [r0, #12] <== NOT EXECUTED
prev->next = new_block;
3000a3f0: 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);
3000a3f4: 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;
3000a3f8: e3871001 orr r1, r7, #1 3000a3fc: e5821004 str r1, [r2, #4]
next_block->prev_size = free_block_size;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000a400: 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;
3000a404: e5837000 str r7, [r3]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000a408: e3c22001 bic r2, r2, #1
_Heap_Protection_block_initialize( heap, free_block );
} else {
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000a40c: e5832004 str r2, [r3, #4]
3000a410: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000f5cc <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
3000f5cc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3000f5d0: e1a05001 mov r5, r1 <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
3000f5d4: 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
)
{
3000f5d8: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 3000f5dc: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
3000f5e0: 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;
3000f5e4: 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;
3000f5e8: 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;
3000f5ec: 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 ) {
3000f5f0: 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
)
{
3000f5f4: 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;
3000f5f8: 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;
3000f5fc: 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;
3000f600: 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;
3000f604: 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;
3000f608: 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;
3000f60c: 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 ) {
3000f610: 2a00009d bcs 3000f88c <_Heap_Extend+0x2c0> <== NOT EXECUTED
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
3000f614: e28d1024 add r1, sp, #36 ; 0x24 <== NOT EXECUTED 3000f618: e58d1000 str r1, [sp] <== NOT EXECUTED 3000f61c: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000f620: e58d1004 str r1, [sp, #4] <== NOT EXECUTED 3000f624: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f628: e1a01002 mov r1, r2 <== NOT EXECUTED 3000f62c: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 3000f630: ebffec4d bl 3000a76c <_Heap_Get_first_and_last_block> <== NOT EXECUTED
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
3000f634: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f638: 0a000093 beq 3000f88c <_Heap_Extend+0x2c0> <== NOT EXECUTED 3000f63c: e59da010 ldr sl, [sp, #16] <== NOT EXECUTED 3000f640: e1a07008 mov r7, r8 <== NOT EXECUTED 3000f644: 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;
3000f648: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED 3000f64c: e1a03008 mov r3, r8 <== NOT EXECUTED 3000f650: e1a0c004 mov ip, r4 <== NOT EXECUTED 3000f654: ea000000 b 3000f65c <_Heap_Extend+0x90> <== NOT EXECUTED 3000f658: e1a0100a mov r1, sl <== NOT EXECUTED
uintptr_t const sub_area_end = start_block->prev_size;
3000f65c: e59a4000 ldr r4, [sl] <== NOT EXECUTED
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
3000f660: e1560001 cmp r6, r1 <== NOT EXECUTED 3000f664: 93a00000 movls r0, #0 <== NOT EXECUTED 3000f668: 83a00001 movhi r0, #1 <== NOT EXECUTED 3000f66c: e1550004 cmp r5, r4 <== NOT EXECUTED 3000f670: 23a00000 movcs r0, #0 <== NOT EXECUTED 3000f674: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f678: 1a000082 bne 3000f888 <_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 ) {
3000f67c: e1560001 cmp r6, r1 <== NOT EXECUTED 3000f680: 01a0300a moveq r3, sl <== NOT EXECUTED 3000f684: 0a000001 beq 3000f690 <_Heap_Extend+0xc4> <== NOT EXECUTED
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
3000f688: e1560004 cmp r6, r4 <== NOT EXECUTED 3000f68c: 31a0900a movcc r9, sl <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000f690: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f694: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 3000f698: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000f69c: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 3000f6a0: eb001637 bl 30014f84 <__umodsi3> <== NOT EXECUTED 3000f6a4: e244b008 sub fp, r4, #8 <== NOT EXECUTED
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
3000f6a8: 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);
3000f6ac: e060000b rsb r0, r0, fp <== NOT EXECUTED 3000f6b0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3000f6b4: 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 )
3000f6b8: 01a07000 moveq r7, r0 <== NOT EXECUTED
start_block->prev_size = extend_area_end;
3000f6bc: 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 ) {
3000f6c0: 0a000000 beq 3000f6c8 <_Heap_Extend+0xfc> <== NOT EXECUTED 3000f6c4: 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;
3000f6c8: 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 );
3000f6cc: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000f6d0: 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);
3000f6d4: e080a00a add sl, r0, sl <== NOT EXECUTED 3000f6d8: e15a0002 cmp sl, r2 <== NOT EXECUTED 3000f6dc: 1affffdd bne 3000f658 <_Heap_Extend+0x8c> <== NOT EXECUTED 3000f6e0: e1a02009 mov r2, r9 <== NOT EXECUTED 3000f6e4: e1a09003 mov r9, r3 <== NOT EXECUTED
if ( extend_area_begin < heap->area_begin ) {
3000f6e8: e59c3018 ldr r3, [ip, #24] <== NOT EXECUTED 3000f6ec: e1a0400c mov r4, ip <== NOT EXECUTED 3000f6f0: e1550003 cmp r5, r3 <== NOT EXECUTED
heap->area_begin = extend_area_begin;
3000f6f4: 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 ) {
3000f6f8: 3a000002 bcc 3000f708 <_Heap_Extend+0x13c> <== NOT EXECUTED
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
3000f6fc: e59c301c ldr r3, [ip, #28] <== NOT EXECUTED 3000f700: e1530006 cmp r3, r6 <== NOT EXECUTED
heap->area_end = extend_area_end;
3000f704: 358c601c strcc r6, [ip, #28] <== NOT EXECUTED
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
3000f708: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000f70c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
extend_first_block->prev_size = extend_area_end;
3000f710: 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 =
3000f714: 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;
3000f718: e380c001 orr ip, r0, #1 <== NOT EXECUTED
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
3000f71c: e5830000 str r0, [r3] <== NOT EXECUTED
extend_last_block->size_and_flag = 0;
3000f720: 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 =
3000f724: 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;
3000f728: 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 ) {
3000f72c: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED 3000f730: e1500001 cmp r0, r1 <== NOT EXECUTED
heap->first_block = extend_first_block;
3000f734: 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 ) {
3000f738: 8a000002 bhi 3000f748 <_Heap_Extend+0x17c> <== NOT EXECUTED
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
3000f73c: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000f740: e1510003 cmp r1, r3 <== NOT EXECUTED
heap->last_block = extend_last_block;
3000f744: 35843024 strcc r3, [r4, #36] ; 0x24 <== NOT EXECUTED
}
if ( merge_below_block != NULL ) {
3000f748: e3590000 cmp r9, #0 <== NOT EXECUTED 3000f74c: 0a000010 beq 3000f794 <_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;
3000f750: 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 );
3000f754: 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;
3000f758: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f75c: e1a0100a mov r1, sl <== NOT EXECUTED 3000f760: eb001607 bl 30014f84 <__umodsi3> <== NOT EXECUTED
if ( remainder != 0 ) {
3000f764: e3500000 cmp r0, #0 <== NOT EXECUTED
return value - remainder + alignment;
3000f768: 1085500a addne r5, r5, sl <== NOT EXECUTED 3000f76c: 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;
3000f770: 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 =
3000f774: 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;
3000f778: 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 =
3000f77c: 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;
3000f780: e3833001 orr r3, r3, #1 <== NOT EXECUTED 3000f784: e5053004 str r3, [r5, #-4] <== NOT EXECUTED
_Heap_Free_block( heap, new_first_block );
3000f788: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f78c: ebffff86 bl 3000f5ac <_Heap_Free_block> <== NOT EXECUTED 3000f790: ea000004 b 3000f7a8 <_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 ) {
3000f794: e3520000 cmp r2, #0 <== NOT EXECUTED
_Heap_Link_below(
3000f798: 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;
3000f79c: 10632002 rsbne r2, r3, r2 <== NOT EXECUTED 3000f7a0: 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 =
3000f7a4: 15832004 strne r2, [r3, #4] <== NOT EXECUTED
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
3000f7a8: e3570000 cmp r7, #0 <== NOT EXECUTED 3000f7ac: 0a000012 beq 3000f7fc <_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,
3000f7b0: 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(
3000f7b4: 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);
3000f7b8: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED 3000f7bc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000f7c0: eb0015ef bl 30014f84 <__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)
3000f7c4: e5972004 ldr r2, [r7, #4] <== NOT EXECUTED 3000f7c8: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3000f7cc: 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 =
3000f7d0: e0863007 add r3, r6, r7 <== NOT EXECUTED
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
3000f7d4: 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 =
3000f7d8: 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;
3000f7dc: 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 );
3000f7e0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f7e4: e2033001 and r3, r3, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3000f7e8: e1866003 orr r6, r6, r3 <== NOT EXECUTED 3000f7ec: e5876004 str r6, [r7, #4] <== NOT EXECUTED 3000f7f0: e1a01007 mov r1, r7 <== NOT EXECUTED 3000f7f4: ebffff6c bl 3000f5ac <_Heap_Free_block> <== NOT EXECUTED 3000f7f8: ea00000b b 3000f82c <_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 ) {
3000f7fc: e3580000 cmp r8, #0 <== NOT EXECUTED 3000f800: 0a000009 beq 3000f82c <_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;
3000f804: 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 );
3000f808: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000f80c: e2022001 and r2, r2, #1 <== NOT EXECUTED 3000f810: 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(
3000f814: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
block->size_and_flag = size | flag;
3000f818: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000f81c: 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;
3000f820: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000f824: e3822001 orr r2, r2, #1 <== NOT EXECUTED 3000f828: e5832004 str r2, [r3, #4] <== NOT EXECUTED
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
3000f82c: e3570000 cmp r7, #0 <== NOT EXECUTED 3000f830: 03590000 cmpeq r9, #0 <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
3000f834: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000f838: 059d1024 ldreq r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000f83c: 0bffff5a bleq 3000f5ac <_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
3000f840: 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(
3000f844: 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;
3000f848: 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(
3000f84c: 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;
3000f850: e2022001 and r2, r2, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3000f854: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000f858: e5832004 str r2, [r3, #4] <== NOT EXECUTED
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
3000f85c: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3000f860: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
3000f864: 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;
3000f868: e0613003 rsb r3, r1, r3 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
3000f86c: e0822003 add r2, r2, r3 <== NOT EXECUTED 3000f870: e584202c str r2, [r4, #44] ; 0x2c <== NOT EXECUTED
if ( extended_size_ptr != NULL )
3000f874: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
*extended_size_ptr = extended_size;
return true;
3000f878: e3a00001 mov r0, #1 <== NOT EXECUTED
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
3000f87c: e3520000 cmp r2, #0 <== NOT EXECUTED
*extended_size_ptr = extended_size;
3000f880: 15823000 strne r3, [r2] <== NOT EXECUTED 3000f884: ea000000 b 3000f88c <_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;
3000f888: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
3000f88c: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
3000f890: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000f5ac <_Heap_Free_block>:
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block )
{
Heap_Statistics *const stats = &heap->stats;
/* Statistics */
++stats->used_blocks;
3000f5ac: e5902040 ldr r2, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ));
3000f5b0: 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;
3000f5b4: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000f5b8: e5802040 str r2, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
3000f5bc: e5902050 ldr r2, [r0, #80] ; 0x50 <== NOT EXECUTED 3000f5c0: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000f5c4: e5802050 str r2, [r0, #80] ; 0x50 <== NOT EXECUTED
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ));
3000f5c8: ea0000b1 b 3000f894 <_Heap_Free> <== NOT EXECUTED
3000a4a0 <_Heap_Initialize>:
Heap_Control *heap,
void *heap_area_begin_ptr,
uintptr_t heap_area_size,
uintptr_t page_size
)
{
3000a4a0: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr}
3000a4a4: 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 ) {
3000a4a8: 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;
3000a4ac: e3a02000 mov r2, #0
Heap_Control *heap,
void *heap_area_begin_ptr,
uintptr_t heap_area_size,
uintptr_t page_size
)
{
3000a4b0: e1a04000 mov r4, r0 3000a4b4: 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;
3000a4b8: e58d200c str r2, [sp, #12]
Heap_Block *last_block = NULL;
3000a4bc: e58d2008 str r2, [sp, #8]
if ( page_size == 0 ) {
page_size = CPU_ALIGNMENT;
3000a4c0: 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 ) {
3000a4c4: 0a000004 beq 3000a4dc <_Heap_Initialize+0x3c>
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
3000a4c8: e2153007 ands r3, r5, #7
return value - remainder + alignment;
3000a4cc: 12855008 addne r5, r5, #8 3000a4d0: 10635005 rsbne r5, r3, r5
page_size = CPU_ALIGNMENT;
} else {
page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT );
if ( page_size < CPU_ALIGNMENT ) {
3000a4d4: e3550007 cmp r5, #7
3000a4d8: 9a000034 bls 3000a5b0 <_Heap_Initialize+0x110>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000a4dc: e1a01005 mov r1, r5 3000a4e0: e3a00010 mov r0, #16 3000a4e4: eb002951 bl 30014a30 <__umodsi3>
if ( remainder != 0 ) {
3000a4e8: e3500000 cmp r0, #0
return value - remainder + alignment;
3000a4ec: 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(
3000a4f0: e28d300c add r3, sp, #12 3000a4f4: 10607007 rsbne r7, r0, r7
} else {
return value;
3000a4f8: 03a07010 moveq r7, #16 3000a4fc: e58d3000 str r3, [sp] 3000a500: e28d3008 add r3, sp, #8 3000a504: e58d3004 str r3, [sp, #4] 3000a508: e1a00006 mov r0, r6 3000a50c: e1a01008 mov r1, r8 3000a510: e1a02005 mov r2, r5 3000a514: e1a03007 mov r3, r7 3000a518: ebffffbd bl 3000a414 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&first_block,
&last_block
);
if ( !area_ok ) {
3000a51c: e3500000 cmp r0, #0
3000a520: 0a000023 beq 3000a5b4 <_Heap_Initialize+0x114>
return 0;
}
memset(heap, 0, sizeof(*heap));
3000a524: e3a01000 mov r1, #0 3000a528: e3a02058 mov r2, #88 ; 0x58 3000a52c: e1a00004 mov r0, r4 3000a530: eb001d48 bl 30011a58 <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;
3000a534: e59d300c ldr r3, [sp, #12]
last_block_begin = (uintptr_t) last_block;
3000a538: 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;
3000a53c: 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;
3000a540: 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;
3000a544: 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;
3000a548: e5838000 str r8, [r3]
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
3000a54c: e9830012 stmib r3, {r1, r4}
first_block->next = _Heap_Free_list_tail( heap ); first_block->prev = _Heap_Free_list_head( heap );
3000a550: 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;
3000a554: 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;
3000a558: 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;
3000a55c: 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(
3000a560: 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;
3000a564: 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;
3000a568: e5845010 str r5, [r4, #16]
heap->min_block_size = min_block_size;
3000a56c: e5847014 str r7, [r4, #20]
heap->area_begin = heap_area_begin;
3000a570: e5846018 str r6, [r4, #24]
heap->area_end = heap_area_end;
3000a574: 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;
3000a578: 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;
3000a57c: 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;
3000a580: 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;
3000a584: e5843038 str r3, [r4, #56] ; 0x38
stats->max_free_blocks = 1;
3000a588: e584303c str r3, [r4, #60] ; 0x3c
stats->instance = instance++;
3000a58c: e59f3028 ldr r3, [pc, #40] ; 3000a5bc <_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;
3000a590: 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++;
3000a594: 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;
3000a598: 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++;
3000a59c: e5842028 str r2, [r4, #40] ; 0x28 3000a5a0: 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;
3000a5a4: e5840034 str r0, [r4, #52] ; 0x34
stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++;
3000a5a8: e5832000 str r2, [r3]
);
_HAssert(
_Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size )
);
return first_block_size;
3000a5ac: ea000000 b 3000a5b4 <_Heap_Initialize+0x114>
} else {
page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT );
if ( page_size < CPU_ALIGNMENT ) {
/* Integer overflow */
return 0;
3000a5b0: e3a00000 mov r0, #0 <== NOT EXECUTED
_HAssert(
_Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size )
);
return first_block_size;
}
3000a5b4: e28dd010 add sp, sp, #16
3000a5b8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
30016d8c <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
30016d8c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30016d90: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30016d94: e241a008 sub sl, r1, #8 30016d98: e1a00001 mov r0, r1 30016d9c: e1a05001 mov r5, r1 30016da0: e5941010 ldr r1, [r4, #16] 30016da4: e1a08003 mov r8, r3 30016da8: e1a07002 mov r7, r2 30016dac: ebfff71f bl 30014a30 <__umodsi3> 30016db0: 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;
30016db4: e3a03000 mov r3, #0 30016db8: e5883000 str r3, [r8]
*new_size = 0;
30016dbc: 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;
30016dc0: 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);
30016dc4: 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;
30016dc8: e1530001 cmp r3, r1
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
30016dcc: 83a00002 movhi r0, #2
30016dd0: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
30016dd4: e5943024 ldr r3, [r4, #36] ; 0x24
30016dd8: e1530001 cmp r3, r1
30016ddc: 3a000035 bcc 30016eb8 <_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;
30016de0: 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;
30016de4: e265c004 rsb ip, r5, #4 30016de8: 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;
30016dec: e0812003 add r2, r1, r3 30016df0: e5920004 ldr r0, [r2, #4]
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
30016df4: e08cc002 add ip, ip, r2 30016df8: e3c00001 bic r0, r0, #1
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
30016dfc: 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;
30016e00: 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;
30016e04: e588c000 str ip, [r8]
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
30016e08: e31a0001 tst sl, #1 30016e0c: 13a0a000 movne sl, #0 30016e10: 03a0a001 moveq sl, #1
if ( next_block_is_free ) {
30016e14: e35a0000 cmp sl, #0
block_size += next_block_size;
alloc_size += next_block_size;
30016e18: 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;
30016e1c: 10833000 addne r3, r3, r0
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
30016e20: e157000c cmp r7, ip
return HEAP_RESIZE_UNSATISFIED;
30016e24: 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 ) {
30016e28: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
30016e2c: e35a0000 cmp sl, #0
30016e30: 0a000011 beq 30016e7c <_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;
30016e34: e591c004 ldr ip, [r1, #4] <== NOT EXECUTED 30016e38: e20cc001 and ip, ip, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
30016e3c: e183c00c orr ip, r3, ip <== NOT EXECUTED 30016e40: 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;
30016e44: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
Heap_Block *prev = block->prev;
30016e48: 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);
30016e4c: 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;
30016e50: e582c008 str ip, [r2, #8] <== NOT EXECUTED
next->prev = prev;
30016e54: 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;
30016e58: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 30016e5c: e3822001 orr r2, r2, #1 <== NOT EXECUTED 30016e60: e5832004 str r2, [r3, #4] <== NOT EXECUTED
/* Statistics */
--stats->free_blocks;
30016e64: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 30016e68: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30016e6c: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
stats->free_size -= next_block_size;
30016e70: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED 30016e74: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 30016e78: e5840030 str r0, [r4, #48] ; 0x30 <== NOT EXECUTED
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
30016e7c: e1a02005 mov r2, r5 30016e80: e1a03007 mov r3, r7 30016e84: e1a00004 mov r0, r4 30016e88: ebffcdcc bl 3000a5c0 <_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;
30016e8c: e5903004 ldr r3, [r0, #4] 30016e90: 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);
30016e94: 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;
30016e98: e0655003 rsb r5, r5, r3 30016e9c: e0800005 add r0, r0, r5 30016ea0: e5860000 str r0, [r6]
/* Statistics */
++stats->resizes;
30016ea4: e5943054 ldr r3, [r4, #84] ; 0x54
return HEAP_RESIZE_SUCCESSFUL;
30016ea8: 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;
30016eac: e2833001 add r3, r3, #1
30016eb0: e5843054 str r3, [r4, #84] ; 0x54
30016eb4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
30016eb8: e3a00002 mov r0, #2 <== NOT EXECUTED
}
30016ebc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000b308 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000b308: 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;
3000b30c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000b310: 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;
3000b314: e58d3024 str r3, [sp, #36] ; 0x24 <== NOT EXECUTED
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
3000b318: 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;
3000b31c: e59f4500 ldr r4, [pc, #1280] ; 3000b824 <_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;
3000b320: 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;
3000b324: e59f34fc ldr r3, [pc, #1276] ; 3000b828 <_Heap_Walk+0x520> <== NOT EXECUTED 3000b328: e31200ff tst r2, #255 ; 0xff <== NOT EXECUTED 3000b32c: 11a04003 movne r4, r3 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000b330: e59f34f4 ldr r3, [pc, #1268] ; 3000b82c <_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;
3000b334: 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() ) ) {
3000b338: e5933000 ldr r3, [r3] <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000b33c: 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() ) ) {
3000b340: e3530003 cmp r3, #3 <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000b344: e1a05001 mov r5, r1 <== NOT EXECUTED
uintptr_t const page_size = heap->page_size;
3000b348: 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;
3000b34c: 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() ) ) {
3000b350: 1a000127 bne 3000b7f4 <_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)(
3000b354: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b358: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000b35c: e58dc000 str ip, [sp] <== NOT EXECUTED 3000b360: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED 3000b364: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000b368: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 3000b36c: e58d200c str r2, [sp, #12] <== NOT EXECUTED 3000b370: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000b374: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000b378: e59f24b0 ldr r2, [pc, #1200] ; 3000b830 <_Heap_Walk+0x528> <== NOT EXECUTED 3000b37c: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 3000b380: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED 3000b384: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 3000b388: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000b38c: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b390: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000b394: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b398: e1a03009 mov r3, r9 <== NOT EXECUTED 3000b39c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b3a0: 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 ) {
3000b3a4: e3590000 cmp r9, #0 <== NOT EXECUTED 3000b3a8: 1a000006 bne 3000b3c8 <_Heap_Walk+0xc0> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
3000b3ac: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b3b0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b3b4: e59f2478 ldr r2, [pc, #1144] ; 3000b834 <_Heap_Walk+0x52c> <== NOT EXECUTED 3000b3b8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b3bc: 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;
3000b3c0: e1a08009 mov r8, r9 <== NOT EXECUTED 3000b3c4: ea00010b b 3000b7f8 <_Heap_Walk+0x4f0> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
3000b3c8: e2198007 ands r8, r9, #7 <== NOT EXECUTED
(*printer)(
3000b3cc: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b3d0: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b3d4: 159f245c ldrne r2, [pc, #1116] ; 3000b838 <_Heap_Walk+0x530><== NOT EXECUTED 3000b3d8: 11a03009 movne r3, r9 <== NOT EXECUTED 3000b3dc: 1a00010c bne 3000b814 <_Heap_Walk+0x50c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000b3e0: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b3e4: e1a01009 mov r1, r9 <== NOT EXECUTED 3000b3e8: ebffe736 bl 300050c8 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
3000b3ec: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3000b3f0: 0a000006 beq 3000b410 <_Heap_Walk+0x108> <== NOT EXECUTED
(*printer)(
3000b3f4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b3f8: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b3fc: e59f2438 ldr r2, [pc, #1080] ; 3000b83c <_Heap_Walk+0x534> <== NOT EXECUTED 3000b400: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b404: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b408: e12fff14 bx r4 <== NOT EXECUTED 3000b40c: ea0000f9 b 3000b7f8 <_Heap_Walk+0x4f0> <== NOT EXECUTED 3000b410: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000b414: e1a01009 mov r1, r9 <== NOT EXECUTED 3000b418: e28c0008 add r0, ip, #8 <== NOT EXECUTED 3000b41c: ebffe729 bl 300050c8 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000b420: e250a000 subs sl, r0, #0 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
3000b424: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b428: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b42c: 159f240c ldrne r2, [pc, #1036] ; 3000b840 <_Heap_Walk+0x538><== NOT EXECUTED 3000b430: 159d3020 ldrne r3, [sp, #32] <== NOT EXECUTED 3000b434: 1a0000cc bne 3000b76c <_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;
3000b438: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000b43c: e5928004 ldr r8, [r2, #4] <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
3000b440: e2188001 ands r8, r8, #1 <== NOT EXECUTED
(*printer)(
3000b444: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000b448: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000b44c: 059f23f0 ldreq r2, [pc, #1008] ; 3000b844 <_Heap_Walk+0x53c><== NOT EXECUTED 3000b450: 0a000009 beq 3000b47c <_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;
3000b454: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000b458: e5937004 ldr r7, [r3, #4] <== NOT EXECUTED 3000b45c: 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);
3000b460: 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;
3000b464: e5978004 ldr r8, [r7, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
3000b468: e2188001 ands r8, r8, #1 <== NOT EXECUTED 3000b46c: 1a000005 bne 3000b488 <_Heap_Walk+0x180> <== NOT EXECUTED
(*printer)(
3000b470: e59f23d0 ldr r2, [pc, #976] ; 3000b848 <_Heap_Walk+0x540> <== NOT EXECUTED 3000b474: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b478: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b47c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b480: e12fff14 bx r4 <== NOT EXECUTED 3000b484: ea0000db b 3000b7f8 <_Heap_Walk+0x4f0> <== NOT EXECUTED
);
return false;
}
if (
3000b488: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000b48c: e157000c cmp r7, ip <== NOT EXECUTED 3000b490: 0a000006 beq 3000b4b0 <_Heap_Walk+0x1a8> <== NOT EXECUTED
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
3000b494: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b498: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b49c: e59f23a8 ldr r2, [pc, #936] ; 3000b84c <_Heap_Walk+0x544> <== NOT EXECUTED 3000b4a0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b4a4: 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;
3000b4a8: e1a0800a mov r8, sl <== NOT EXECUTED 3000b4ac: ea0000d1 b 3000b7f8 <_Heap_Walk+0x4f0> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
3000b4b0: e596b010 ldr fp, [r6, #16] <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000b4b4: 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 );
3000b4b8: e1a0a006 mov sl, r6 <== NOT EXECUTED 3000b4bc: ea000034 b 3000b594 <_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;
3000b4c0: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED 3000b4c4: e1530008 cmp r3, r8 <== NOT EXECUTED 3000b4c8: 83a0c000 movhi ip, #0 <== NOT EXECUTED 3000b4cc: 8a000003 bhi 3000b4e0 <_Heap_Walk+0x1d8> <== NOT EXECUTED 3000b4d0: e596c024 ldr ip, [r6, #36] ; 0x24 <== NOT EXECUTED 3000b4d4: e15c0008 cmp ip, r8 <== NOT EXECUTED 3000b4d8: 33a0c000 movcc ip, #0 <== NOT EXECUTED 3000b4dc: 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 ) ) {
3000b4e0: e21cc0ff ands ip, ip, #255 ; 0xff <== NOT EXECUTED
(*printer)(
3000b4e4: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000b4e8: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000b4ec: 059f235c ldreq r2, [pc, #860] ; 3000b850 <_Heap_Walk+0x548><== NOT EXECUTED 3000b4f0: 0a000012 beq 3000b540 <_Heap_Walk+0x238> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000b4f4: e2880008 add r0, r8, #8 <== NOT EXECUTED 3000b4f8: e1a0100b mov r1, fp <== NOT EXECUTED 3000b4fc: ebffe6f1 bl 300050c8 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000b500: e250c000 subs ip, r0, #0 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
3000b504: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b508: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b50c: 159f2340 ldrne r2, [pc, #832] ; 3000b854 <_Heap_Walk+0x54c><== NOT EXECUTED 3000b510: 11a03008 movne r3, r8 <== NOT EXECUTED 3000b514: 1a0000be bne 3000b814 <_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;
3000b518: e5983004 ldr r3, [r8, #4] <== NOT EXECUTED 3000b51c: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000b520: 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;
3000b524: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000b528: e2133001 ands r3, r3, #1 <== NOT EXECUTED 3000b52c: e58d302c str r3, [sp, #44] ; 0x2c <== NOT EXECUTED 3000b530: 0a000009 beq 3000b55c <_Heap_Walk+0x254> <== NOT EXECUTED
(*printer)(
3000b534: e59f231c ldr r2, [pc, #796] ; 3000b858 <_Heap_Walk+0x550> <== NOT EXECUTED 3000b538: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b53c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b540: e1a03008 mov r3, r8 <== NOT EXECUTED 3000b544: e58dc01c str ip, [sp, #28] <== NOT EXECUTED 3000b548: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b54c: 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;
3000b550: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 3000b554: e1a0800c mov r8, ip <== NOT EXECUTED 3000b558: ea0000a6 b 3000b7f8 <_Heap_Walk+0x4f0> <== NOT EXECUTED
);
return false;
}
if ( free_block->prev != prev_block ) {
3000b55c: e598300c ldr r3, [r8, #12] <== NOT EXECUTED 3000b560: e153000a cmp r3, sl <== NOT EXECUTED 3000b564: 0a000008 beq 3000b58c <_Heap_Walk+0x284> <== NOT EXECUTED
(*printer)(
3000b568: e58d3000 str r3, [sp] <== NOT EXECUTED 3000b56c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b570: e1a03008 mov r3, r8 <== NOT EXECUTED 3000b574: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b578: e59f22dc ldr r2, [pc, #732] ; 3000b85c <_Heap_Walk+0x554> <== NOT EXECUTED 3000b57c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b580: 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;
3000b584: e59d802c ldr r8, [sp, #44] ; 0x2c <== NOT EXECUTED 3000b588: ea00009a b 3000b7f8 <_Heap_Walk+0x4f0> <== NOT EXECUTED
return false;
}
prev_block = free_block;
free_block = free_block->next;
3000b58c: e1a0a008 mov sl, r8 <== NOT EXECUTED 3000b590: 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 ) {
3000b594: e1580006 cmp r8, r6 <== NOT EXECUTED 3000b598: 1affffc8 bne 3000b4c0 <_Heap_Walk+0x1b8> <== NOT EXECUTED 3000b59c: ea000000 b 3000b5a4 <_Heap_Walk+0x29c> <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000b5a0: e1a07008 mov r7, r8 <== NOT EXECUTED
return true;
}
3000b5a4: 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;
3000b5a8: 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;
3000b5ac: 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);
3000b5b0: 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;
3000b5b4: e1520008 cmp r2, r8 <== NOT EXECUTED 3000b5b8: 83a0b000 movhi fp, #0 <== NOT EXECUTED 3000b5bc: 8a000003 bhi 3000b5d0 <_Heap_Walk+0x2c8> <== NOT EXECUTED 3000b5c0: e596b024 ldr fp, [r6, #36] ; 0x24 <== NOT EXECUTED 3000b5c4: e15b0008 cmp fp, r8 <== NOT EXECUTED 3000b5c8: 33a0b000 movcc fp, #0 <== NOT EXECUTED 3000b5cc: 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 ) ) {
3000b5d0: e21bb0ff ands fp, fp, #255 ; 0xff <== NOT EXECUTED 3000b5d4: 1a000007 bne 3000b5f8 <_Heap_Walk+0x2f0> <== NOT EXECUTED
(*printer)(
3000b5d8: e58d8000 str r8, [sp] <== NOT EXECUTED 3000b5dc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b5e0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b5e4: e59f2274 ldr r2, [pc, #628] ; 3000b860 <_Heap_Walk+0x558> <== NOT EXECUTED 3000b5e8: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b5ec: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b5f0: e12fff14 bx r4 <== NOT EXECUTED 3000b5f4: ea00005e b 3000b774 <_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;
3000b5f8: 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;
3000b5fc: e1a0000a mov r0, sl <== NOT EXECUTED 3000b600: e1a01009 mov r1, r9 <== NOT EXECUTED 3000b604: e057b002 subs fp, r7, r2 <== NOT EXECUTED 3000b608: 13a0b001 movne fp, #1 <== NOT EXECUTED 3000b60c: e58d301c str r3, [sp, #28] <== NOT EXECUTED 3000b610: ebffe6ac bl 300050c8 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
3000b614: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b618: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 3000b61c: 0a000005 beq 3000b638 <_Heap_Walk+0x330> <== NOT EXECUTED 3000b620: e35b0000 cmp fp, #0 <== NOT EXECUTED
(*printer)(
3000b624: 158da000 strne sl, [sp] <== NOT EXECUTED 3000b628: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b62c: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b630: 159f222c ldrne r2, [pc, #556] ; 3000b864 <_Heap_Walk+0x55c><== NOT EXECUTED 3000b634: 1a000014 bne 3000b68c <_Heap_Walk+0x384> <== NOT EXECUTED
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
3000b638: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b63c: e15a000c cmp sl, ip <== NOT EXECUTED 3000b640: 2a000009 bcs 3000b66c <_Heap_Walk+0x364> <== NOT EXECUTED 3000b644: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b648: 0a000007 beq 3000b66c <_Heap_Walk+0x364> <== NOT EXECUTED
(*printer)(
3000b64c: e88d1400 stm sp, {sl, ip} <== NOT EXECUTED
3000b650: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b654: e3a01001 mov r1, #1 <== NOT EXECUTED
3000b658: e59f2208 ldr r2, [pc, #520] ; 3000b868 <_Heap_Walk+0x560> <== NOT EXECUTED
3000b65c: e1a03007 mov r3, r7 <== NOT EXECUTED
3000b660: e1a0e00f mov lr, pc <== NOT EXECUTED
3000b664: e12fff14 bx r4 <== NOT EXECUTED
3000b668: ea00006b b 3000b81c <_Heap_Walk+0x514> <== NOT EXECUTED
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
3000b66c: e1580007 cmp r8, r7 <== NOT EXECUTED 3000b670: 8a000009 bhi 3000b69c <_Heap_Walk+0x394> <== NOT EXECUTED 3000b674: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b678: 0a000007 beq 3000b69c <_Heap_Walk+0x394> <== NOT EXECUTED
(*printer)(
3000b67c: e59f21e8 ldr r2, [pc, #488] ; 3000b86c <_Heap_Walk+0x564> <== NOT EXECUTED 3000b680: e58d8000 str r8, [sp] <== NOT EXECUTED 3000b684: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b688: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b68c: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b690: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b694: e12fff14 bx r4 <== NOT EXECUTED 3000b698: ea00005f b 3000b81c <_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;
3000b69c: e203b001 and fp, r3, #1 <== NOT EXECUTED 3000b6a0: e5983004 ldr r3, [r8, #4] <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
3000b6a4: e3130001 tst r3, #1 <== NOT EXECUTED 3000b6a8: 1a00003b bne 3000b79c <_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 ?
3000b6ac: 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)(
3000b6b0: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000b6b4: 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)(
3000b6b8: e1520003 cmp r2, r3 <== NOT EXECUTED 3000b6bc: 059f01ac ldreq r0, [pc, #428] ; 3000b870 <_Heap_Walk+0x568><== NOT EXECUTED 3000b6c0: 0a000003 beq 3000b6d4 <_Heap_Walk+0x3cc> <== NOT EXECUTED
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
3000b6c4: e59f31a8 ldr r3, [pc, #424] ; 3000b874 <_Heap_Walk+0x56c> <== NOT EXECUTED 3000b6c8: e1520006 cmp r2, r6 <== NOT EXECUTED 3000b6cc: e59f01a4 ldr r0, [pc, #420] ; 3000b878 <_Heap_Walk+0x570> <== NOT EXECUTED 3000b6d0: 01a00003 moveq r0, r3 <== NOT EXECUTED
block->next,
block->next == last_free_block ?
3000b6d4: 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)(
3000b6d8: e1530001 cmp r3, r1 <== NOT EXECUTED 3000b6dc: 059f1198 ldreq r1, [pc, #408] ; 3000b87c <_Heap_Walk+0x574><== NOT EXECUTED 3000b6e0: 0a000003 beq 3000b6f4 <_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)" : "")
3000b6e4: e59fc194 ldr ip, [pc, #404] ; 3000b880 <_Heap_Walk+0x578> <== NOT EXECUTED 3000b6e8: e1530006 cmp r3, r6 <== NOT EXECUTED 3000b6ec: e59f1184 ldr r1, [pc, #388] ; 3000b878 <_Heap_Walk+0x570> <== NOT EXECUTED 3000b6f0: 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)(
3000b6f4: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000b6f8: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000b6fc: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000b700: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000b704: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b708: e58da000 str sl, [sp] <== NOT EXECUTED 3000b70c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b710: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b714: e59f2168 ldr r2, [pc, #360] ; 3000b884 <_Heap_Walk+0x57c> <== NOT EXECUTED 3000b718: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b71c: 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 ) {
3000b720: e5983000 ldr r3, [r8] <== NOT EXECUTED 3000b724: e15a0003 cmp sl, r3 <== NOT EXECUTED 3000b728: 0a000009 beq 3000b754 <_Heap_Walk+0x44c> <== NOT EXECUTED
(*printer)(
3000b72c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000b730: e58da000 str sl, [sp] <== NOT EXECUTED 3000b734: e58d8008 str r8, [sp, #8] <== NOT EXECUTED 3000b738: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b73c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b740: e59f2140 ldr r2, [pc, #320] ; 3000b888 <_Heap_Walk+0x580> <== NOT EXECUTED 3000b744: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b748: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b74c: e12fff14 bx r4 <== NOT EXECUTED 3000b750: ea000031 b 3000b81c <_Heap_Walk+0x514> <== NOT EXECUTED
);
return false;
}
if ( !prev_used ) {
3000b754: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b758: 1a000007 bne 3000b77c <_Heap_Walk+0x474> <== NOT EXECUTED
(*printer)(
3000b75c: e59f2128 ldr r2, [pc, #296] ; 3000b88c <_Heap_Walk+0x584> <== NOT EXECUTED 3000b760: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b764: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b768: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b76c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b770: 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;
3000b774: e1a0800b mov r8, fp <== NOT EXECUTED 3000b778: ea00001e b 3000b7f8 <_Heap_Walk+0x4f0> <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000b77c: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED 3000b780: ea000002 b 3000b790 <_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 ) {
3000b784: e1530007 cmp r3, r7 <== NOT EXECUTED 3000b788: 0a000016 beq 3000b7e8 <_Heap_Walk+0x4e0> <== NOT EXECUTED
return true;
}
free_block = free_block->next;
3000b78c: 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 ) {
3000b790: e1530006 cmp r3, r6 <== NOT EXECUTED 3000b794: 1afffffa bne 3000b784 <_Heap_Walk+0x47c> <== NOT EXECUTED 3000b798: ea000019 b 3000b804 <_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) {
3000b79c: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b7a0: 0a000007 beq 3000b7c4 <_Heap_Walk+0x4bc> <== NOT EXECUTED
(*printer)(
3000b7a4: e58da000 str sl, [sp] <== NOT EXECUTED 3000b7a8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b7ac: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b7b0: e59f20d8 ldr r2, [pc, #216] ; 3000b890 <_Heap_Walk+0x588> <== NOT EXECUTED 3000b7b4: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b7b8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b7bc: e12fff14 bx r4 <== NOT EXECUTED 3000b7c0: ea000008 b 3000b7e8 <_Heap_Walk+0x4e0> <== NOT EXECUTED
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
3000b7c4: e58da000 str sl, [sp] <== NOT EXECUTED 3000b7c8: e5973000 ldr r3, [r7] <== NOT EXECUTED 3000b7cc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b7d0: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000b7d4: e1a0100b mov r1, fp <== NOT EXECUTED 3000b7d8: e59f20b4 ldr r2, [pc, #180] ; 3000b894 <_Heap_Walk+0x58c> <== NOT EXECUTED 3000b7dc: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b7e0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b7e4: e12fff14 bx r4 <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000b7e8: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000b7ec: e1580002 cmp r8, r2 <== NOT EXECUTED 3000b7f0: 1affff6a bne 3000b5a0 <_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;
3000b7f4: e3a08001 mov r8, #1 <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000b7f8: e1a00008 mov r0, r8 <== NOT EXECUTED
3000b7fc: e28dd030 add sp, sp, #48 ; 0x30 <== NOT EXECUTED
3000b800: 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)(
3000b804: e59f208c ldr r2, [pc, #140] ; 3000b898 <_Heap_Walk+0x590> <== NOT EXECUTED 3000b808: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b80c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b810: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b814: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b818: 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;
3000b81c: e3a08000 mov r8, #0 <== NOT EXECUTED 3000b820: eafffff4 b 3000b7f8 <_Heap_Walk+0x4f0> <== NOT EXECUTED
3000b2c4 <_Heap_Walk_print>:
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
3000b2c4: e92d000c push {r2, r3} <== NOT EXECUTED
3000b2c8: e92d4001 push {r0, lr} <== NOT EXECUTED
3000b2cc: e1a03000 mov r3, r0 <== NOT EXECUTED
va_list ap;
if ( error ) {
3000b2d0: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
3000b2d4: 159f0024 ldrne r0, [pc, #36] ; 3000b300 <_Heap_Walk_print+0x3c><== NOT EXECUTED
} else {
printk( "PASS[%d]: ", source );
3000b2d8: 059f0024 ldreq r0, [pc, #36] ; 3000b304 <_Heap_Walk_print+0x40><== NOT EXECUTED 3000b2dc: e1a01003 mov r1, r3 <== NOT EXECUTED 3000b2e0: ebfff16a bl 30007890 <printk> <== NOT EXECUTED
}
va_start( ap, fmt );
3000b2e4: e28d100c add r1, sp, #12 <== NOT EXECUTED
vprintk( fmt, ap );
3000b2e8: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
3000b2ec: e58d1000 str r1, [sp] <== NOT EXECUTED
vprintk( fmt, ap );
3000b2f0: ebfff834 bl 300093c8 <vprintk> <== NOT EXECUTED
va_end( ap ); }
3000b2f4: e8bd4008 pop {r3, lr} <== NOT EXECUTED
3000b2f8: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000b2fc: e12fff1e bx lr <== NOT EXECUTED
3000b2b8 <_Heap_Walk_print_nothing>:
int source,
bool error,
const char *fmt,
...
)
{
3000b2b8: e92d000c push {r2, r3} <== NOT EXECUTED
/* Do nothing */ }
3000b2bc: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000b2c0: e12fff1e bx lr <== NOT EXECUTED
3000a6ec <_Internal_error_Occurred>:
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
3000a6ec: e59f3038 ldr r3, [pc, #56] ; 3000a72c <_Internal_error_Occurred+0x40>
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000a6f0: e20110ff and r1, r1, #255 ; 0xff
3000a6f4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
_Internal_errors_What_happened.the_source = the_source;
3000a6f8: e5830000 str r0, [r3]
_Internal_errors_What_happened.is_internal = is_internal;
3000a6fc: e5c31004 strb r1, [r3, #4]
_Internal_errors_What_happened.the_error = the_error;
3000a700: e5832008 str r2, [r3, #8]
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000a704: 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 );
3000a708: eb000761 bl 3000c494 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
3000a70c: e59f301c ldr r3, [pc, #28] ; 3000a730 <_Internal_error_Occurred+0x44><== NOT EXECUTED 3000a710: e3a02005 mov r2, #5 <== NOT EXECUTED 3000a714: e5832000 str r2, [r3] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a718: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000a71c: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000a720: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
3000a724: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a728: eafffffe b 3000a728 <_Internal_error_Occurred+0x3c> <== NOT EXECUTED
3000abb8 <_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;
3000abb8: e5903008 ldr r3, [r0, #8]
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000abbc: 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;
3000abc0: e2633001 rsb r3, r3, #1
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000abc4: 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 ) {
3000abc8: 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;
3000abcc: 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 ) {
3000abd0: 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;
3000abd4: 83a03001 movhi r3, #1 3000abd8: 85843000 strhi r3, [r4]
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
3000abdc: 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 ) {
3000abe0: 8a00000b bhi 3000ac14 <_Objects_Get+0x5c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000abe4: e59f2030 ldr r2, [pc, #48] ; 3000ac1c <_Objects_Get+0x64> 3000abe8: e5921000 ldr r1, [r2] 3000abec: e2811001 add r1, r1, #1 3000abf0: e5821000 str r1, [r2]
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000abf4: e590201c ldr r2, [r0, #28] 3000abf8: e7925103 ldr r5, [r2, r3, lsl #2] 3000abfc: e3550000 cmp r5, #0
*location = OBJECTS_LOCAL;
3000ac00: 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 ) {
3000ac04: 1a000001 bne 3000ac10 <_Objects_Get+0x58>
/*
* Valid Id for this API, Class and Node but the object has not
* been allocated yet.
*/
_Thread_Enable_dispatch();
3000ac08: eb000310 bl 3000b850 <_Thread_Enable_dispatch> <== NOT EXECUTED
*location = OBJECTS_ERROR;
3000ac0c: e3a03001 mov r3, #1 <== NOT EXECUTED
3000ac10: e5843000 str r3, [r4]
_Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif }
3000ac14: e1a00005 mov r0, r5
3000ac18: e8bd8030 pop {r4, r5, pc}
3000aaec <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000aaec: e1a01801 lsl r1, r1, #16
3000aaf0: e92d4030 push {r4, r5, lr}
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000aaf4: e1b05821 lsrs r5, r1, #16
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000aaf8: e1a04000 mov r4, r0
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
3000aafc: 01a00005 moveq r0, r5
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000ab00: 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 );
3000ab04: eb00125e bl 3000f484 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
3000ab08: e3500000 cmp r0, #0
3000ab0c: 08bd8030 popeq {r4, r5, pc}
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
3000ab10: e1550000 cmp r5, r0
3000ab14: 8a00000a bhi 3000ab44 <_Objects_Get_information+0x58>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
3000ab18: e59f302c ldr r3, [pc, #44] ; 3000ab4c <_Objects_Get_information+0x60>
3000ab1c: e7930104 ldr r0, [r3, r4, lsl #2]
3000ab20: e3500000 cmp r0, #0
3000ab24: 08bd8030 popeq {r4, r5, pc}
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
3000ab28: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !info )
3000ab2c: e3500000 cmp r0, #0
3000ab30: 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 )
3000ab34: e1d031b0 ldrh r3, [r0, #16]
return NULL;
3000ab38: e3530000 cmp r3, #0
3000ab3c: 03a00000 moveq r0, #0
3000ab40: 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;
3000ab44: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
3000ab48: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000ab50 <_Objects_Get_isr_disable>:
{
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000ab50: e590c008 ldr ip, [r0, #8]
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
3000ab54: e92d4010 push {r4, lr}
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000ab58: e26cc001 rsb ip, ip, #1 3000ab5c: e08c1001 add r1, ip, r1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ab60: e10f4000 mrs r4, CPSR 3000ab64: e384c080 orr ip, r4, #128 ; 0x80 3000ab68: e129f00c msr CPSR_fc, ip
_ISR_Disable( level );
if ( information->maximum >= index ) {
3000ab6c: e1d0c1b0 ldrh ip, [r0, #16] 3000ab70: e15c0001 cmp ip, r1
3000ab74: 3a00000a bcc 3000aba4 <_Objects_Get_isr_disable+0x54>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000ab78: e590001c ldr r0, [r0, #28] 3000ab7c: e7900101 ldr r0, [r0, r1, lsl #2] 3000ab80: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3000ab84: 13a01000 movne r1, #0 3000ab88: 15821000 strne r1, [r2]
*level_p = level;
3000ab8c: 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 ) {
3000ab90: 18bd8010 popne {r4, pc}
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ab94: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
3000ab98: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ab9c: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3000aba0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000aba4: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
} _ISR_Enable( level ); *location = OBJECTS_ERROR;
3000aba8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000abac: 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;
3000abb0: e3a00000 mov r0, #0 <== NOT EXECUTED
#endif }
3000abb4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c604 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
3000c604: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr} <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
3000c608: e2516000 subs r6, r1, #0 <== NOT EXECUTED
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
3000c60c: e1a04002 mov r4, r2 <== NOT EXECUTED
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
return NULL;
3000c610: 01a04006 moveq r4, r6 <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
3000c614: 0a000038 beq 3000c6fc <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
if ( name == NULL )
3000c618: e3540000 cmp r4, #0 <== NOT EXECUTED 3000c61c: 0a000036 beq 3000c6fc <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000c620: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c624: 059f30d8 ldreq r3, [pc, #216] ; 3000c704 <_Objects_Get_name_as_string+0x100><== NOT EXECUTED 3000c628: 11a07000 movne r7, r0 <== NOT EXECUTED 3000c62c: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000c630: 05937008 ldreq r7, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3000c634: e1a00007 mov r0, r7 <== NOT EXECUTED 3000c638: ebffffb9 bl 3000c524 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
3000c63c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
return NULL;
3000c640: 01a04005 moveq r4, r5 <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
information = _Objects_Get_information_id( tmpId );
if ( !information )
3000c644: 0a00002c beq 3000c6fc <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
3000c648: e1a01007 mov r1, r7 <== NOT EXECUTED 3000c64c: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000c650: eb00002d bl 3000c70c <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3000c654: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3000c658: e3530000 cmp r3, #0 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
3000c65c: 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 ) {
3000c660: 1a000025 bne 3000c6fc <_Objects_Get_name_as_string+0xf8> <== NOT EXECUTED
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
3000c664: e5d52038 ldrb r2, [r5, #56] ; 0x38 <== NOT EXECUTED 3000c668: e3520000 cmp r2, #0 <== NOT EXECUTED 3000c66c: 0a000004 beq 3000c684 <_Objects_Get_name_as_string+0x80> <== NOT EXECUTED
s = the_object->name.name_p;
3000c670: e590100c ldr r1, [r0, #12] <== NOT EXECUTED
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
3000c674: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c678: 01a03004 moveq r3, r4 <== NOT EXECUTED 3000c67c: 1a00000a bne 3000c6ac <_Objects_Get_name_as_string+0xa8> <== NOT EXECUTED 3000c680: ea00001a b 3000c6f0 <_Objects_Get_name_as_string+0xec> <== 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;
3000c684: e590300c ldr r3, [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';
3000c688: e5cd2004 strb r2, [sp, #4] <== NOT EXECUTED
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
3000c68c: e1a01c23 lsr r1, r3, #24 <== NOT EXECUTED 3000c690: e5cd1000 strb r1, [sp] <== NOT EXECUTED
lname[ 1 ] = (u32_name >> 16) & 0xff;
3000c694: e1a01823 lsr r1, r3, #16 <== NOT EXECUTED 3000c698: e5cd1001 strb r1, [sp, #1] <== NOT EXECUTED
lname[ 2 ] = (u32_name >> 8) & 0xff;
3000c69c: e1a01423 lsr r1, r3, #8 <== NOT EXECUTED 3000c6a0: e5cd1002 strb r1, [sp, #2] <== NOT EXECUTED
lname[ 3 ] = (u32_name >> 0) & 0xff;
3000c6a4: e5cd3003 strb r3, [sp, #3] <== NOT EXECUTED
lname[ 4 ] = '\0';
s = lname;
3000c6a8: e1a0100d mov r1, sp <== NOT EXECUTED
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
*d = (isprint((unsigned char)*s)) ? *s : '*';
3000c6ac: e1a03004 mov r3, r4 <== NOT EXECUTED 3000c6b0: e3a02000 mov r2, #0 <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000c6b4: e2466001 sub r6, r6, #1 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
3000c6b8: e59fc048 ldr ip, [pc, #72] ; 3000c708 <_Objects_Get_name_as_string+0x104><== NOT EXECUTED 3000c6bc: ea000006 b 3000c6dc <_Objects_Get_name_as_string+0xd8> <== NOT EXECUTED 3000c6c0: e59ce000 ldr lr, [ip] <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000c6c4: e2822001 add r2, r2, #1 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
3000c6c8: e08ee000 add lr, lr, r0 <== NOT EXECUTED 3000c6cc: e5dee001 ldrb lr, [lr, #1] <== NOT EXECUTED 3000c6d0: e31e0097 tst lr, #151 ; 0x97 <== NOT EXECUTED 3000c6d4: 03a0002a moveq r0, #42 ; 0x2a <== NOT EXECUTED 3000c6d8: e4c30001 strb r0, [r3], #1 <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000c6dc: e1520006 cmp r2, r6 <== NOT EXECUTED 3000c6e0: 2a000002 bcs 3000c6f0 <_Objects_Get_name_as_string+0xec> <== NOT EXECUTED 3000c6e4: e7d10002 ldrb r0, [r1, r2] <== NOT EXECUTED 3000c6e8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c6ec: 1afffff3 bne 3000c6c0 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
3000c6f0: e3a02000 mov r2, #0 <== NOT EXECUTED 3000c6f4: e5c32000 strb r2, [r3] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c6f8: eb000307 bl 3000d31c <_Thread_Enable_dispatch> <== NOT EXECUTED
return name;
}
return NULL; /* unreachable path */
}
3000c6fc: e1a00004 mov r0, r4 <== NOT EXECUTED
3000c700: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000ad6c <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
3000ad6c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
3000ad70: e2507000 subs r7, r0, #0 <== NOT EXECUTED
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
3000ad74: e1a04002 mov r4, r2 <== NOT EXECUTED 3000ad78: e1a06003 mov r6, r3 <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
3000ad7c: 01a00007 moveq r0, r7 <== NOT EXECUTED
)
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
3000ad80: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return NULL;
if ( !location_p )
3000ad84: e3520000 cmp r2, #0 <== NOT EXECUTED
return NULL;
3000ad88: 01a00002 moveq r0, r2 <== NOT EXECUTED
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
3000ad8c: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return NULL;
if ( !next_id_p )
3000ad90: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ad94: 0a000016 beq 3000adf4 <_Objects_Get_next+0x88> <== NOT EXECUTED
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
3000ad98: e1b03801 lsls r3, r1, #16 <== NOT EXECUTED
next_id = information->minimum_id;
3000ad9c: 05975008 ldreq r5, [r7, #8] <== NOT EXECUTED
else
next_id = id;
3000ada0: 11a05001 movne r5, r1 <== NOT EXECUTED
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
3000ada4: e1d731b0 ldrh r3, [r7, #16] <== NOT EXECUTED 3000ada8: e1a02805 lsl r2, r5, #16 <== NOT EXECUTED 3000adac: e1530822 cmp r3, r2, lsr #16 <== NOT EXECUTED 3000adb0: 2a000005 bcs 3000adcc <_Objects_Get_next+0x60> <== NOT EXECUTED
{
*location_p = OBJECTS_ERROR;
3000adb4: e3a03001 mov r3, #1 <== NOT EXECUTED 3000adb8: e5843000 str r3, [r4] <== NOT EXECUTED
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
3000adbc: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000adc0: e5863000 str r3, [r6] <== NOT EXECUTED
return 0;
3000adc4: e3a00000 mov r0, #0 <== NOT EXECUTED
3000adc8: 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);
3000adcc: e1a01005 mov r1, r5 <== NOT EXECUTED 3000add0: e1a00007 mov r0, r7 <== NOT EXECUTED 3000add4: e1a02004 mov r2, r4 <== NOT EXECUTED 3000add8: eb000007 bl 3000adfc <_Objects_Get> <== NOT EXECUTED
next_id++;
} while (*location_p != OBJECTS_LOCAL);
3000addc: e5943000 ldr r3, [r4] <== NOT EXECUTED
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
next_id++;
3000ade0: e2855001 add r5, r5, #1 <== NOT EXECUTED
} while (*location_p != OBJECTS_LOCAL);
3000ade4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ade8: 1affffed bne 3000ada4 <_Objects_Get_next+0x38> <== NOT EXECUTED
*next_id_p = next_id;
3000adec: e5865000 str r5, [r6] <== NOT EXECUTED
return object;
3000adf0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
3000adf4: e1a00003 mov r0, r3 <== NOT EXECUTED
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
3000adf8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3001add8 <_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;
3001add8: e5903008 ldr r3, [r0, #8] 3001addc: e2633001 rsb r3, r3, #1 3001ade0: e0833001 add r3, r3, r1
if ( information->maximum >= index ) {
3001ade4: e1d011b0 ldrh r1, [r0, #16] 3001ade8: e1510003 cmp r1, r3
3001adec: 3a000005 bcc 3001ae08 <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3001adf0: e590101c ldr r1, [r0, #28] 3001adf4: e7910103 ldr r0, [r1, r3, lsl #2] 3001adf8: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3001adfc: 13a03000 movne r3, #0 3001ae00: 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 ) {
3001ae04: 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;
3001ae08: e3a03001 mov r3, #1 <== NOT EXECUTED 3001ae0c: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3001ae10: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3001ae14: e12fff1e bx lr <== NOT EXECUTED
3000c118 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
3000c118: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3000c11c: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000c120: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000c124: 059f3078 ldreq r3, [pc, #120] ; 3000c1a4 <_Objects_Id_to_name+0x8c><== NOT EXECUTED 3000c128: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000c12c: 05931008 ldreq r1, [r3, #8] <== NOT EXECUTED 3000c130: e1a03c21 lsr r3, r1, #24 <== NOT EXECUTED 3000c134: 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 )
3000c138: e2432001 sub r2, r3, #1 <== NOT EXECUTED 3000c13c: e3520002 cmp r2, #2 <== NOT EXECUTED 3000c140: 8a000010 bhi 3000c188 <_Objects_Id_to_name+0x70> <== NOT EXECUTED 3000c144: ea000011 b 3000c190 <_Objects_Id_to_name+0x78> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000c148: 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 ];
3000c14c: e7930102 ldr r0, [r3, r2, lsl #2] <== NOT EXECUTED
if ( !information )
3000c150: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c154: 0a00000b beq 3000c188 <_Objects_Id_to_name+0x70> <== NOT EXECUTED
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
3000c158: e5d04038 ldrb r4, [r0, #56] ; 0x38 <== NOT EXECUTED 3000c15c: e3540000 cmp r4, #0 <== NOT EXECUTED 3000c160: 1a000008 bne 3000c188 <_Objects_Id_to_name+0x70> <== NOT EXECUTED
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
3000c164: e1a0200d mov r2, sp <== NOT EXECUTED 3000c168: ebffffd0 bl 3000c0b0 <_Objects_Get> <== NOT EXECUTED
if ( !the_object )
3000c16c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c170: 0a000004 beq 3000c188 <_Objects_Id_to_name+0x70> <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
3000c174: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000c178: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c17c: eb000316 bl 3000cddc <_Thread_Enable_dispatch> <== NOT EXECUTED
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000c180: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c184: ea000000 b 3000c18c <_Objects_Id_to_name+0x74> <== 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;
3000c188: e3a00003 mov r0, #3 <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
3000c18c: e8bd8038 pop {r3, r4, r5, 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 ] )
3000c190: e59f2010 ldr r2, [pc, #16] ; 3000c1a8 <_Objects_Id_to_name+0x90><== NOT EXECUTED 3000c194: e7923103 ldr r3, [r2, r3, lsl #2] <== NOT EXECUTED 3000c198: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c19c: 1affffe9 bne 3000c148 <_Objects_Id_to_name+0x30> <== NOT EXECUTED 3000c1a0: eafffff8 b 3000c188 <_Objects_Id_to_name+0x70> <== NOT EXECUTED
30016820 <_Objects_Name_to_id_string>:
Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string(
Objects_Information *information,
const char *name,
Objects_Id *id
)
{
30016820: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Objects_Control *the_object;
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
30016824: e252a000 subs sl, r2, #0
Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string(
Objects_Information *information,
const char *name,
Objects_Id *id
)
{
30016828: e1a06000 mov r6, r0 3001682c: e1a08001 mov r8, r1
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
30016830: 03a00002 moveq r0, #2
Objects_Control *the_object;
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
30016834: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return OBJECTS_INVALID_ADDRESS;
if ( !name )
30016838: e3510000 cmp r1, #0
3001683c: 0a000016 beq 3001689c <_Objects_Name_to_id_string+0x7c>
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
30016840: e1d671b0 ldrh r7, [r6, #16] 30016844: e3570000 cmp r7, #0 30016848: 13a04001 movne r4, #1
3001684c: 1a000010 bne 30016894 <_Objects_Name_to_id_string+0x74>
30016850: ea000013 b 300168a4 <_Objects_Name_to_id_string+0x84>
for ( index = 1; index <= information->maximum; index++ ) {
the_object = information->local_table[ index ];
30016854: e596301c ldr r3, [r6, #28] <== NOT EXECUTED 30016858: e7935104 ldr r5, [r3, r4, lsl #2] <== NOT EXECUTED
if ( !the_object )
3001685c: e3550000 cmp r5, #0 <== NOT EXECUTED 30016860: 0a00000a beq 30016890 <_Objects_Name_to_id_string+0x70> <== NOT EXECUTED
continue;
if ( !the_object->name.name_p )
30016864: e595100c ldr r1, [r5, #12] <== NOT EXECUTED 30016868: e3510000 cmp r1, #0 <== NOT EXECUTED 3001686c: 0a000007 beq 30016890 <_Objects_Name_to_id_string+0x70> <== NOT EXECUTED
continue;
if (!strncmp( name, the_object->name.name_p, information->name_length)) {
30016870: e1a00008 mov r0, r8 <== NOT EXECUTED 30016874: e1d623ba ldrh r2, [r6, #58] ; 0x3a <== NOT EXECUTED 30016878: eb000eed bl 3001a434 <strncmp> <== NOT EXECUTED 3001687c: e3500000 cmp r0, #0 <== NOT EXECUTED 30016880: 1a000002 bne 30016890 <_Objects_Name_to_id_string+0x70> <== NOT EXECUTED
*id = the_object->id;
30016884: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 30016888: e58a3000 str r3, [sl] <== NOT EXECUTED
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3001688c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
if ( !name )
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
for ( index = 1; index <= information->maximum; index++ ) {
30016890: e2844001 add r4, r4, #1 <== NOT EXECUTED 30016894: e1540007 cmp r4, r7 <== NOT EXECUTED 30016898: 9affffed bls 30016854 <_Objects_Name_to_id_string+0x34> <== NOT EXECUTED
if ( !id )
return OBJECTS_INVALID_ADDRESS;
if ( !name )
return OBJECTS_INVALID_NAME;
3001689c: e3a00001 mov r0, #1
300168a0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
}
}
return OBJECTS_INVALID_NAME;
300168a4: e3a00001 mov r0, #1
}
300168a8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
3000ad1c <_Objects_Name_to_id_u32>:
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000ad1c: e3530000 cmp r3, #0
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
3000ad20: e92d4030 push {r4, r5, lr}
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
3000ad24: 03a00002 moveq r0, #2
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000ad28: 08bd8030 popeq {r4, r5, pc}
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
3000ad2c: e3510000 cmp r1, #0
3000ad30: 0a000017 beq 3000ad94 <_Objects_Name_to_id_u32+0x78>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
3000ad34: e1d041b0 ldrh r4, [r0, #16] 3000ad38: e3540000 cmp r4, #0
3000ad3c: 0a000016 beq 3000ad9c <_Objects_Name_to_id_u32+0x80>
3000ad40: e3720106 cmn r2, #-2147483647 ; 0x80000001 3000ad44: 13520000 cmpne r2, #0 3000ad48: 03a02001 moveq r2, #1
3000ad4c: 0a00000e beq 3000ad8c <_Objects_Name_to_id_u32+0x70>
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
3000ad50: e3520001 cmp r2, #1 <== NOT EXECUTED 3000ad54: 1a00000e bne 3000ad94 <_Objects_Name_to_id_u32+0x78> <== NOT EXECUTED 3000ad58: ea00000b b 3000ad8c <_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 ];
3000ad5c: e590c01c ldr ip, [r0, #28] 3000ad60: e79cc102 ldr ip, [ip, r2, lsl #2]
if ( !the_object )
3000ad64: e35c0000 cmp ip, #0
3000ad68: 0a000006 beq 3000ad88 <_Objects_Name_to_id_u32+0x6c>
continue;
if ( name == the_object->name.name_u32 ) {
3000ad6c: e59c500c ldr r5, [ip, #12] 3000ad70: e1510005 cmp r1, r5
3000ad74: 1a000003 bne 3000ad88 <_Objects_Name_to_id_u32+0x6c>
*id = the_object->id;
3000ad78: e59c2008 ldr r2, [ip, #8]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000ad7c: 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;
3000ad80: e5832000 str r2, [r3]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000ad84: 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++ ) {
3000ad88: e2822001 add r2, r2, #1 3000ad8c: e1520004 cmp r2, r4
3000ad90: 9afffff1 bls 3000ad5c <_Objects_Name_to_id_u32+0x40>
if ( !id )
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
return OBJECTS_INVALID_NAME;
3000ad94: e3a00001 mov r0, #1 <== NOT EXECUTED
3000ad98: 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;
3000ad9c: e3a00001 mov r0, #1
#endif }
3000ada0: e8bd8030 pop {r4, r5, pc}
3000b400 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000b400: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000b404: e1a05000 mov r5, r0
3000b408: e1a06001 mov r6, r1
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000b40c: e1a00002 mov r0, r2 3000b410: e1d513ba ldrh r1, [r5, #58] ; 0x3a
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000b414: e1a08002 mov r8, r2
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000b418: eb002032 bl 300134e8 <strnlen>
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
3000b41c: e5d53038 ldrb r3, [r5, #56] ; 0x38
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000b420: e1a04000 mov r4, r0
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
3000b424: e3530000 cmp r3, #0
3000b428: 0a00000e beq 3000b468 <_Objects_Set_name+0x68>
char *d;
d = _Workspace_Allocate( length + 1 );
3000b42c: e2800001 add r0, r0, #1 3000b430: eb0006f4 bl 3000d008 <_Workspace_Allocate>
if ( !d )
3000b434: e2505000 subs r5, r0, #0
3000b438: 0a00001d beq 3000b4b4 <_Objects_Set_name+0xb4>
return false;
_Workspace_Free( (void *)the_object->name.name_p );
3000b43c: e596000c ldr r0, [r6, #12] <== NOT EXECUTED
the_object->name.name_p = NULL;
3000b440: e3a07000 mov r7, #0 <== NOT EXECUTED
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
_Workspace_Free( (void *)the_object->name.name_p );
3000b444: eb0006f5 bl 3000d020 <_Workspace_Free> <== NOT EXECUTED
the_object->name.name_p = NULL;
3000b448: e586700c str r7, [r6, #12] <== NOT EXECUTED
strncpy( d, name, length );
3000b44c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b450: e1a01008 mov r1, r8 <== NOT EXECUTED 3000b454: e1a02004 mov r2, r4 <== NOT EXECUTED 3000b458: eb001fe7 bl 300133fc <strncpy> <== NOT EXECUTED
d[length] = '\0';
3000b45c: e7c57004 strb r7, [r5, r4] <== NOT EXECUTED
the_object->name.name_p = d;
3000b460: e586500c str r5, [r6, #12] <== NOT EXECUTED 3000b464: ea000010 b 3000b4ac <_Objects_Set_name+0xac> <== NOT EXECUTED
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
3000b468: e3500001 cmp r0, #1 <== NOT EXECUTED 3000b46c: 85d83001 ldrbhi r3, [r8, #1] <== NOT EXECUTED 3000b470: e5d82000 ldrb r2, [r8] <== NOT EXECUTED 3000b474: 81a03803 lslhi r3, r3, #16 <== NOT EXECUTED 3000b478: 93a03602 movls r3, #2097152 ; 0x200000 <== NOT EXECUTED 3000b47c: e1a02c02 lsl r2, r2, #24 <== NOT EXECUTED 3000b480: e3500002 cmp r0, #2 <== NOT EXECUTED 3000b484: e1832002 orr r2, r3, r2 <== NOT EXECUTED 3000b488: 85d83002 ldrbhi r3, [r8, #2] <== NOT EXECUTED 3000b48c: 93a03a02 movls r3, #8192 ; 0x2000 <== NOT EXECUTED 3000b490: 81a03403 lslhi r3, r3, #8 <== NOT EXECUTED 3000b494: e3500003 cmp r0, #3 <== NOT EXECUTED 3000b498: e1822003 orr r2, r2, r3 <== NOT EXECUTED 3000b49c: 85d83003 ldrbhi r3, [r8, #3] <== NOT EXECUTED 3000b4a0: 93a03020 movls r3, #32 <== NOT EXECUTED 3000b4a4: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000b4a8: e586300c str r3, [r6, #12] <== NOT EXECUTED
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
3000b4ac: e3a00001 mov r0, #1 <== NOT EXECUTED
3000b4b0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
3000b4b4: e1a00005 mov r0, r5
);
}
return true;
}
3000b4b8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000bb20 <_POSIX_Absolute_timeout_to_ticks>:
*/
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
{
3000bb20: e92d40ff push {r0, r1, r2, r3, r4, r5, r6, r7, lr} <== NOT EXECUTED
/*
* Make sure there is always a value returned.
*/
*ticks_out = 0;
3000bb24: e3a03000 mov r3, #0 <== NOT EXECUTED 3000bb28: e5813000 str r3, [r1] <== NOT EXECUTED
*/
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
{
3000bb2c: e1a07000 mov r7, r0 <== NOT EXECUTED 3000bb30: e1a04001 mov r4, r1 <== NOT EXECUTED
*ticks_out = 0;
/*
* Is the absolute time even valid?
*/
if ( !_Timespec_Is_valid(abstime) )
3000bb34: eb000f20 bl 3000f7bc <_Timespec_Is_valid> <== NOT EXECUTED 3000bb38: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bb3c: 0a000013 beq 3000bb90 <_POSIX_Absolute_timeout_to_ticks+0x70><== NOT EXECUTED
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
3000bb40: e28d6008 add r6, sp, #8 <== NOT EXECUTED 3000bb44: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bb48: eb0006d1 bl 3000d694 <_TOD_Get> <== NOT EXECUTED
if ( _Timespec_Less_than( abstime, ¤t_time ) )
3000bb4c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000bb50: e1a01006 mov r1, r6 <== NOT EXECUTED 3000bb54: eb000f29 bl 3000f800 <_Timespec_Less_than> <== NOT EXECUTED 3000bb58: e3500000 cmp r0, #0 <== NOT EXECUTED
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
3000bb5c: 13a00001 movne r0, #1 <== NOT EXECUTED
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
if ( _Timespec_Less_than( abstime, ¤t_time ) )
3000bb60: 1a00000a bne 3000bb90 <_POSIX_Absolute_timeout_to_ticks+0x70><== NOT EXECUTED
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
/*
* How long until the requested absolute time?
*/
_Timespec_Subtract( ¤t_time, abstime, &difference );
3000bb64: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bb68: e1a01007 mov r1, r7 <== NOT EXECUTED 3000bb6c: e1a0200d mov r2, sp <== NOT EXECUTED 3000bb70: eb000f30 bl 3000f838 <_Timespec_Subtract> <== NOT EXECUTED
/*
* Internally the SuperCore uses ticks, so convert to them.
*/
*ticks_out = _Timespec_To_ticks( &difference );
3000bb74: e1a0000d mov r0, sp <== NOT EXECUTED 3000bb78: eb000f40 bl 3000f880 <_Timespec_To_ticks> <== NOT EXECUTED
/*
* If the difference was 0, then the future is now. It is so bright
* we better wear shades.
*/
if ( !*ticks_out )
return POSIX_ABSOLUTE_TIMEOUT_IS_NOW;
3000bb7c: e3500000 cmp r0, #0 <== NOT EXECUTED
_Timespec_Subtract( ¤t_time, abstime, &difference );
/*
* Internally the SuperCore uses ticks, so convert to them.
*/
*ticks_out = _Timespec_To_ticks( &difference );
3000bb80: e5840000 str r0, [r4] <== NOT EXECUTED
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
/*
* How long until the requested absolute time?
*/
_Timespec_Subtract( ¤t_time, abstime, &difference );
3000bb84: e1a0500d mov r5, sp <== NOT EXECUTED
/*
* If the difference was 0, then the future is now. It is so bright
* we better wear shades.
*/
if ( !*ticks_out )
return POSIX_ABSOLUTE_TIMEOUT_IS_NOW;
3000bb88: 13a00003 movne r0, #3 <== NOT EXECUTED 3000bb8c: 03a00002 moveq r0, #2 <== NOT EXECUTED
/* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; }
3000bb90: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000bb94: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000f71c <_POSIX_Barrier_Translate_core_barrier_return_code>:
#if defined(RTEMS_DEBUG)
if ( the_barrier_status > CORE_BARRIER_STATUS_LAST )
return EINVAL;
#endif
return _POSIX_Barrier_Return_codes[the_barrier_status];
}
3000f71c: e59f3004 ldr r3, [pc, #4] ; 3000f728 <_POSIX_Barrier_Translate_core_barrier_return_code+0xc><== NOT EXECUTED 3000f720: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3000f724: e12fff1e bx lr <== NOT EXECUTED
3000a4e4 <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
3000a4e4: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3000a4e8: e1a05000 mov r5, r0 <== NOT EXECUTED
3000a4ec: e1a04001 mov r4, r1 <== NOT EXECUTED
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
3000a4f0: e1a00001 mov r0, r1 <== NOT EXECUTED 3000a4f4: e1a0100d mov r1, sp <== NOT EXECUTED
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
3000a4f8: e1a07002 mov r7, r2 <== NOT EXECUTED 3000a4fc: e20380ff and r8, r3, #255 ; 0xff <== NOT EXECUTED
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
3000a500: eb000056 bl 3000a660 <_POSIX_Mutex_Get> <== NOT EXECUTED 3000a504: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a508: e1a0600d mov r6, sp <== NOT EXECUTED 3000a50c: 0a000031 beq 3000a5d8 <_POSIX_Condition_variables_Wait_support+0xf4><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000a510: e59f30cc ldr r3, [pc, #204] ; 3000a5e4 <_POSIX_Condition_variables_Wait_support+0x100><== NOT EXECUTED
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000a514: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a518: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000a51c: e1a0100d mov r1, sp <== NOT EXECUTED 3000a520: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000a524: e5832000 str r2, [r3] <== NOT EXECUTED 3000a528: ebffff7a bl 3000a318 <_POSIX_Condition_variables_Get> <== NOT EXECUTED
switch ( location ) {
3000a52c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000a530: e1a0a000 mov sl, r0 <== NOT EXECUTED
switch ( location ) {
3000a534: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a538: 1a000026 bne 3000a5d8 <_POSIX_Condition_variables_Wait_support+0xf4><== NOT EXECUTED
case OBJECTS_LOCAL:
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
3000a53c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000a540: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a544: 0a000004 beq 3000a55c <_POSIX_Condition_variables_Wait_support+0x78><== NOT EXECUTED 3000a548: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000a54c: e1530002 cmp r3, r2 <== NOT EXECUTED 3000a550: 0a000001 beq 3000a55c <_POSIX_Condition_variables_Wait_support+0x78><== NOT EXECUTED
_Thread_Enable_dispatch();
3000a554: eb000cd5 bl 3000d8b0 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000a558: ea00001e b 3000a5d8 <_POSIX_Condition_variables_Wait_support+0xf4><== NOT EXECUTED
return EINVAL;
}
(void) pthread_mutex_unlock( mutex );
3000a55c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a560: eb0000df bl 3000a8e4 <pthread_mutex_unlock> <== NOT EXECUTED
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
3000a564: e3580000 cmp r8, #0 <== NOT EXECUTED 3000a568: 1a000013 bne 3000a5bc <_POSIX_Condition_variables_Wait_support+0xd8><== NOT EXECUTED
the_cond->Mutex = *mutex;
3000a56c: e5943000 ldr r3, [r4] <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000a570: e59f6070 ldr r6, [pc, #112] ; 3000a5e8 <_POSIX_Condition_variables_Wait_support+0x104><== NOT EXECUTED
return EINVAL;
}
*/
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
3000a574: e58a3014 str r3, [sl, #20] <== 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;
3000a578: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a57c: e58a3048 str r3, [sl, #72] ; 0x48 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000a580: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
3000a584: e28a0018 add r0, sl, #24 <== NOT EXECUTED
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000a588: e5838034 str r8, [r3, #52] ; 0x34 <== NOT EXECUTED
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
_Thread_Executing->Wait.id = *cond;
3000a58c: e5952000 ldr r2, [r5] <== NOT EXECUTED
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
3000a590: e5830044 str r0, [r3, #68] ; 0x44 <== NOT EXECUTED
_Thread_Executing->Wait.id = *cond;
3000a594: e5832020 str r2, [r3, #32] <== NOT EXECUTED
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
3000a598: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a59c: e59f2048 ldr r2, [pc, #72] ; 3000a5ec <_POSIX_Condition_variables_Wait_support+0x108><== NOT EXECUTED 3000a5a0: eb000de7 bl 3000dd44 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a5a4: eb000cc1 bl 3000d8b0 <_Thread_Enable_dispatch> <== NOT EXECUTED
* a POSIX signal, then pthread_cond_wait returns spuriously,
* according to the POSIX standard. It means that pthread_cond_wait
* returns a success status, except for the fact that it was not
* woken up a pthread_cond_signal or a pthread_cond_broadcast.
*/
status = _Thread_Executing->Wait.return_code;
3000a5a8: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED 3000a5ac: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
if ( status == EINTR )
status = 0;
3000a5b0: e3550004 cmp r5, #4 <== NOT EXECUTED 3000a5b4: 03a05000 moveq r5, #0 <== NOT EXECUTED 3000a5b8: ea000001 b 3000a5c4 <_POSIX_Condition_variables_Wait_support+0xe0><== NOT EXECUTED
} else {
_Thread_Enable_dispatch();
3000a5bc: eb000cbb bl 3000d8b0 <_Thread_Enable_dispatch> <== NOT EXECUTED
status = ETIMEDOUT;
3000a5c0: e3a05074 mov r5, #116 ; 0x74 <== NOT EXECUTED
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
3000a5c4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a5c8: eb0000a6 bl 3000a868 <pthread_mutex_lock> <== NOT EXECUTED
if ( mutex_status )
return EINVAL;
3000a5cc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a5d0: 13a05016 movne r5, #22 <== NOT EXECUTED 3000a5d4: ea000000 b 3000a5dc <_POSIX_Condition_variables_Wait_support+0xf8><== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a5d8: e3a05016 mov r5, #22 <== NOT EXECUTED
}
3000a5dc: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a5e0: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
300108c8 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
300108c8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
300108cc: e5907008 ldr r7, [r0, #8]
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
300108d0: e59f6080 ldr r6, [pc, #128] ; 30010958 <_POSIX_Keys_Run_destructors+0x90> 300108d4: e1a08c27 lsr r8, r7, #24
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
300108d8: e1a07807 lsl r7, r7, #16 300108dc: e2088007 and r8, r8, #7 300108e0: e1a07727 lsr r7, r7, #14
if ( value != NULL ) {
key->Values [ thread_api ][ thread_index ] = NULL;
300108e4: e3a05000 mov r5, #0
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
300108e8: e3a04001 mov r4, #1
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
300108ec: e1d6a1b0 ldrh sl, [r6, #16]
done = true;
300108f0: e1a01004 mov r1, r4
for ( index = 1 ; index <= max ; ++index ) {
300108f4: ea000012 b 30010944 <_POSIX_Keys_Run_destructors+0x7c>
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
300108f8: e596301c ldr r3, [r6, #28] <== NOT EXECUTED
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
300108fc: e7932104 ldr r2, [r3, r4, lsl #2] <== NOT EXECUTED
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
30010900: e3520000 cmp r2, #0 <== NOT EXECUTED 30010904: 0a00000b beq 30010938 <_POSIX_Keys_Run_destructors+0x70> <== NOT EXECUTED 30010908: e5923010 ldr r3, [r2, #16] <== NOT EXECUTED 3001090c: e3530000 cmp r3, #0 <== NOT EXECUTED 30010910: 0a000008 beq 30010938 <_POSIX_Keys_Run_destructors+0x70> <== NOT EXECUTED
void *value = key->Values [ thread_api ][ thread_index ];
30010914: e2880005 add r0, r8, #5 <== NOT EXECUTED 30010918: e7922100 ldr r2, [r2, r0, lsl #2] <== NOT EXECUTED 3001091c: e7920007 ldr r0, [r2, r7] <== NOT EXECUTED
if ( value != NULL ) {
30010920: e3500000 cmp r0, #0 <== NOT EXECUTED 30010924: 0a000003 beq 30010938 <_POSIX_Keys_Run_destructors+0x70> <== NOT EXECUTED
key->Values [ thread_api ][ thread_index ] = NULL;
30010928: e7825007 str r5, [r2, r7] <== NOT EXECUTED
(*key->destructor)( value );
3001092c: e1a0e00f mov lr, pc <== NOT EXECUTED 30010930: e12fff13 bx r3 <== NOT EXECUTED
done = false;
30010934: e1a01005 mov r1, r5 <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
30010938: e2844001 add r4, r4, #1 <== NOT EXECUTED 3001093c: e1a04804 lsl r4, r4, #16 <== NOT EXECUTED 30010940: e1a04824 lsr r4, r4, #16 <== NOT EXECUTED
30010944: e154000a cmp r4, sl
30010948: 9affffea bls 300108f8 <_POSIX_Keys_Run_destructors+0x30>
* number of iterations. An infinite loop may happen if destructors set
* thread specific data. This can be considered dubious.
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
3001094c: e3510000 cmp r1, #0
30010950: 0affffe4 beq 300108e8 <_POSIX_Keys_Run_destructors+0x20>
done = false;
}
}
}
}
}
30010954: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
300150d4 <_POSIX_Message_queue_Create_support>:
const char *name_arg,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
300150d4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
300150d8: e1a06001 mov r6, r1 <== NOT EXECUTED
CORE_message_queue_Attributes *the_mq_attr;
struct mq_attr attr;
char *name;
size_t n;
n = strnlen( name_arg, NAME_MAX );
300150dc: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
const char *name_arg,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
300150e0: e1a04002 mov r4, r2 <== NOT EXECUTED 300150e4: e1a0b003 mov fp, r3 <== NOT EXECUTED 300150e8: e1a09000 mov r9, r0 <== NOT EXECUTED
CORE_message_queue_Attributes *the_mq_attr;
struct mq_attr attr;
char *name;
size_t n;
n = strnlen( name_arg, NAME_MAX );
300150ec: eb00156c bl 3001a6a4 <strnlen> <== NOT EXECUTED 300150f0: e59f3128 ldr r3, [pc, #296] ; 30015220 <_POSIX_Message_queue_Create_support+0x14c><== NOT EXECUTED 300150f4: e1a07000 mov r7, r0 <== NOT EXECUTED 300150f8: e5932000 ldr r2, [r3] <== NOT EXECUTED 300150fc: e2822001 add r2, r2, #1 <== NOT EXECUTED 30015100: e5832000 str r2, [r3] <== NOT EXECUTED
* There is no real basis for the default values. They will work
* but were not compared against any existing implementation for
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
30015104: e3540000 cmp r4, #0 <== NOT EXECUTED 30015108: 0a000009 beq 30015134 <_POSIX_Message_queue_Create_support+0x60><== NOT EXECUTED
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
3001510c: e594a004 ldr sl, [r4, #4] <== NOT EXECUTED 30015110: e35a0000 cmp sl, #0 <== NOT EXECUTED 30015114: da000002 ble 30015124 <_POSIX_Message_queue_Create_support+0x50><== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
30015118: e5948008 ldr r8, [r4, #8] <== NOT EXECUTED 3001511c: e3580000 cmp r8, #0 <== NOT EXECUTED 30015120: ca000005 bgt 3001513c <_POSIX_Message_queue_Create_support+0x68><== NOT EXECUTED
_Thread_Enable_dispatch();
30015124: ebfff50a bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30015128: eb000d48 bl 30018650 <__errno> <== NOT EXECUTED 3001512c: e3a03016 mov r3, #22 <== NOT EXECUTED 30015130: ea00002f b 300151f4 <_POSIX_Message_queue_Create_support+0x120><== NOT EXECUTED
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
30015134: e3a08010 mov r8, #16 <== NOT EXECUTED
* but were not compared against any existing implementation for
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
attr.mq_maxmsg = 10;
30015138: e3a0a00a mov sl, #10 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE
POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void )
{
return (POSIX_Message_queue_Control *)
_Objects_Allocate( &_POSIX_Message_queue_Information );
3001513c: e59f50e0 ldr r5, [pc, #224] ; 30015224 <_POSIX_Message_queue_Create_support+0x150><== NOT EXECUTED 30015140: e1a00005 mov r0, r5 <== NOT EXECUTED 30015144: ebfff0c0 bl 3001144c <_Objects_Allocate> <== NOT EXECUTED
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
30015148: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3001514c: 1a000003 bne 30015160 <_POSIX_Message_queue_Create_support+0x8c><== NOT EXECUTED
_Thread_Enable_dispatch();
30015150: ebfff4ff bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENFILE );
30015154: eb000d3d bl 30018650 <__errno> <== NOT EXECUTED 30015158: e3a03017 mov r3, #23 <== NOT EXECUTED 3001515c: ea000024 b 300151f4 <_POSIX_Message_queue_Create_support+0x120><== NOT EXECUTED
}
the_mq->process_shared = pshared;
the_mq->named = true;
30015160: e3a03001 mov r3, #1 <== NOT EXECUTED
if ( !the_mq ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq->process_shared = pshared;
30015164: e5846010 str r6, [r4, #16] <== NOT EXECUTED
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
name = _Workspace_Allocate(n+1);
30015168: e0876003 add r6, r7, r3 <== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq->process_shared = pshared;
the_mq->named = true;
3001516c: e5c43014 strb r3, [r4, #20] <== NOT EXECUTED
the_mq->open_count = 1;
30015170: e5843018 str r3, [r4, #24] <== NOT EXECUTED
the_mq->linked = true;
30015174: e5c43015 strb r3, [r4, #21] <== NOT EXECUTED
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
name = _Workspace_Allocate(n+1);
30015178: e1a00006 mov r0, r6 <== NOT EXECUTED 3001517c: ebfff95e bl 300136fc <_Workspace_Allocate> <== NOT EXECUTED
if (!name) {
30015180: e2507000 subs r7, r0, #0 <== NOT EXECUTED 30015184: 1a000006 bne 300151a4 <_POSIX_Message_queue_Create_support+0xd0><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );
30015188: e1a00005 mov r0, r5 <== NOT EXECUTED 3001518c: e1a01004 mov r1, r4 <== NOT EXECUTED 30015190: ebfff174 bl 30011768 <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
30015194: ebfff4ee bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
30015198: eb000d2c bl 30018650 <__errno> <== NOT EXECUTED 3001519c: e3a0300c mov r3, #12 <== NOT EXECUTED 300151a0: ea000013 b 300151f4 <_POSIX_Message_queue_Create_support+0x120><== NOT EXECUTED
} strncpy( name, name_arg, n+1 );
300151a4: e1a02006 mov r2, r6 <== NOT EXECUTED 300151a8: e1a01009 mov r1, r9 <== NOT EXECUTED
* * Joel: Cite POSIX or OpenGroup on above statement so we can determine * if it is a real requirement. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
300151ac: e3a06000 mov r6, #0 <== NOT EXECUTED
if (!name) {
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
strncpy( name, name_arg, n+1 );
300151b0: eb001500 bl 3001a5b8 <strncpy> <== NOT EXECUTED
* * Joel: Cite POSIX or OpenGroup on above statement so we can determine * if it is a real requirement. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
300151b4: e584605c str r6, [r4, #92] ; 0x5c <== NOT EXECUTED
if ( !_CORE_message_queue_Initialize(
300151b8: e284001c add r0, r4, #28 <== NOT EXECUTED 300151bc: e284105c add r1, r4, #92 ; 0x5c <== NOT EXECUTED 300151c0: e1a0200a mov r2, sl <== NOT EXECUTED 300151c4: e1a03008 mov r3, r8 <== NOT EXECUTED 300151c8: eb0003ca bl 300160f8 <_CORE_message_queue_Initialize> <== NOT EXECUTED 300151cc: e1500006 cmp r0, r6 <== NOT EXECUTED 300151d0: 1a00000a bne 30015200 <_POSIX_Message_queue_Create_support+0x12c><== NOT EXECUTED 300151d4: e1a01004 mov r1, r4 <== NOT EXECUTED 300151d8: e1a00005 mov r0, r5 <== NOT EXECUTED 300151dc: ebfff161 bl 30011768 <_Objects_Free> <== NOT EXECUTED
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
300151e0: e1a00007 mov r0, r7 <== NOT EXECUTED 300151e4: ebfff94a bl 30013714 <_Workspace_Free> <== NOT EXECUTED
_Thread_Enable_dispatch();
300151e8: ebfff4d9 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
300151ec: eb000d17 bl 30018650 <__errno> <== NOT EXECUTED
300151f0: e3a0301c mov r3, #28 <== NOT EXECUTED
300151f4: e5803000 str r3, [r0] <== NOT EXECUTED
300151f8: e3e00000 mvn r0, #0 <== NOT EXECUTED
300151fc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30015200: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
30015204: e1d420b8 ldrh r2, [r4, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30015208: e7834102 str r4, [r3, r2, lsl #2] <== NOT EXECUTED
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
3001520c: e584700c str r7, [r4, #12] <== NOT EXECUTED
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
30015210: e58b4000 str r4, [fp] <== NOT EXECUTED
_Thread_Enable_dispatch();
30015214: ebfff4ce bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30015218: e1a00006 mov r0, r6 <== NOT EXECUTED
}
3001521c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000e6a8 <_POSIX_Message_queue_Delete>:
void _POSIX_Message_queue_Delete(
POSIX_Message_queue_Control *the_mq
)
{
if ( !the_mq->linked && !the_mq->open_count ) {
3000e6a8: e5d03015 ldrb r3, [r0, #21] <== NOT EXECUTED
*/
void _POSIX_Message_queue_Delete(
POSIX_Message_queue_Control *the_mq
)
{
3000e6ac: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !the_mq->linked && !the_mq->open_count ) {
3000e6b0: e3530000 cmp r3, #0 <== NOT EXECUTED
*/
void _POSIX_Message_queue_Delete(
POSIX_Message_queue_Control *the_mq
)
{
3000e6b4: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( !the_mq->linked && !the_mq->open_count ) {
3000e6b8: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
3000e6bc: e5905018 ldr r5, [r0, #24] <== NOT EXECUTED
3000e6c0: e3550000 cmp r5, #0 <== NOT EXECUTED
3000e6c4: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
);
_Workspace_Free( (void *)the_object->name.name_p );
}
#endif
_Objects_Close( &_POSIX_Message_queue_Information, the_object );
3000e6c8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e6cc: e59f0020 ldr r0, [pc, #32] ; 3000e6f4 <_POSIX_Message_queue_Delete+0x4c><== NOT EXECUTED 3000e6d0: eb000b7f bl 300114d4 <_Objects_Close> <== NOT EXECUTED
_CORE_message_queue_Close(
3000e6d4: e284001c add r0, r4, #28 <== NOT EXECUTED 3000e6d8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000e6dc: e3a02005 mov r2, #5 <== NOT EXECUTED 3000e6e0: eb00086a bl 30010890 <_CORE_message_queue_Close> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );
3000e6e4: e59f0008 ldr r0, [pc, #8] ; 3000e6f4 <_POSIX_Message_queue_Delete+0x4c><== NOT EXECUTED 3000e6e8: e1a01004 mov r1, r4 <== NOT EXECUTED
);
_POSIX_Message_queue_Free( the_mq );
}
}
3000e6ec: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
3000e6f0: ea000c1c b 30011768 <_Objects_Free> <== NOT EXECUTED
30015228 <_POSIX_Message_queue_Name_to_id>:
*/
int _POSIX_Message_queue_Name_to_id(
const char *name,
Objects_Id *id
)
{
30015228: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
3001522c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
*/
int _POSIX_Message_queue_Name_to_id(
const char *name,
Objects_Id *id
)
{
30015230: e1a04001 mov r4, r1 <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
30015234: 0a000011 beq 30015280 <_POSIX_Message_queue_Name_to_id+0x58><== NOT EXECUTED
return EINVAL;
if ( !name[0] )
30015238: e5d53000 ldrb r3, [r5] <== NOT EXECUTED 3001523c: e3530000 cmp r3, #0 <== NOT EXECUTED 30015240: 0a00000e beq 30015280 <_POSIX_Message_queue_Name_to_id+0x58><== NOT EXECUTED
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
30015244: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 30015248: eb001515 bl 3001a6a4 <strnlen> <== NOT EXECUTED 3001524c: e35000fe cmp r0, #254 ; 0xfe <== NOT EXECUTED
return ENAMETOOLONG;
30015250: 83a0005b movhi r0, #91 ; 0x5b <== NOT EXECUTED
return EINVAL;
if ( !name[0] )
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
30015254: 8a00000a bhi 30015284 <_POSIX_Message_queue_Name_to_id+0x5c><== NOT EXECUTED
return ENAMETOOLONG;
status = _Objects_Name_to_id_string(
30015258: e59f0028 ldr r0, [pc, #40] ; 30015288 <_POSIX_Message_queue_Name_to_id+0x60><== NOT EXECUTED 3001525c: e1a01005 mov r1, r5 <== NOT EXECUTED 30015260: e1a0200d mov r2, sp <== NOT EXECUTED 30015264: eb00056d bl 30016820 <_Objects_Name_to_id_string> <== NOT EXECUTED
&_POSIX_Message_queue_Information,
name,
&the_id
);
*id = the_id;
30015268: e59d3000 ldr r3, [sp] <== NOT EXECUTED
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
3001526c: e3500000 cmp r0, #0 <== NOT EXECUTED
status = _Objects_Name_to_id_string(
&_POSIX_Message_queue_Information,
name,
&the_id
);
*id = the_id;
30015270: e5843000 str r3, [r4] <== NOT EXECUTED
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
30015274: 13a00002 movne r0, #2 <== NOT EXECUTED 30015278: 03a00000 moveq r0, #0 <== NOT EXECUTED 3001527c: ea000000 b 30015284 <_POSIX_Message_queue_Name_to_id+0x5c> <== NOT EXECUTED
if ( !name )
return EINVAL;
if ( !name[0] )
return EINVAL;
30015280: e3a00016 mov r0, #22 <== NOT EXECUTED
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
30015284: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000e778 <_POSIX_Message_queue_Notify_handler>:
*/
void _POSIX_Message_queue_Notify_handler(
void *user_data
)
{
3000e778: e92d4010 push {r4, lr} <== NOT EXECUTED
3000e77c: e1a04000 mov r4, r0 <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
the_mq = user_data;
kill( getpid(), the_mq->notification.sigev_signo );
3000e780: eb0018b6 bl 30014a60 <getpid> <== NOT EXECUTED 3000e784: e5941094 ldr r1, [r4, #148] ; 0x94 <== NOT EXECUTED 3000e788: eb001a4f bl 300150cc <kill> <== NOT EXECUTED
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
3000e78c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000e790: e584307c str r3, [r4, #124] ; 0x7c <== NOT EXECUTED
the_message_queue->notify_argument = the_argument;
3000e794: e5843080 str r3, [r4, #128] ; 0x80 <== NOT EXECUTED
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
}
3000e798: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000e9e0 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3000e9e0: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000e9e4: e1a04000 mov r4, r0 <== NOT EXECUTED
3000e9e8: e1a06001 mov r6, r1 <== NOT EXECUTED
3000e9ec: e1a07002 mov r7, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
3000e9f0: e59f00f0 ldr r0, [pc, #240] ; 3000eae8 <_POSIX_Message_queue_Receive_support+0x108><== NOT EXECUTED 3000e9f4: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e9f8: e28d200c add r2, sp, #12 <== NOT EXECUTED 3000e9fc: e1a05003 mov r5, r3 <== NOT EXECUTED 3000ea00: e5dd8028 ldrb r8, [sp, #40] ; 0x28 <== NOT EXECUTED 3000ea04: eb000bac bl 300118bc <_Objects_Get> <== NOT EXECUTED
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000ea08: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3000ea0c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ea10: 1a00002e bne 3000ead0 <_POSIX_Message_queue_Receive_support+0xf0><== NOT EXECUTED
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
3000ea14: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000ea18: e2032003 and r2, r3, #3 <== NOT EXECUTED 3000ea1c: e3520001 cmp r2, #1 <== NOT EXECUTED 3000ea20: 1a000001 bne 3000ea2c <_POSIX_Message_queue_Receive_support+0x4c><== NOT EXECUTED
_Thread_Enable_dispatch();
3000ea24: eb000eca bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000ea28: ea000028 b 3000ead0 <_POSIX_Message_queue_Receive_support+0xf0><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
3000ea2c: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
3000ea30: e5902068 ldr r2, [r0, #104] ; 0x68 <== NOT EXECUTED 3000ea34: e1570002 cmp r7, r2 <== NOT EXECUTED 3000ea38: 2a000003 bcs 3000ea4c <_POSIX_Message_queue_Receive_support+0x6c><== NOT EXECUTED
_Thread_Enable_dispatch();
3000ea3c: eb000ec4 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMSGSIZE );
3000ea40: eb002702 bl 30018650 <__errno> <== NOT EXECUTED 3000ea44: e3a0307a mov r3, #122 ; 0x7a <== NOT EXECUTED 3000ea48: ea000022 b 3000ead8 <_POSIX_Message_queue_Receive_support+0xf8><== NOT EXECUTED
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
3000ea4c: e3e02000 mvn r2, #0 <== NOT EXECUTED
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000ea50: e3580000 cmp r8, #0 <== NOT EXECUTED
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
3000ea54: e58d2008 str r2, [sp, #8] <== NOT EXECUTED
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000ea58: 0a000002 beq 3000ea68 <_POSIX_Message_queue_Receive_support+0x88><== NOT EXECUTED
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
3000ea5c: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 3000ea60: 13a08000 movne r8, #0 <== NOT EXECUTED 3000ea64: 03a08001 moveq r8, #1 <== NOT EXECUTED
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
3000ea68: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED 3000ea6c: e1a01004 mov r1, r4 <== NOT EXECUTED
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
3000ea70: e59f4074 ldr r4, [pc, #116] ; 3000eaec <_POSIX_Message_queue_Receive_support+0x10c><== NOT EXECUTED
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
3000ea74: e280001c add r0, r0, #28 <== NOT EXECUTED 3000ea78: e1a02006 mov r2, r6 <== NOT EXECUTED 3000ea7c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000ea80: e28d3008 add r3, sp, #8 <== NOT EXECUTED 3000ea84: e58d8000 str r8, [sp] <== NOT EXECUTED 3000ea88: eb0007a1 bl 30010914 <_CORE_message_queue_Seize> <== NOT EXECUTED
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
3000ea8c: eb000eb0 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
3000ea90: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return ((priority >= 0) ? priority : -priority);
3000ea94: e5932024 ldr r2, [r3, #36] ; 0x24 <== NOT EXECUTED
if ( !_Thread_Executing->Wait.return_code )
3000ea98: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000ea9c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000eaa0: b2622000 rsblt r2, r2, #0 <== NOT EXECUTED 3000eaa4: e3530000 cmp r3, #0 <== NOT EXECUTED
do_wait,
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
3000eaa8: e5852000 str r2, [r5] <== NOT EXECUTED
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
return length_out;
3000eaac: 059d0008 ldreq r0, [sp, #8] <== NOT EXECUTED
_Thread_Enable_dispatch();
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
3000eab0: 0a00000a beq 3000eae0 <_POSIX_Message_queue_Receive_support+0x100><== NOT EXECUTED
return length_out;
rtems_set_errno_and_return_minus_one(
3000eab4: eb0026e5 bl 30018650 <__errno> <== NOT EXECUTED 3000eab8: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3000eabc: e1a05000 mov r5, r0 <== NOT EXECUTED 3000eac0: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000eac4: eb00009b bl 3000ed38 <_POSIX_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED 3000eac8: e5850000 str r0, [r5] <== NOT EXECUTED 3000eacc: ea000002 b 3000eadc <_POSIX_Message_queue_Receive_support+0xfc><== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000ead0: eb0026de bl 30018650 <__errno> <== NOT EXECUTED 3000ead4: e3a03009 mov r3, #9 <== NOT EXECUTED 3000ead8: e5803000 str r3, [r0] <== NOT EXECUTED 3000eadc: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000eae0: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000eae4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000eb0c <_POSIX_Message_queue_Send_support>:
size_t msg_len,
uint32_t msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3000eb0c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
3000eb10: e3530020 cmp r3, #32 <== NOT EXECUTED
size_t msg_len,
uint32_t msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3000eb14: e24dd014 sub sp, sp, #20 <== NOT EXECUTED 3000eb18: e1a04000 mov r4, r0 <== NOT EXECUTED 3000eb1c: e1a06001 mov r6, r1 <== NOT EXECUTED 3000eb20: e1a05002 mov r5, r2 <== NOT EXECUTED 3000eb24: e1a07003 mov r7, r3 <== NOT EXECUTED 3000eb28: e5dd802c ldrb r8, [sp, #44] ; 0x2c <== NOT EXECUTED
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
3000eb2c: 9a000002 bls 3000eb3c <_POSIX_Message_queue_Send_support+0x30><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000eb30: eb0026c6 bl 30018650 <__errno> <== NOT EXECUTED 3000eb34: e3a03016 mov r3, #22 <== NOT EXECUTED 3000eb38: ea00002d b 3000ebf4 <_POSIX_Message_queue_Send_support+0xe8><== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
3000eb3c: e59f00c0 ldr r0, [pc, #192] ; 3000ec04 <_POSIX_Message_queue_Send_support+0xf8><== NOT EXECUTED 3000eb40: e1a01004 mov r1, r4 <== NOT EXECUTED 3000eb44: e28d2010 add r2, sp, #16 <== NOT EXECUTED 3000eb48: eb000b5b bl 300118bc <_Objects_Get> <== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000eb4c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000eb50: e3530000 cmp r3, #0 <== NOT EXECUTED 3000eb54: 1a000024 bne 3000ebec <_POSIX_Message_queue_Send_support+0xe0><== NOT EXECUTED
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
3000eb58: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000eb5c: e3130003 tst r3, #3 <== NOT EXECUTED 3000eb60: 1a000001 bne 3000eb6c <_POSIX_Message_queue_Send_support+0x60><== NOT EXECUTED
_Thread_Enable_dispatch();
3000eb64: eb000e7a bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000eb68: ea00001f b 3000ebec <_POSIX_Message_queue_Send_support+0xe0><== NOT EXECUTED
the_mq = the_mq_fd->Queue;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000eb6c: e3580000 cmp r8, #0 <== NOT EXECUTED
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
3000eb70: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000eb74: 0a000002 beq 3000eb84 <_POSIX_Message_queue_Send_support+0x78><== NOT EXECUTED
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
3000eb78: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 3000eb7c: 13a08000 movne r8, #0 <== NOT EXECUTED 3000eb80: 03a08001 moveq r8, #1 <== NOT EXECUTED
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
3000eb84: e3a03000 mov r3, #0 <== NOT EXECUTED 3000eb88: e58d3000 str r3, [sp] <== NOT EXECUTED 3000eb8c: e59d3030 ldr r3, [sp, #48] ; 0x30 <== NOT EXECUTED 3000eb90: e1a01006 mov r1, r6 <== NOT EXECUTED 3000eb94: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000eb98: e1a02005 mov r2, r5 <== NOT EXECUTED 3000eb9c: e1a03004 mov r3, r4 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE CORE_message_queue_Submit_types _POSIX_Message_queue_Priority_to_core(
unsigned int priority
)
{
return priority * -1;
3000eba0: e2677000 rsb r7, r7, #0 <== NOT EXECUTED
3000eba4: e280001c add r0, r0, #28 <== NOT EXECUTED
3000eba8: e98d0180 stmib sp, {r7, r8} <== NOT EXECUTED
3000ebac: eb0007a4 bl 30010a44 <_CORE_message_queue_Submit> <== NOT EXECUTED
3000ebb0: e1a04000 mov r4, r0 <== NOT EXECUTED
_POSIX_Message_queue_Priority_to_core( msg_prio ),
do_wait,
timeout /* no timeout */
);
_Thread_Enable_dispatch();
3000ebb4: eb000e66 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
* after it wakes up. The returned status is correct for
* non-blocking operations but if we blocked, then we need
* to look at the status in our TCB.
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
3000ebb8: e3540007 cmp r4, #7 <== NOT EXECUTED
msg_status = _Thread_Executing->Wait.return_code;
3000ebbc: 059f3044 ldreq r3, [pc, #68] ; 3000ec08 <_POSIX_Message_queue_Send_support+0xfc><== NOT EXECUTED 3000ebc0: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000ebc4: 05934034 ldreq r4, [r3, #52] ; 0x34 <== NOT EXECUTED
if ( !msg_status )
3000ebc8: e3540000 cmp r4, #0 <== NOT EXECUTED
return msg_status;
3000ebcc: 01a00004 moveq r0, r4 <== NOT EXECUTED
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
3000ebd0: 0a000009 beq 3000ebfc <_POSIX_Message_queue_Send_support+0xf0><== NOT EXECUTED
return msg_status;
rtems_set_errno_and_return_minus_one(
3000ebd4: eb00269d bl 30018650 <__errno> <== NOT EXECUTED 3000ebd8: e1a05000 mov r5, r0 <== NOT EXECUTED 3000ebdc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ebe0: eb000054 bl 3000ed38 <_POSIX_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED 3000ebe4: e5850000 str r0, [r5] <== NOT EXECUTED 3000ebe8: ea000002 b 3000ebf8 <_POSIX_Message_queue_Send_support+0xec><== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000ebec: eb002697 bl 30018650 <__errno> <== NOT EXECUTED 3000ebf0: e3a03009 mov r3, #9 <== NOT EXECUTED 3000ebf4: e5803000 str r3, [r0] <== NOT EXECUTED 3000ebf8: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000ebfc: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000ec00: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000ed38 <_POSIX_Message_queue_Translate_core_message_queue_return_code>:
#if defined(RTEMS_DEBUG)
if ( the_message_queue_status > CORE_MESSAGE_QUEUE_STATUS_LAST )
return EINVAL;
#endif
return _POSIX_Message_queue_Return_codes[the_message_queue_status];
}
3000ed38: e59f3004 ldr r3, [pc, #4] ; 3000ed44 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0xc><== NOT EXECUTED 3000ed3c: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3000ed40: e12fff1e bx lr <== NOT EXECUTED
3000f908 <_POSIX_Priority_Is_valid>:
bool _POSIX_Priority_Is_valid(
int priority
)
{
return ((priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY) &&
3000f908: e3500000 cmp r0, #0
3000f90c: da000005 ble 3000f928 <_POSIX_Priority_Is_valid+0x20>
(priority <= POSIX_SCHEDULER_MAXIMUM_PRIORITY));
3000f910: e59f3018 ldr r3, [pc, #24] ; 3000f930 <_POSIX_Priority_Is_valid+0x28> 3000f914: e5d33000 ldrb r3, [r3]
#endif
#include <rtems/system.h>
#include <rtems/posix/priority.h>
bool _POSIX_Priority_Is_valid(
3000f918: e1530000 cmp r3, r0 3000f91c: d3a00000 movle r0, #0 3000f920: c3a00001 movgt r0, #1 3000f924: e12fff1e bx lr
int priority
)
{
return ((priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY) &&
3000f928: e3a00000 mov r0, #0 <== NOT EXECUTED
(priority <= POSIX_SCHEDULER_MAXIMUM_PRIORITY));
}
3000f92c: e12fff1e bx lr <== NOT EXECUTED
3000abcc <_POSIX_RWLock_Translate_core_RWLock_return_code>:
#if defined(RTEMS_DEBUG)
if ( the_rwlock_status > CORE_RWLOCK_STATUS_LAST )
return EINVAL;
#endif
return _POSIX_RWLock_Return_codes[the_rwlock_status];
}
3000abcc: e59f3004 ldr r3, [pc, #4] ; 3000abd8 <_POSIX_RWLock_Translate_core_RWLock_return_code+0xc><== NOT EXECUTED 3000abd0: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3000abd4: e12fff1e bx lr <== NOT EXECUTED
300124ec <_POSIX_Semaphore_Create_support>:
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name_p = (char *)name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
300124ec: e3510000 cmp r1, #0 <== NOT EXECUTED
const char *name,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
300124f0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
300124f4: e1a04000 mov r4, r0 <== NOT EXECUTED
300124f8: e1a08002 mov r8, r2 <== NOT EXECUTED
300124fc: e1a07003 mov r7, r3 <== NOT EXECUTED
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name_p = (char *)name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
30012500: 0a000002 beq 30012510 <_POSIX_Semaphore_Create_support+0x24><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30012504: eb000b44 bl 3001521c <__errno> <== NOT EXECUTED 30012508: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3001250c: ea000013 b 30012560 <_POSIX_Semaphore_Create_support+0x74> <== NOT EXECUTED
if ( name ) {
30012510: e3500000 cmp r0, #0 <== NOT EXECUTED 30012514: 0a000006 beq 30012534 <_POSIX_Semaphore_Create_support+0x48><== NOT EXECUTED
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
30012518: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 3001251c: eb001179 bl 30016b08 <strnlen> <== NOT EXECUTED 30012520: e35000fe cmp r0, #254 ; 0xfe <== NOT EXECUTED 30012524: 9a000002 bls 30012534 <_POSIX_Semaphore_Create_support+0x48><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
30012528: eb000b3b bl 3001521c <__errno> <== NOT EXECUTED 3001252c: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 30012530: ea00000a b 30012560 <_POSIX_Semaphore_Create_support+0x74> <== NOT EXECUTED 30012534: e59f309c ldr r3, [pc, #156] ; 300125d8 <_POSIX_Semaphore_Create_support+0xec><== NOT EXECUTED 30012538: e5932000 ldr r2, [r3] <== NOT EXECUTED 3001253c: e2822001 add r2, r2, #1 <== NOT EXECUTED 30012540: e5832000 str r2, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
_Objects_Allocate( &_POSIX_Semaphore_Information );
30012544: e59f0090 ldr r0, [pc, #144] ; 300125dc <_POSIX_Semaphore_Create_support+0xf0><== NOT EXECUTED 30012548: ebffee8a bl 3000df78 <_Objects_Allocate> <== NOT EXECUTED
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
3001254c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30012550: 1a000005 bne 3001256c <_POSIX_Semaphore_Create_support+0x80><== NOT EXECUTED
_Thread_Enable_dispatch();
30012554: ebfff2c9 bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
30012558: eb000b2f bl 3001521c <__errno> <== NOT EXECUTED
3001255c: e3a0301c mov r3, #28 <== NOT EXECUTED
30012560: e5803000 str r3, [r0] <== NOT EXECUTED
30012564: e3e00000 mvn r0, #0 <== NOT EXECUTED
30012568: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
the_semaphore->process_shared = pshared;
3001256c: e3a03000 mov r3, #0 <== NOT EXECUTED
if ( name ) {
30012570: e1540003 cmp r4, r3 <== NOT EXECUTED
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOSPC );
}
the_semaphore->process_shared = pshared;
30012574: e5853010 str r3, [r5, #16] <== NOT EXECUTED
if ( name ) {
the_semaphore->named = true;
30012578: 12833001 addne r3, r3, #1 <== NOT EXECUTED 3001257c: 15c53014 strbne r3, [r5, #20] <== NOT EXECUTED
the_semaphore->open_count = 1;
30012580: 15853018 strne r3, [r5, #24] <== NOT EXECUTED
the_semaphore->linked = true;
30012584: 15c53015 strbne r3, [r5, #21] <== NOT EXECUTED
* blocking tasks on this semaphore should be. It could somehow * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
30012588: e3a06000 mov r6, #0 <== NOT EXECUTED
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
3001258c: e3e03000 mvn r3, #0 <== NOT EXECUTED
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
30012590: e285001c add r0, r5, #28 <== NOT EXECUTED
if ( name ) {
the_semaphore->named = true;
the_semaphore->open_count = 1;
the_semaphore->linked = true;
} else {
the_semaphore->named = false;
30012594: 05c54014 strbeq r4, [r5, #20] <== NOT EXECUTED
the_semaphore->open_count = 0;
30012598: 05854018 streq r4, [r5, #24] <== NOT EXECUTED
the_semaphore->linked = false;
3001259c: 05c54015 strbeq r4, [r5, #21] <== NOT EXECUTED
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
300125a0: e585305c str r3, [r5, #92] ; 0x5c <== NOT EXECUTED
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
300125a4: e285105c add r1, r5, #92 ; 0x5c <== NOT EXECUTED 300125a8: e1a02008 mov r2, r8 <== NOT EXECUTED
* blocking tasks on this semaphore should be. It could somehow * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
300125ac: e5856060 str r6, [r5, #96] ; 0x60 <== NOT EXECUTED
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
300125b0: ebffecfe bl 3000d9b0 <_CORE_semaphore_Initialize> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300125b4: e59f3020 ldr r3, [pc, #32] ; 300125dc <_POSIX_Semaphore_Create_support+0xf0><== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
300125b8: e1d520b8 ldrh r2, [r5, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300125bc: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 300125c0: e7835102 str r5, [r3, r2, lsl #2] <== NOT EXECUTED
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
300125c4: e585400c str r4, [r5, #12] <== NOT EXECUTED
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name_p
);
*the_sem = the_semaphore;
300125c8: e5875000 str r5, [r7] <== NOT EXECUTED
_Thread_Enable_dispatch();
300125cc: ebfff2ab bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
300125d0: e1a00006 mov r0, r6 <== NOT EXECUTED
}
300125d4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300125e0 <_POSIX_Semaphore_Delete>:
void _POSIX_Semaphore_Delete(
POSIX_Semaphore_Control *the_semaphore
)
{
if ( !the_semaphore->linked && !the_semaphore->open_count ) {
300125e0: e5d03015 ldrb r3, [r0, #21] <== NOT EXECUTED
*/
void _POSIX_Semaphore_Delete(
POSIX_Semaphore_Control *the_semaphore
)
{
300125e4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !the_semaphore->linked && !the_semaphore->open_count ) {
300125e8: e3530000 cmp r3, #0 <== NOT EXECUTED
*/
void _POSIX_Semaphore_Delete(
POSIX_Semaphore_Control *the_semaphore
)
{
300125ec: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( !the_semaphore->linked && !the_semaphore->open_count ) {
300125f0: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
300125f4: e5905018 ldr r5, [r0, #24] <== NOT EXECUTED
300125f8: e3550000 cmp r5, #0 <== NOT EXECUTED
300125fc: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
_Objects_Close( &_POSIX_Semaphore_Information, &the_semaphore->Object );
30012600: e1a01004 mov r1, r4 <== NOT EXECUTED 30012604: e59f0020 ldr r0, [pc, #32] ; 3001262c <_POSIX_Semaphore_Delete+0x4c><== NOT EXECUTED 30012608: ebffee7c bl 3000e000 <_Objects_Close> <== NOT EXECUTED
_CORE_semaphore_Flush(
3001260c: e284001c add r0, r4, #28 <== NOT EXECUTED 30012610: e1a01005 mov r1, r5 <== NOT EXECUTED 30012614: e3e02000 mvn r2, #0 <== NOT EXECUTED 30012618: ebffece3 bl 3000d9ac <_CORE_semaphore_Flush> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
3001261c: e59f0008 ldr r0, [pc, #8] ; 3001262c <_POSIX_Semaphore_Delete+0x4c><== NOT EXECUTED 30012620: e1a01004 mov r1, r4 <== NOT EXECUTED
-1
);
_POSIX_Semaphore_Free( the_semaphore );
}
}
30012624: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
30012628: eaffef19 b 3000e294 <_Objects_Free> <== NOT EXECUTED
30012630 <_POSIX_Semaphore_Name_to_id>:
int _POSIX_Semaphore_Name_to_id(
const char *name,
sem_t *id
)
{
30012630: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
30012634: e1a04001 mov r4, r1 <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
30012638: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3001263c: 0a00000b beq 30012670 <_POSIX_Semaphore_Name_to_id+0x40> <== NOT EXECUTED
return EINVAL;
if ( !name[0] )
30012640: e5d13000 ldrb r3, [r1] <== NOT EXECUTED 30012644: e3530000 cmp r3, #0 <== NOT EXECUTED 30012648: 0a000008 beq 30012670 <_POSIX_Semaphore_Name_to_id+0x40> <== NOT EXECUTED
return EINVAL;
status = _Objects_Name_to_id_string(
3001264c: e59f0024 ldr r0, [pc, #36] ; 30012678 <_POSIX_Semaphore_Name_to_id+0x48><== NOT EXECUTED 30012650: e1a0200d mov r2, sp <== NOT EXECUTED 30012654: eb00035c bl 300133cc <_Objects_Name_to_id_string> <== NOT EXECUTED
&_POSIX_Semaphore_Information,
name,
&the_id
);
*id = the_id;
30012658: e59d3000 ldr r3, [sp] <== NOT EXECUTED
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
3001265c: e3500000 cmp r0, #0 <== NOT EXECUTED
status = _Objects_Name_to_id_string(
&_POSIX_Semaphore_Information,
name,
&the_id
);
*id = the_id;
30012660: e5843000 str r3, [r4] <== NOT EXECUTED
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
30012664: 13a00002 movne r0, #2 <== NOT EXECUTED 30012668: 03a00000 moveq r0, #0 <== NOT EXECUTED 3001266c: ea000000 b 30012674 <_POSIX_Semaphore_Name_to_id+0x44> <== NOT EXECUTED
if ( !name )
return EINVAL;
if ( !name[0] )
return EINVAL;
30012670: e3a00016 mov r0, #22 <== NOT EXECUTED
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
30012674: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
30014d30 <_POSIX_Semaphore_Translate_core_semaphore_return_code>:
#if defined(RTEMS_DEBUG)
if ( the_semaphore_status > CORE_SEMAPHORE_STATUS_LAST )
return EINVAL;
#endif
return _POSIX_Semaphore_Return_codes[the_semaphore_status];
}
30014d30: e59f3004 ldr r3, [pc, #4] ; 30014d3c <_POSIX_Semaphore_Translate_core_semaphore_return_code+0xc><== NOT EXECUTED 30014d34: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 30014d38: e12fff1e bx lr <== NOT EXECUTED
300126bc <_POSIX_Semaphore_Wait_support>:
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,
Watchdog_Interval timeout
)
{
300126bc: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
300126c0: e1a03000 mov r3, r0 <== NOT EXECUTED
300126c4: e1a04002 mov r4, r2 <== NOT EXECUTED
300126c8: e20150ff and r5, r1, #255 ; 0xff <== NOT EXECUTED
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
_Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location );
300126cc: e1a0200d mov r2, sp <== NOT EXECUTED 300126d0: e5931000 ldr r1, [r3] <== NOT EXECUTED 300126d4: e59f006c ldr r0, [pc, #108] ; 30012748 <_POSIX_Semaphore_Wait_support+0x8c><== NOT EXECUTED 300126d8: ebffef42 bl 3000e3e8 <_Objects_Get> <== NOT EXECUTED
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
300126dc: e59d2000 ldr r2, [sp] <== NOT EXECUTED 300126e0: e1a03000 mov r3, r0 <== NOT EXECUTED 300126e4: e3520000 cmp r2, #0 <== NOT EXECUTED 300126e8: 1a000011 bne 30012734 <_POSIX_Semaphore_Wait_support+0x78> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
300126ec: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED 300126f0: e1a03004 mov r3, r4 <== NOT EXECUTED
blocking,
timeout
);
_Thread_Enable_dispatch();
if ( !_Thread_Executing->Wait.return_code )
300126f4: e59f4050 ldr r4, [pc, #80] ; 3001274c <_POSIX_Semaphore_Wait_support+0x90><== NOT EXECUTED
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
300126f8: e280001c add r0, r0, #28 <== NOT EXECUTED 300126fc: e1a02005 mov r2, r5 <== NOT EXECUTED 30012700: eb0001cc bl 30012e38 <_CORE_semaphore_Seize> <== NOT EXECUTED
&the_semaphore->Semaphore,
the_semaphore->Object.id,
blocking,
timeout
);
_Thread_Enable_dispatch();
30012704: ebfff25d bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !_Thread_Executing->Wait.return_code )
30012708: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3001270c: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 30012710: e3500000 cmp r0, #0 <== NOT EXECUTED 30012714: 0a00000a beq 30012744 <_POSIX_Semaphore_Wait_support+0x88> <== NOT EXECUTED
return 0;
rtems_set_errno_and_return_minus_one(
30012718: eb000abf bl 3001521c <__errno> <== NOT EXECUTED 3001271c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30012720: e1a05000 mov r5, r0 <== NOT EXECUTED 30012724: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 30012728: eb000980 bl 30014d30 <_POSIX_Semaphore_Translate_core_semaphore_return_code><== NOT EXECUTED 3001272c: e5850000 str r0, [r5] <== NOT EXECUTED 30012730: ea000002 b 30012740 <_POSIX_Semaphore_Wait_support+0x84> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
30012734: eb000ab8 bl 3001521c <__errno> <== NOT EXECUTED 30012738: e3a03016 mov r3, #22 <== NOT EXECUTED 3001273c: e5803000 str r3, [r0] <== NOT EXECUTED 30012740: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
30012744: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
300098ec <_POSIX_Spinlock_Translate_core_spinlock_return_code>:
#if defined(RTEMS_DEBUG)
if ( the_spinlock_status > CORE_SPINLOCK_STATUS_LAST )
return EINVAL;
#endif
return _POSIX_Spinlock_Return_codes[the_spinlock_status];
}
300098ec: e59f3004 ldr r3, [pc, #4] ; 300098f8 <_POSIX_Spinlock_Translate_core_spinlock_return_code+0xc><== NOT EXECUTED 300098f0: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 300098f4: e12fff1e bx lr <== NOT EXECUTED
3000e4f8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
Thread_Control *the_thread
)
{
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000e4f8: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
3000e4fc: e59320d8 ldr r2, [r3, #216] ; 0xd8 <== NOT EXECUTED 3000e500: e3520000 cmp r2, #0 <== NOT EXECUTED 3000e504: 1a00000b bne 3000e538 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x40><== NOT EXECUTED 3000e508: e59320dc ldr r2, [r3, #220] ; 0xdc <== NOT EXECUTED 3000e50c: e3520001 cmp r2, #1 <== NOT EXECUTED 3000e510: 1a000008 bne 3000e538 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x40><== NOT EXECUTED
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
3000e514: e59330e0 ldr r3, [r3, #224] ; 0xe0 <== NOT EXECUTED 3000e518: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e51c: 0a000005 beq 3000e538 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x40><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000e520: e59f3014 ldr r3, [pc, #20] ; 3000e53c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NOT EXECUTED
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
3000e524: e3e01000 mvn r1, #0 <== NOT EXECUTED 3000e528: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000e52c: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000e530: e5832000 str r2, [r3] <== NOT EXECUTED 3000e534: ea000201 b 3000ed40 <_POSIX_Thread_Exit> <== NOT EXECUTED
} else
_Thread_Enable_dispatch();
3000e538: eafff5b2 b 3000bc08 <_Thread_Enable_dispatch> <== NOT EXECUTED
3000f934 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
3000f934: e92d40f0 push {r4, r5, r6, r7, lr}
3000f938: e1a04000 mov r4, r0
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
3000f93c: e5910000 ldr r0, [r1]
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
3000f940: e1a05001 mov r5, r1 3000f944: e1a06002 mov r6, r2 3000f948: e1a07003 mov r7, r3
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
3000f94c: ebffffed bl 3000f908 <_POSIX_Priority_Is_valid> 3000f950: e3500000 cmp r0, #0
3000f954: 0a00002b beq 3000fa08 <_POSIX_Thread_Translate_sched_param+0xd4>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
3000f958: e3a00000 mov r0, #0
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
3000f95c: e1540000 cmp r4, r0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
3000f960: 03a03001 moveq r3, #1
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
3000f964: e5860000 str r0, [r6]
*budget_callout = NULL;
3000f968: e5870000 str r0, [r7]
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
3000f96c: 05863000 streq r3, [r6]
return 0;
3000f970: 01a00004 moveq r0, r4
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
3000f974: 08bd80f0 popeq {r4, r5, r6, r7, pc}
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
3000f978: e3540001 cmp r4, #1
3000f97c: 08bd80f0 popeq {r4, r5, r6, r7, pc}
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
3000f980: e3540002 cmp r4, #2 <== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
3000f984: 05864000 streq r4, [r6] <== NOT EXECUTED
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
3000f988: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
3000f98c: e3540004 cmp r4, #4 <== NOT EXECUTED 3000f990: 1a00001c bne 3000fa08 <_POSIX_Thread_Translate_sched_param+0xd4><== NOT EXECUTED
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
3000f994: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000f998: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f99c: 1a000002 bne 3000f9ac <_POSIX_Thread_Translate_sched_param+0x78><== NOT EXECUTED 3000f9a0: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000f9a4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f9a8: 0a000016 beq 3000fa08 <_POSIX_Thread_Translate_sched_param+0xd4><== NOT EXECUTED
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
3000f9ac: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED 3000f9b0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f9b4: 1a000002 bne 3000f9c4 <_POSIX_Thread_Translate_sched_param+0x90><== NOT EXECUTED 3000f9b8: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 3000f9bc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f9c0: 0a000010 beq 3000fa08 <_POSIX_Thread_Translate_sched_param+0xd4><== NOT EXECUTED
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
3000f9c4: e2850008 add r0, r5, #8 <== NOT EXECUTED 3000f9c8: ebfff6c3 bl 3000d4dc <_Timespec_To_ticks> <== NOT EXECUTED 3000f9cc: e1a04000 mov r4, r0 <== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
3000f9d0: e2850010 add r0, r5, #16 <== NOT EXECUTED 3000f9d4: ebfff6c0 bl 3000d4dc <_Timespec_To_ticks> <== NOT EXECUTED
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
3000f9d8: e1540000 cmp r4, r0 <== NOT EXECUTED 3000f9dc: 3a000009 bcc 3000fa08 <_POSIX_Thread_Translate_sched_param+0xd4><== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
3000f9e0: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 3000f9e4: ebffffc7 bl 3000f908 <_POSIX_Priority_Is_valid> <== NOT EXECUTED 3000f9e8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f9ec: 0a000007 beq 3000fa10 <_POSIX_Thread_Translate_sched_param+0xdc><== NOT EXECUTED
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
3000f9f0: e3a03003 mov r3, #3 <== NOT EXECUTED 3000f9f4: e5863000 str r3, [r6] <== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
3000f9f8: e59f3018 ldr r3, [pc, #24] ; 3000fa18 <_POSIX_Thread_Translate_sched_param+0xe4><== NOT EXECUTED
return 0;
3000f9fc: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
3000fa00: e5873000 str r3, [r7] <== NOT EXECUTED
return 0;
3000fa04: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
3000fa08: e3a00016 mov r0, #22 <== NOT EXECUTED
3000fa0c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
3000fa10: e3a00016 mov r0, #22 <== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
3000fa14: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000e664 <_POSIX_Threads_Delete_extension>:
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
3000e664: e92d40f0 push {r4, r5, r6, r7, lr}
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
3000e668: e1a00001 mov r0, r1
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
3000e66c: e1a04001 mov r4, r1
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
3000e670: e59150fc ldr r5, [r1, #252] ; 0xfc
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
3000e674: eb00087c bl 3001086c <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
3000e678: e1a00004 mov r0, r4 3000e67c: eb000891 bl 300108c8 <_POSIX_Keys_Run_destructors>
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
3000e680: e2856044 add r6, r5, #68 ; 0x44
_POSIX_Keys_Run_destructors( deleted );
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
3000e684: e5947028 ldr r7, [r4, #40] ; 0x28
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
3000e688: ea000001 b 3000e694 <_POSIX_Threads_Delete_extension+0x30>
*(void **)the_thread->Wait.return_argument = value_ptr;
3000e68c: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 3000e690: e5837000 str r7, [r3] <== NOT EXECUTED
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
3000e694: e1a00006 mov r0, r6 3000e698: ebfff536 bl 3000bb78 <_Thread_queue_Dequeue> 3000e69c: e3500000 cmp r0, #0
3000e6a0: 1afffff9 bne 3000e68c <_POSIX_Threads_Delete_extension+0x28>
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
3000e6a4: e5953084 ldr r3, [r5, #132] ; 0x84 3000e6a8: e3530004 cmp r3, #4
(void) _Watchdog_Remove( &api->Sporadic_timer );
3000e6ac: 028500a8 addeq r0, r5, #168 ; 0xa8 3000e6b0: 0bfff82b bleq 3000c764 <_Watchdog_Remove>
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
3000e6b4: e3a03000 mov r3, #0
_Workspace_Free( api );
3000e6b8: e1a00005 mov r0, r5
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
3000e6bc: e58430fc str r3, [r4, #252] ; 0xfc
_Workspace_Free( api );
}
3000e6c0: e8bd40f0 pop {r4, r5, r6, r7, lr}
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
_Workspace_Free( api );
3000e6c4: eafff88f b 3000c908 <_Workspace_Free>
3000e7e0 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
3000e7e0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000e7e4: e59140fc ldr r4, [r1, #252] ; 0xfc <== NOT EXECUTED
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
3000e7e8: e1a05001 mov r5, r1 <== NOT EXECUTED
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
3000e7ec: e2840098 add r0, r4, #152 ; 0x98 <== NOT EXECUTED 3000e7f0: eb0003ce bl 3000f730 <_Timespec_To_ticks> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000e7f4: e59f304c ldr r3, [pc, #76] ; 3000e848 <_POSIX_Threads_Sporadic_budget_TSR+0x68><== NOT EXECUTED
the_thread->cpu_time_budget = ticks;
3000e7f8: e5850078 str r0, [r5, #120] ; 0x78 <== NOT EXECUTED 3000e7fc: e5d31000 ldrb r1, [r3] <== NOT EXECUTED 3000e800: e5943088 ldr r3, [r4, #136] ; 0x88 <== NOT EXECUTED 3000e804: e0631001 rsb r1, r3, r1 <== NOT EXECUTED
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
3000e808: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
the_thread->cpu_time_budget = ticks;
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
3000e80c: e5851018 str r1, [r5, #24] <== NOT EXECUTED
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
3000e810: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e814: 1a000004 bne 3000e82c <_POSIX_Threads_Sporadic_budget_TSR+0x4c><== NOT EXECUTED
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
3000e818: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 3000e81c: e1530001 cmp r3, r1 <== NOT EXECUTED
_Thread_Change_priority( the_thread, new_priority, true );
3000e820: 81a00005 movhi r0, r5 <== NOT EXECUTED 3000e824: 83a02001 movhi r2, #1 <== NOT EXECUTED 3000e828: 8bfff304 blhi 3000b440 <_Thread_Change_priority> <== NOT EXECUTED
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
3000e82c: e2840090 add r0, r4, #144 ; 0x90 <== NOT EXECUTED 3000e830: eb0003be bl 3000f730 <_Timespec_To_ticks> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000e834: e58400b4 str r0, [r4, #180] ; 0xb4 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000e838: e59f000c ldr r0, [pc, #12] ; 3000e84c <_POSIX_Threads_Sporadic_budget_TSR+0x6c><== NOT EXECUTED 3000e83c: e28410a8 add r1, r4, #168 ; 0xa8 <== NOT EXECUTED
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
3000e840: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
3000e844: eafff76e b 3000c604 <_Watchdog_Insert> <== NOT EXECUTED
3000e850 <_POSIX_Threads_Sporadic_budget_callout>:
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
3000e850: e3e01000 mvn r1, #0 <== NOT EXECUTED
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000e854: e59020fc ldr r2, [r0, #252] ; 0xfc <== NOT EXECUTED
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
3000e858: e5801078 str r1, [r0, #120] ; 0x78 <== NOT EXECUTED 3000e85c: e59f102c ldr r1, [pc, #44] ; 3000e890 <_POSIX_Threads_Sporadic_budget_callout+0x40><== NOT EXECUTED 3000e860: e592208c ldr r2, [r2, #140] ; 0x8c <== NOT EXECUTED 3000e864: e5d11000 ldrb r1, [r1] <== NOT EXECUTED 3000e868: e0621001 rsb r1, r2, r1 <== NOT EXECUTED
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
3000e86c: e590201c ldr r2, [r0, #28] <== NOT EXECUTED
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
3000e870: e5801018 str r1, [r0, #24] <== NOT EXECUTED
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
3000e874: e3520000 cmp r2, #0 <== NOT EXECUTED 3000e878: 112fff1e bxne lr <== NOT EXECUTED
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
3000e87c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000e880: e1530001 cmp r3, r1 <== NOT EXECUTED 3000e884: 212fff1e bxcs lr <== NOT EXECUTED
_Thread_Change_priority( the_thread, new_priority, true );
3000e888: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000e88c: eafff2eb b 3000b440 <_Thread_Change_priority> <== NOT EXECUTED
3001086c <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
3001086c: e92d4070 push {r4, r5, r6, lr}
POSIX_Cancel_Handler_control *handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
30010870: e59050fc ldr r5, [r0, #252] ; 0xfc
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
30010874: e3a03001 mov r3, #1 30010878: e58530d8 str r3, [r5, #216] ; 0xd8
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3001087c: e28560e8 add r6, r5, #232 ; 0xe8
while ( !_Chain_Is_empty( handler_stack ) ) {
30010880: ea00000c b 300108b8 <_POSIX_Threads_cancel_run+0x4c>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30010884: e10f1000 mrs r1, CPSR <== NOT EXECUTED 30010888: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 3001088c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Disable( level );
handler = (POSIX_Cancel_Handler_control *)
30010890: e59540ec ldr r4, [r5, #236] ; 0xec <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
30010894: e894000c ldm r4, {r2, r3} <== NOT EXECUTED
previous = the_node->previous; next->previous = previous;
30010898: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3001089c: e5832000 str r2, [r3] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300108a0: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
(*handler->routine)( handler->arg );
300108a4: e594000c ldr r0, [r4, #12] <== NOT EXECUTED 300108a8: e1a0e00f mov lr, pc <== NOT EXECUTED 300108ac: e594f008 ldr pc, [r4, #8] <== NOT EXECUTED
_Workspace_Free( handler );
300108b0: e1a00004 mov r0, r4 <== NOT EXECUTED 300108b4: ebfff013 bl 3000c908 <_Workspace_Free> <== NOT EXECUTED
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
300108b8: e59530e4 ldr r3, [r5, #228] ; 0xe4 300108bc: e1530006 cmp r3, r6
300108c0: 1affffef bne 30010884 <_POSIX_Threads_cancel_run+0x18>
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
300108c4: e8bd8070 pop {r4, r5, r6, pc}
3000f544 <_POSIX_Timer_Insert_helper>:
Watchdog_Interval ticks,
Objects_Id id,
Watchdog_Service_routine_entry TSR,
void *arg
)
{
3000f544: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000f548: e1a04000 mov r4, r0 <== NOT EXECUTED
3000f54c: e1a05001 mov r5, r1 <== NOT EXECUTED
3000f550: e1a07002 mov r7, r2 <== NOT EXECUTED
3000f554: e1a08003 mov r8, r3 <== NOT EXECUTED
ISR_Level level;
(void) _Watchdog_Remove( timer );
3000f558: ebfff719 bl 3000d1c4 <_Watchdog_Remove> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000f55c: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000f560: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000f564: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( timer->state != WATCHDOG_INACTIVE ) {
3000f568: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000f56c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f570: 0a000002 beq 3000f580 <_POSIX_Timer_Insert_helper+0x3c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f574: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
return false;
3000f578: e3a00000 mov r0, #0 <== NOT EXECUTED
3000f57c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000f580: e5843008 str r3, [r4, #8] <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3000f584: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000f588: e584801c str r8, [r4, #28] <== NOT EXECUTED
the_watchdog->id = id;
3000f58c: e5847020 str r7, [r4, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000f590: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000f594: e584500c str r5, [r4, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000f598: e59f0010 ldr r0, [pc, #16] ; 3000f5b0 <_POSIX_Timer_Insert_helper+0x6c><== NOT EXECUTED 3000f59c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000f5a0: ebfff6af bl 3000d064 <_Watchdog_Insert> <== NOT EXECUTED 3000f5a4: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
* so we can atomically initialize it as in use.
*/
_Watchdog_Initialize( timer, TSR, id, arg );
_Watchdog_Insert_ticks( timer, ticks );
_ISR_Enable( level );
return true;
3000f5a8: e3a00001 mov r0, #1 <== NOT EXECUTED
}
3000f5ac: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300096b8 <_POSIX_Timer_TSR>:
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
300096b8: e5913068 ldr r3, [r1, #104] ; 0x68 <== NOT EXECUTED
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
300096bc: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
300096c0: e2833001 add r3, r3, #1 <== NOT EXECUTED 300096c4: e5813068 str r3, [r1, #104] ; 0x68 <== NOT EXECUTED
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
300096c8: e5913054 ldr r3, [r1, #84] ; 0x54 <== NOT EXECUTED
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
300096cc: e1a04001 mov r4, r1 <== NOT EXECUTED
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
300096d0: e3530000 cmp r3, #0 <== NOT EXECUTED 300096d4: 1a000003 bne 300096e8 <_POSIX_Timer_TSR+0x30> <== NOT EXECUTED 300096d8: e5913058 ldr r3, [r1, #88] ; 0x58 <== NOT EXECUTED 300096dc: e3530000 cmp r3, #0 <== NOT EXECUTED
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
300096e0: 03a03004 moveq r3, #4 <== NOT EXECUTED
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
300096e4: 0a00000a beq 30009714 <_POSIX_Timer_TSR+0x5c> <== NOT EXECUTED
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
300096e8: e2840010 add r0, r4, #16 <== NOT EXECUTED 300096ec: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED 300096f0: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 300096f4: e59f3034 ldr r3, [pc, #52] ; 30009730 <_POSIX_Timer_TSR+0x78><== NOT EXECUTED 300096f8: e58d4000 str r4, [sp] <== NOT EXECUTED 300096fc: eb001790 bl 3000f544 <_POSIX_Timer_Insert_helper> <== NOT EXECUTED
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
30009700: e3500000 cmp r0, #0 <== NOT EXECUTED 30009704: 0a000008 beq 3000972c <_POSIX_Timer_TSR+0x74> <== NOT EXECUTED
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
30009708: e284006c add r0, r4, #108 ; 0x6c <== NOT EXECUTED 3000970c: eb000541 bl 3000ac18 <_TOD_Get> <== NOT EXECUTED
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
30009710: e3a03003 mov r3, #3 <== NOT EXECUTED
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
30009714: e5c4303c strb r3, [r4, #60] ; 0x3c <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
30009718: e5940038 ldr r0, [r4, #56] ; 0x38 <== NOT EXECUTED 3000971c: e5941044 ldr r1, [r4, #68] ; 0x44 <== NOT EXECUTED 30009720: eb00167a bl 3000f110 <pthread_kill> <== NOT EXECUTED
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
30009724: e3a03000 mov r3, #0 <== NOT EXECUTED 30009728: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED
}
3000972c: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000e318 <_POSIX_signals_Abnormal_termination_handler>:
sigset_t _POSIX_signals_Pending;
void _POSIX_signals_Abnormal_termination_handler(
int signo __attribute__((unused)) )
{
3000e318: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
exit( 1 );
3000e31c: e3a00001 mov r0, #1 <== NOT EXECUTED 3000e320: eb000b6b bl 300110d4 <exit> <== NOT EXECUTED
3000b250 <_POSIX_signals_Alarm_TSR>:
void _POSIX_signals_Alarm_TSR(
Objects_Id id __attribute__((unused)),
void *argument __attribute__((unused))
)
{
3000b250: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
int status;
status = kill( getpid(), SIGALRM );
3000b254: ebfff536 bl 30008734 <getpid> <== NOT EXECUTED 3000b258: e3a0100e mov r1, #14 <== NOT EXECUTED
/* XXX can't print from an ISR, should this be fatal? */ }
3000b25c: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
void *argument __attribute__((unused))
)
{
int status;
status = kill( getpid(), SIGALRM );
3000b260: ea000049 b 3000b38c <kill> <== NOT EXECUTED
3001095c <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
3001095c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
30010960: e24dd038 sub sp, sp, #56 ; 0x38 <== NOT EXECUTED
30010964: e20230ff and r3, r2, #255 ; 0xff <== NOT EXECUTED
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
30010968: e28da02c add sl, sp, #44 ; 0x2c <== NOT EXECUTED 3001096c: e3a02001 mov r2, #1 <== NOT EXECUTED 30010970: e58d2000 str r2, [sp] <== NOT EXECUTED 30010974: e1a0200a mov r2, sl <== NOT EXECUTED
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
30010978: e1a04000 mov r4, r0 <== NOT EXECUTED 3001097c: e1a05001 mov r5, r1 <== NOT EXECUTED
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
30010980: eb000033 bl 30010a54 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 30010984: e3500000 cmp r0, #0 <== NOT EXECUTED 30010988: 0a00002d beq 30010a44 <_POSIX_signals_Check_signal+0xe8> <== NOT EXECUTED
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
3001098c: e3a0800c mov r8, #12 <== NOT EXECUTED 30010990: e0080895 mul r8, r5, r8 <== NOT EXECUTED 30010994: e59f60b0 ldr r6, [pc, #176] ; 30010a4c <_POSIX_signals_Check_signal+0xf0><== NOT EXECUTED 30010998: e0863008 add r3, r6, r8 <== NOT EXECUTED 3001099c: e593c008 ldr ip, [r3, #8] <== NOT EXECUTED 300109a0: e35c0001 cmp ip, #1 <== NOT EXECUTED
return false;
300109a4: 03a00000 moveq r0, #0 <== NOT EXECUTED
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
300109a8: 0a000025 beq 30010a44 <_POSIX_signals_Check_signal+0xe8> <== NOT EXECUTED
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
300109ac: e59490d0 ldr r9, [r4, #208] ; 0xd0 <== NOT EXECUTED
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
300109b0: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
/* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
300109b4: e28de004 add lr, sp, #4 <== NOT EXECUTED
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
300109b8: e1833009 orr r3, r3, r9 <== NOT EXECUTED 300109bc: e58430d0 str r3, [r4, #208] ; 0xd0 <== NOT EXECUTED
/* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
300109c0: e59f3088 ldr r3, [pc, #136] ; 30010a50 <_POSIX_signals_Check_signal+0xf4><== NOT EXECUTED
300109c4: e5937004 ldr r7, [r3, #4] <== NOT EXECUTED
300109c8: e2877020 add r7, r7, #32 <== NOT EXECUTED
300109cc: e8b7000f ldm r7!, {r0, r1, r2, r3} <== NOT EXECUTED
300109d0: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
300109d4: e8b7000f ldm r7!, {r0, r1, r2, r3} <== NOT EXECUTED
300109d8: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
300109dc: e8970003 ldm r7, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
300109e0: e7963008 ldr r3, [r6, r8] <== NOT EXECUTED
/* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
300109e4: e88e0003 stm lr, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
300109e8: e3530002 cmp r3, #2 <== NOT EXECUTED 300109ec: 1a000005 bne 30010a08 <_POSIX_signals_Check_signal+0xac> <== NOT EXECUTED
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
300109f0: e1a00005 mov r0, r5 <== NOT EXECUTED 300109f4: e1a0100a mov r1, sl <== NOT EXECUTED 300109f8: e3a02000 mov r2, #0 <== NOT EXECUTED 300109fc: e1a0e00f mov lr, pc <== NOT EXECUTED 30010a00: e12fff1c bx ip <== NOT EXECUTED
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
30010a04: ea000002 b 30010a14 <_POSIX_signals_Check_signal+0xb8> <== NOT EXECUTED
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
30010a08: e1a00005 mov r0, r5 <== NOT EXECUTED 30010a0c: e1a0e00f mov lr, pc <== NOT EXECUTED 30010a10: e12fff1c bx ip <== NOT EXECUTED
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
30010a14: e59f3034 ldr r3, [pc, #52] ; 30010a50 <_POSIX_signals_Check_signal+0xf4><== NOT EXECUTED
30010a18: e28d5004 add r5, sp, #4 <== NOT EXECUTED
30010a1c: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED
30010a20: e8b5000f ldm r5!, {r0, r1, r2, r3} <== NOT EXECUTED
30010a24: e28cc020 add ip, ip, #32 <== NOT EXECUTED
30010a28: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30010a2c: e8b5000f ldm r5!, {r0, r1, r2, r3} <== NOT EXECUTED
30010a30: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30010a34: e8950003 ldm r5, {r0, r1} <== NOT EXECUTED
30010a38: e88c0003 stm ip, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
30010a3c: e58490d0 str r9, [r4, #208] ; 0xd0 <== NOT EXECUTED
return true;
30010a40: e3a00001 mov r0, #1 <== NOT EXECUTED
}
30010a44: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
30010a48: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
30011048 <_POSIX_signals_Clear_process_signals>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30011048: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001104c: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 30011050: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
30011054: e3a0300c mov r3, #12 <== NOT EXECUTED 30011058: e0030390 mul r3, r0, r3 <== NOT EXECUTED 3001105c: e59f2040 ldr r2, [pc, #64] ; 300110a4 <_POSIX_signals_Clear_process_signals+0x5c><== NOT EXECUTED 30011060: e7922003 ldr r2, [r2, r3] <== NOT EXECUTED 30011064: e3520002 cmp r2, #2 <== NOT EXECUTED 30011068: 1a000005 bne 30011084 <_POSIX_signals_Clear_process_signals+0x3c><== NOT EXECUTED
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
}
3001106c: e59f2034 ldr r2, [pc, #52] ; 300110a8 <_POSIX_signals_Clear_process_signals+0x60><== 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 );
30011070: e283c004 add ip, r3, #4 <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
30011074: e7923003 ldr r3, [r2, r3] <== NOT EXECUTED 30011078: e08cc002 add ip, ip, r2 <== NOT EXECUTED 3001107c: e153000c cmp r3, ip <== NOT EXECUTED 30011080: 1a000005 bne 3001109c <_POSIX_signals_Clear_process_signals+0x54><== NOT EXECUTED
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
30011084: e59f3020 ldr r3, [pc, #32] ; 300110ac <_POSIX_signals_Clear_process_signals+0x64><== NOT EXECUTED 30011088: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3001108c: e5932000 ldr r2, [r3] <== NOT EXECUTED 30011090: e3a0c001 mov ip, #1 <== NOT EXECUTED 30011094: e1c2001c bic r0, r2, ip, lsl r0 <== NOT EXECUTED 30011098: e5830000 str r0, [r3] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001109c: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
}
_ISR_Enable( level );
}
300110a0: e12fff1e bx lr <== NOT EXECUTED
30010a54 <_POSIX_signals_Clear_signals>:
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
30010a54: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
30010a58: e5ddc014 ldrb ip, [sp, #20] <== NOT EXECUTED
30010a5c: e1a04001 mov r4, r1 <== NOT EXECUTED
/* set blocked signals based on if checking for them, SIGNAL_ALL_MASK
* insures that no signals are blocked and all are checked.
*/
if ( check_blocked )
30010a60: e35c0000 cmp ip, #0 <== NOT EXECUTED
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
30010a64: e1a05002 mov r5, r2 <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
30010a68: e2412001 sub r2, r1, #1 <== NOT EXECUTED 30010a6c: e3a01001 mov r1, #1 <== NOT EXECUTED 30010a70: e1a01211 lsl r1, r1, r2 <== NOT EXECUTED
/* set blocked signals based on if checking for them, SIGNAL_ALL_MASK
* insures that no signals are blocked and all are checked.
*/
if ( check_blocked )
signals_blocked = ~api->signals_blocked;
30010a74: 159020d0 ldrne r2, [r0, #208] ; 0xd0 <== NOT EXECUTED
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
30010a78: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED
/* set blocked signals based on if checking for them, SIGNAL_ALL_MASK
* insures that no signals are blocked and all are checked.
*/
if ( check_blocked )
signals_blocked = ~api->signals_blocked;
30010a7c: 11e02002 mvnne r2, r2 <== NOT EXECUTED
else
signals_blocked = SIGNAL_ALL_MASK;
30010a80: 03e02000 mvneq r2, #0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30010a84: e10f7000 mrs r7, CPSR <== NOT EXECUTED 30010a88: e387c080 orr ip, r7, #128 ; 0x80 <== NOT EXECUTED 30010a8c: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
/* XXX is this right for siginfo type signals? */
/* XXX are we sure they can be cleared the same way? */
_ISR_Disable( level );
if ( is_global ) {
30010a90: e3530000 cmp r3, #0 <== NOT EXECUTED 30010a94: 0a000025 beq 30010b30 <_POSIX_signals_Clear_signals+0xdc> <== NOT EXECUTED
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
30010a98: e59f30b8 ldr r3, [pc, #184] ; 30010b58 <_POSIX_signals_Clear_signals+0x104><== NOT EXECUTED 30010a9c: e5930000 ldr r0, [r3] <== NOT EXECUTED 30010aa0: e0011000 and r1, r1, r0 <== NOT EXECUTED 30010aa4: e0110002 ands r0, r1, r2 <== NOT EXECUTED 30010aa8: 0a000028 beq 30010b50 <_POSIX_signals_Clear_signals+0xfc> <== NOT EXECUTED
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
30010aac: e3a0300c mov r3, #12 <== NOT EXECUTED 30010ab0: e0030394 mul r3, r4, r3 <== NOT EXECUTED 30010ab4: e59f20a0 ldr r2, [pc, #160] ; 30010b5c <_POSIX_signals_Clear_signals+0x108><== NOT EXECUTED 30010ab8: e7922003 ldr r2, [r2, r3] <== NOT EXECUTED 30010abc: e3520002 cmp r2, #2 <== NOT EXECUTED 30010ac0: 1a000017 bne 30010b24 <_POSIX_signals_Clear_signals+0xd0> <== NOT EXECUTED
do_callout = true;
}
}
_ISR_Enable( level );
return do_callout;
}
30010ac4: e59f2094 ldr r2, [pc, #148] ; 30010b60 <_POSIX_signals_Clear_signals+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 );
30010ac8: e2831004 add r1, r3, #4 <== NOT EXECUTED 30010acc: e7926003 ldr r6, [r2, r3] <== NOT EXECUTED 30010ad0: e0811002 add r1, r1, r2 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
30010ad4: e1560001 cmp r6, r1 <== 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;
30010ad8: 15961000 ldrne r1, [r6] <== NOT EXECUTED 30010adc: e0820003 add r0, r2, r3 <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
30010ae0: 15810004 strne r0, [r1, #4] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
30010ae4: 17821003 strne r1, [r2, r3] <== NOT EXECUTED
)
{
if ( !_Chain_Is_empty(the_chain))
return _Chain_Get_first_unprotected(the_chain);
else
return NULL;
30010ae8: 03a06000 moveq r6, #0 <== NOT EXECUTED
if ( is_global ) {
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
_POSIX_signals_Clear_process_signals( signo );
30010aec: e1a00004 mov r0, r4 <== NOT EXECUTED 30010af0: eb000154 bl 30011048 <_POSIX_signals_Clear_process_signals><== NOT EXECUTED
/*
* It may be impossible to get here with an empty chain
* BUT until that is proven we need to be defensive and
* protect against it.
*/
if ( psiginfo ) {
30010af4: e3560000 cmp r6, #0 <== NOT EXECUTED 30010af8: 0a000009 beq 30010b24 <_POSIX_signals_Clear_signals+0xd0> <== NOT EXECUTED
*info = psiginfo->Info;
30010afc: e2863008 add r3, r6, #8 <== NOT EXECUTED
30010b00: e8930007 ldm r3, {r0, r1, r2} <== NOT EXECUTED
30010b04: e8850007 stm r5, {r0, r1, r2} <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
30010b08: e59f3054 ldr r3, [pc, #84] ; 30010b64 <_POSIX_signals_Clear_signals+0x110><== NOT EXECUTED 30010b0c: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
the_node->next = tail;
30010b10: e2831004 add r1, r3, #4 <== NOT EXECUTED 30010b14: e5861000 str r1, [r6] <== NOT EXECUTED
tail->previous = the_node;
30010b18: e5836008 str r6, [r3, #8] <== NOT EXECUTED
old_last->next = the_node;
30010b1c: e5826000 str r6, [r2] <== NOT EXECUTED
the_node->previous = old_last;
30010b20: e5862004 str r2, [r6, #4] <== NOT EXECUTED
&psiginfo->Node
);
} else
do_callout = false;
}
_POSIX_signals_Clear_process_signals( signo );
30010b24: e1a00004 mov r0, r4 <== NOT EXECUTED 30010b28: eb000146 bl 30011048 <_POSIX_signals_Clear_process_signals><== NOT EXECUTED 30010b2c: ea000006 b 30010b4c <_POSIX_signals_Clear_signals+0xf8> <== NOT EXECUTED
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
30010b30: e590c0d4 ldr ip, [r0, #212] ; 0xd4 <== NOT EXECUTED 30010b34: e001400c and r4, r1, ip <== NOT EXECUTED 30010b38: e1140002 tst r4, r2 <== NOT EXECUTED
bool do_callout;
POSIX_signals_Siginfo_node *psiginfo;
mask = signo_to_mask( signo );
do_callout = false;
30010b3c: 01a00003 moveq r0, r3 <== NOT EXECUTED
}
_POSIX_signals_Clear_process_signals( signo );
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
30010b40: 0a000002 beq 30010b50 <_POSIX_signals_Clear_signals+0xfc> <== NOT EXECUTED
api->signals_pending &= ~mask;
30010b44: e1cc1001 bic r1, ip, r1 <== NOT EXECUTED 30010b48: e58010d4 str r1, [r0, #212] ; 0xd4 <== NOT EXECUTED
do_callout = true;
30010b4c: e3a00001 mov r0, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30010b50: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
}
}
_ISR_Enable( level );
return do_callout;
}
30010b54: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000a1a0 <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000a1a0: e3a0301b mov r3, #27 <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3000a1a4: e3a02001 mov r2, #1 <== NOT EXECUTED
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
3000a1a8: e2431001 sub r1, r3, #1 <== NOT EXECUTED
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
3000a1ac: e0101112 ands r1, r0, r2, lsl r1 <== NOT EXECUTED 3000a1b0: 1a00000a bne 3000a1e0 <_POSIX_signals_Get_lowest+0x40> <== NOT EXECUTED
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000a1b4: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000a1b8: e3530020 cmp r3, #32 <== NOT EXECUTED 3000a1bc: 1afffff9 bne 3000a1a8 <_POSIX_signals_Get_lowest+0x8> <== NOT EXECUTED 3000a1c0: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a1c4: e1a02003 mov r2, r3 <== NOT EXECUTED
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
3000a1c8: e2431001 sub r1, r3, #1 <== NOT EXECUTED
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
3000a1cc: e0101112 ands r1, r0, r2, lsl r1 <== NOT EXECUTED 3000a1d0: 1a000002 bne 3000a1e0 <_POSIX_signals_Get_lowest+0x40> <== NOT EXECUTED
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
3000a1d4: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000a1d8: e353001b cmp r3, #27 <== NOT EXECUTED 3000a1dc: 1afffff9 bne 3000a1c8 <_POSIX_signals_Get_lowest+0x28> <== NOT EXECUTED
* a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; }
3000a1e0: e1a00003 mov r0, r3 <== NOT EXECUTED 3000a1e4: e12fff1e bx lr <== NOT EXECUTED
3000e324 <_POSIX_signals_Post_switch_extension>:
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
3000e324: e92d4070 push {r4, r5, r6, lr}
POSIX_API_Control *api;
int signo;
ISR_Level level;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000e328: e59040fc ldr r4, [r0, #252] ; 0xfc
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
3000e32c: e3540000 cmp r4, #0
3000e330: 08bd8070 popeq {r4, r5, r6, pc}
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending)) ) {
3000e334: e59f6090 ldr r6, [pc, #144] ; 3000e3cc <_POSIX_signals_Post_switch_extension+0xa8>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000e338: e10f3000 mrs r3, CPSR 3000e33c: e3832080 orr r2, r3, #128 ; 0x80 3000e340: e129f002 msr CPSR_fc, r2 3000e344: e5961000 ldr r1, [r6] 3000e348: e59420d4 ldr r2, [r4, #212] ; 0xd4 3000e34c: e1812002 orr r2, r1, r2
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
_ISR_Disable( level );
if ( !(~api->signals_blocked &
3000e350: e59410d0 ldr r1, [r4, #208] ; 0xd0 3000e354: e1d21001 bics r1, r2, r1
3000e358: 1a000001 bne 3000e364 <_POSIX_signals_Post_switch_extension+0x40>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000e35c: e129f003 msr CPSR_fc, r3
3000e360: e8bd8070 pop {r4, r5, r6, pc}
3000e364: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000e368: e3a0501b mov r5, #27 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
3000e36c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000e370: e3a02000 mov r2, #0 <== NOT EXECUTED 3000e374: e1a00004 mov r0, r4 <== NOT EXECUTED 3000e378: eb000977 bl 3001095c <_POSIX_signals_Check_signal> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, true );
3000e37c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000e380: e1a00004 mov r0, r4 <== NOT EXECUTED 3000e384: e3a02001 mov r2, #1 <== NOT EXECUTED
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000e388: e2855001 add r5, r5, #1 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
3000e38c: eb000972 bl 3001095c <_POSIX_signals_Check_signal> <== NOT EXECUTED
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000e390: e3550020 cmp r5, #32 <== NOT EXECUTED 3000e394: 1afffff4 bne 3000e36c <_POSIX_signals_Post_switch_extension+0x48><== NOT EXECUTED 3000e398: e3a05001 mov r5, #1 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
_POSIX_signals_Check_signal( api, signo, false );
3000e39c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000e3a0: e3a02000 mov r2, #0 <== NOT EXECUTED 3000e3a4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000e3a8: eb00096b bl 3001095c <_POSIX_signals_Check_signal> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, true );
3000e3ac: e1a01005 mov r1, r5 <== NOT EXECUTED 3000e3b0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000e3b4: e3a02001 mov r2, #1 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
3000e3b8: e2855001 add r5, r5, #1 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
3000e3bc: eb000966 bl 3001095c <_POSIX_signals_Check_signal> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
}
/* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
3000e3c0: e355001b cmp r5, #27 <== NOT EXECUTED 3000e3c4: 1afffff4 bne 3000e39c <_POSIX_signals_Post_switch_extension+0x78><== NOT EXECUTED 3000e3c8: eaffffda b 3000e338 <_POSIX_signals_Post_switch_extension+0x14><== NOT EXECUTED
30009318 <_POSIX_signals_Ualarm_TSR>:
void _POSIX_signals_Ualarm_TSR(
Objects_Id id __attribute__((unused)),
void *argument __attribute__((unused))
)
{
30009318: e92d4010 push {r4, lr} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Reset(
Watchdog_Control *the_watchdog
)
{
(void) _Watchdog_Remove( the_watchdog );
3000931c: e59f4020 ldr r4, [pc, #32] ; 30009344 <_POSIX_signals_Ualarm_TSR+0x2c><== NOT EXECUTED
/* * Send a SIGALRM but if there is a problem, ignore it. * It's OK, there isn't a way this should fail. */ (void) kill( getpid(), SIGALRM );
30009320: ebfff493 bl 30006574 <getpid> <== NOT EXECUTED 30009324: e3a0100e mov r1, #14 <== NOT EXECUTED 30009328: ebffff7d bl 30009124 <kill> <== NOT EXECUTED 3000932c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009330: eb000e97 bl 3000cd94 <_Watchdog_Remove> <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30009334: e59f000c ldr r0, [pc, #12] ; 30009348 <_POSIX_signals_Ualarm_TSR+0x30><== NOT EXECUTED 30009338: e1a01004 mov r1, r4 <== NOT EXECUTED
/*
* If the reset interval is non-zero, reschedule ourselves.
*/
_Watchdog_Reset( &_POSIX_signals_Ualarm_timer );
}
3000933c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
30009340: ea000e3b b 3000cc34 <_Watchdog_Insert> <== NOT EXECUTED
30025a80 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
30025a80: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
30025a84: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 30025a88: e59f50f8 ldr r5, [pc, #248] ; 30025b88 <_POSIX_signals_Unblock_thread+0x108><== NOT EXECUTED 30025a8c: e59f80f4 ldr r8, [pc, #244] ; 30025b88 <_POSIX_signals_Unblock_thread+0x108><== NOT EXECUTED 30025a90: e0035005 and r5, r3, r5 <== NOT EXECUTED 30025a94: e241c001 sub ip, r1, #1 <== NOT EXECUTED 30025a98: e3a06001 mov r6, #1 <== NOT EXECUTED 30025a9c: e1550008 cmp r5, r8 <== NOT EXECUTED
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
30025aa0: e1a04000 mov r4, r0 <== NOT EXECUTED
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
30025aa4: e59070fc ldr r7, [r0, #252] ; 0xfc <== NOT EXECUTED 30025aa8: e1a0cc16 lsl ip, r6, ip <== NOT EXECUTED
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
30025aac: 1a000013 bne 30025b00 <_POSIX_signals_Unblock_thread+0x80> <== NOT EXECUTED
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
30025ab0: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 30025ab4: e11c0003 tst ip, r3 <== NOT EXECUTED 30025ab8: 1a000002 bne 30025ac8 <_POSIX_signals_Unblock_thread+0x48> <== NOT EXECUTED 30025abc: e59750d0 ldr r5, [r7, #208] ; 0xd0 <== NOT EXECUTED 30025ac0: e1dc5005 bics r5, ip, r5 <== NOT EXECUTED 30025ac4: 0a00002d beq 30025b80 <_POSIX_signals_Unblock_thread+0x100><== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
30025ac8: e3a03004 mov r3, #4 <== NOT EXECUTED 30025acc: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
the_info = (siginfo_t *) the_thread->Wait.return_argument;
30025ad0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
if ( !info ) {
30025ad4: e3520000 cmp r2, #0 <== NOT EXECUTED
the_info->si_signo = signo;
30025ad8: 05831000 streq r1, [r3] <== NOT EXECUTED
the_info->si_code = SI_USER;
30025adc: 03a01001 moveq r1, #1 <== NOT EXECUTED
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
30025ae0: 18920007 ldmne r2, {r0, r1, r2} <== NOT EXECUTED
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
30025ae4: 05831004 streq r1, [r3, #4] <== NOT EXECUTED
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
30025ae8: 18830007 stmne r3, {r0, r1, r2} <== NOT EXECUTED
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
30025aec: 05832008 streq r2, [r3, #8] <== NOT EXECUTED
} else {
*the_info = *info;
}
_Thread_queue_Extract_with_proxy( the_thread );
30025af0: e1a00004 mov r0, r4 <== NOT EXECUTED 30025af4: ebffad13 bl 30010f48 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED
return true;
30025af8: e3a05001 mov r5, #1 <== NOT EXECUTED 30025afc: ea00001f b 30025b80 <_POSIX_signals_Unblock_thread+0x100> <== NOT EXECUTED
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
30025b00: e59750d0 ldr r5, [r7, #208] ; 0xd0 <== NOT EXECUTED 30025b04: e1dc5005 bics r5, ip, r5 <== NOT EXECUTED 30025b08: 0a00001c beq 30025b80 <_POSIX_signals_Unblock_thread+0x100><== NOT EXECUTED
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
30025b0c: e2135201 ands r5, r3, #268435456 ; 0x10000000 <== NOT EXECUTED 30025b10: 0a000010 beq 30025b58 <_POSIX_signals_Unblock_thread+0xd8> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
30025b14: e59f5070 ldr r5, [pc, #112] ; 30025b8c <_POSIX_signals_Unblock_thread+0x10c><== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
30025b18: e3a02004 mov r2, #4 <== NOT EXECUTED 30025b1c: e0035005 and r5, r3, r5 <== NOT EXECUTED
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
30025b20: e3550000 cmp r5, #0 <== NOT EXECUTED
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
the_thread->Wait.return_code = EINTR;
30025b24: e5802034 str r2, [r0, #52] ; 0x34 <== NOT EXECUTED
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
30025b28: 0a000002 beq 30025b38 <_POSIX_signals_Unblock_thread+0xb8> <== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
30025b2c: ebffad05 bl 30010f48 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
30025b30: e3a05000 mov r5, #0 <== NOT EXECUTED 30025b34: ea000011 b 30025b80 <_POSIX_signals_Unblock_thread+0x100> <== NOT EXECUTED
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
30025b38: e2133008 ands r3, r3, #8 <== NOT EXECUTED 30025b3c: 0a00000e beq 30025b7c <_POSIX_signals_Unblock_thread+0xfc> <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
30025b40: e2800048 add r0, r0, #72 ; 0x48 <== NOT EXECUTED 30025b44: ebffaf11 bl 30011790 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30025b48: e1a00004 mov r0, r4 <== NOT EXECUTED 30025b4c: e59f103c ldr r1, [pc, #60] ; 30025b90 <_POSIX_signals_Unblock_thread+0x110><== NOT EXECUTED 30025b50: ebffaa84 bl 30010568 <_Thread_Clear_state> <== NOT EXECUTED 30025b54: ea000009 b 30025b80 <_POSIX_signals_Unblock_thread+0x100> <== NOT EXECUTED
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
30025b58: e3530000 cmp r3, #0 <== NOT EXECUTED 30025b5c: 1a000007 bne 30025b80 <_POSIX_signals_Unblock_thread+0x100><== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
30025b60: e59f202c ldr r2, [pc, #44] ; 30025b94 <_POSIX_signals_Unblock_thread+0x114><== NOT EXECUTED 30025b64: e5925000 ldr r5, [r2] <== NOT EXECUTED 30025b68: e3550000 cmp r5, #0 <== NOT EXECUTED 30025b6c: 0a000003 beq 30025b80 <_POSIX_signals_Unblock_thread+0x100><== NOT EXECUTED 30025b70: e5921004 ldr r1, [r2, #4] <== NOT EXECUTED 30025b74: e1500001 cmp r0, r1 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
30025b78: 05c26010 strbeq r6, [r2, #16] <== NOT EXECUTED
}
}
return false;
30025b7c: e1a05003 mov r5, r3 <== NOT EXECUTED
}
30025b80: e1a00005 mov r0, r5 <== NOT EXECUTED
30025b84: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000b174 <_Protected_heap_Extend>:
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000b174: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
bool extend_ok;
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000b178: e59f4038 ldr r4, [pc, #56] ; 3000b1b8 <_Protected_heap_Extend+0x44><== NOT EXECUTED
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000b17c: e1a05000 mov r5, r0 <== NOT EXECUTED 3000b180: e1a07001 mov r7, r1 <== NOT EXECUTED 3000b184: e1a06002 mov r6, r2 <== NOT EXECUTED
bool extend_ok;
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000b188: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000b18c: ebfffbcc bl 3000a0c4 <_API_Mutex_Lock> <== NOT EXECUTED
extend_ok = _Heap_Extend(the_heap, starting_address, size, &amount_extended);
3000b190: e1a01007 mov r1, r7 <== NOT EXECUTED 3000b194: e1a02006 mov r2, r6 <== NOT EXECUTED 3000b198: e1a0300d mov r3, sp <== NOT EXECUTED 3000b19c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b1a0: eb001109 bl 3000f5cc <_Heap_Extend> <== NOT EXECUTED 3000b1a4: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
3000b1a8: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000b1ac: ebfffbdd bl 3000a128 <_API_Mutex_Unlock> <== NOT EXECUTED
return extend_ok; }
3000b1b0: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b1b4: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000b564 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
3000b564: e92d4070 push {r4, r5, r6, lr}
if ( !the_heap )
3000b568: e2506000 subs r6, r0, #0
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
3000b56c: e1a05001 mov r5, r1
if ( !the_heap )
return false;
3000b570: 01a00006 moveq r0, r6
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
if ( !the_heap )
3000b574: 08bd8070 popeq {r4, r5, r6, pc}
return false;
if ( !the_info )
3000b578: e3510000 cmp r1, #0
3000b57c: 0a000009 beq 3000b5a8 <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
3000b580: e59f4028 ldr r4, [pc, #40] ; 3000b5b0 <_Protected_heap_Get_information+0x4c> 3000b584: e5940000 ldr r0, [r4] 3000b588: ebfffbba bl 3000a478 <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
3000b58c: e1a00006 mov r0, r6 3000b590: e1a01005 mov r1, r5 3000b594: eb00122a bl 3000fe44 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
3000b598: e5940000 ldr r0, [r4] 3000b59c: ebfffbce bl 3000a4dc <_API_Mutex_Unlock>
return true;
3000b5a0: e3a00001 mov r0, #1
3000b5a4: e8bd8070 pop {r4, r5, r6, pc}
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
3000b5a8: e1a00001 mov r0, r1 <== NOT EXECUTED
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
3000b5ac: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30010048 <_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 ) {
30010048: e59f3054 ldr r3, [pc, #84] ; 300100a4 <_Protected_heap_Walk+0x5c><== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
3001004c: 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 ) {
30010050: e5933000 ldr r3, [r3] <== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
30010054: 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 ) {
30010058: e3530000 cmp r3, #0 <== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
3001005c: e1a05001 mov r5, r1 <== NOT EXECUTED 30010060: 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 ) {
30010064: 1a00000b bne 30010098 <_Protected_heap_Walk+0x50> <== NOT EXECUTED
_RTEMS_Lock_allocator();
30010068: e59f4038 ldr r4, [pc, #56] ; 300100a8 <_Protected_heap_Walk+0x60><== NOT EXECUTED 3001006c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010070: ebfff861 bl 3000e1fc <_API_Mutex_Lock> <== NOT EXECUTED
status = _Heap_Walk( the_heap, source, do_dump );
30010074: e1a01005 mov r1, r5 <== NOT EXECUTED 30010078: e1a02007 mov r2, r7 <== NOT EXECUTED 3001007c: e1a00006 mov r0, r6 <== NOT EXECUTED 30010080: ebfffc32 bl 3000f150 <_Heap_Walk> <== NOT EXECUTED 30010084: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
30010088: e5940000 ldr r0, [r4] <== NOT EXECUTED 3001008c: ebfff873 bl 3000e260 <_API_Mutex_Unlock> <== NOT EXECUTED
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
30010090: e1a00005 mov r0, r5 <== NOT EXECUTED
30010094: 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 );
30010098: e1a02007 mov r2, r7 <== NOT EXECUTED
} return status; }
3001009c: 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 );
300100a0: eafffc2a b 3000f150 <_Heap_Walk> <== NOT EXECUTED
3000edec <_RTEMS_Tasks_Invoke_task_variable_dtor>:
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000edec: e59f203c ldr r2, [pc, #60] ; 3000ee30 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x44><== NOT EXECUTED
)
{
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
3000edf0: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
if (_Thread_Is_executing(the_thread)) {
3000edf4: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED
void _RTEMS_Tasks_Invoke_task_variable_dtor(
Thread_Control *the_thread,
rtems_task_variable_t *tvp
)
{
3000edf8: e92d4010 push {r4, lr} <== NOT EXECUTED
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
3000edfc: e1520000 cmp r2, r0 <== NOT EXECUTED
value = *tvp->ptr;
3000ee00: 05912004 ldreq r2, [r1, #4] <== NOT EXECUTED
void _RTEMS_Tasks_Invoke_task_variable_dtor(
Thread_Control *the_thread,
rtems_task_variable_t *tvp
)
{
3000ee04: e1a04001 mov r4, r1 <== NOT EXECUTED
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
value = *tvp->ptr;
*tvp->ptr = tvp->gval;
3000ee08: 05911008 ldreq r1, [r1, #8] <== NOT EXECUTED
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
value = *tvp->ptr;
3000ee0c: 05920000 ldreq r0, [r2] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
} else {
value = tvp->tval;
3000ee10: 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;
3000ee14: 05821000 streq r1, [r2] <== NOT EXECUTED
} else {
value = tvp->tval;
}
if ( dtor )
3000ee18: e3530000 cmp r3, #0 <== NOT EXECUTED
(*dtor)(value);
3000ee1c: 11a0e00f movne lr, pc <== NOT EXECUTED 3000ee20: 112fff13 bxne r3 <== NOT EXECUTED
_Workspace_Free(tvp);
3000ee24: e1a00004 mov r0, r4 <== NOT EXECUTED
}
3000ee28: e8bd4010 pop {r4, lr} <== NOT EXECUTED
}
if ( dtor )
(*dtor)(value);
_Workspace_Free(tvp);
3000ee2c: eafff6b5 b 3000c908 <_Workspace_Free> <== NOT EXECUTED
3000ecc4 <_RTEMS_tasks_Delete_extension>:
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
3000ecc4: e3a03000 mov r3, #0
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
3000ecc8: e92d4070 push {r4, r5, r6, lr}
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
3000eccc: e5916104 ldr r6, [r1, #260] ; 0x104
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
3000ecd0: e1a04001 mov r4, r1
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
3000ecd4: e5813104 str r3, [r1, #260] ; 0x104
while (tvp) {
3000ecd8: ea000004 b 3000ecf0 <_RTEMS_tasks_Delete_extension+0x2c>
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
3000ecdc: e1a01006 mov r1, r6 <== NOT EXECUTED 3000ece0: e1a00004 mov r0, r4 <== NOT EXECUTED
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
3000ece4: e5965000 ldr r5, [r6] <== NOT EXECUTED
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
3000ece8: eb00003f bl 3000edec <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
tvp = next;
3000ecec: e1a06005 mov r6, r5 <== NOT EXECUTED
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
3000ecf0: e3560000 cmp r6, #0
3000ecf4: 1afffff8 bne 3000ecdc <_RTEMS_tasks_Delete_extension+0x18>
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
3000ecf8: e59400f8 ldr r0, [r4, #248] ; 0xf8 3000ecfc: ebfff701 bl 3000c908 <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
3000ed00: e58460f8 str r6, [r4, #248] ; 0xf8
}
3000ed04: e8bd8070 pop {r4, r5, r6, pc}
3000ebc8 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
3000ebc8: e5903104 ldr r3, [r0, #260] ; 0x104
while (tvp) {
3000ebcc: ea000005 b 3000ebe8 <_RTEMS_tasks_Switch_extension+0x20>
tvp->tval = *tvp->ptr;
3000ebd0: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000ebd4: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000ebd8: e583000c str r0, [r3, #12] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
3000ebdc: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
3000ebe0: e5933000 ldr r3, [r3] <== NOT EXECUTED
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
3000ebe4: e5820000 str r0, [r2] <== NOT EXECUTED
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
3000ebe8: e3530000 cmp r3, #0
3000ebec: 1afffff7 bne 3000ebd0 <_RTEMS_tasks_Switch_extension+0x8>
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
3000ebf0: e5913104 ldr r3, [r1, #260] ; 0x104
while (tvp) {
3000ebf4: ea000005 b 3000ec10 <_RTEMS_tasks_Switch_extension+0x48>
tvp->gval = *tvp->ptr;
3000ebf8: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000ebfc: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000ec00: e5831008 str r1, [r3, #8] <== NOT EXECUTED
*tvp->ptr = tvp->tval;
3000ec04: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
3000ec08: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
3000ec0c: e5821000 str r1, [r2] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
3000ec10: e3530000 cmp r3, #0
3000ec14: 1afffff7 bne 3000ebf8 <_RTEMS_tasks_Switch_extension+0x30>
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
3000ec18: 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: eb00073a bl 3000c690 <_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: eb00098d bl 3000d014 <_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: eb000deb bl 3000e1c8 <_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
3000b478 <_Scheduler_simple_Block>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Block(
Thread_Control *the_thread
)
{
3000b478: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b47c: e1a04000 mov r4, r0 <== NOT EXECUTED
_Scheduler_simple_Extract(the_thread);
3000b480: eb00000c bl 3000b4b8 <_Scheduler_simple_Extract> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
3000b484: e59f3020 ldr r3, [pc, #32] ; 3000b4ac <_Scheduler_simple_Block+0x34><== NOT EXECUTED
if ( _Thread_Is_heir( the_thread ) )
3000b488: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000b48c: e1540003 cmp r4, r3 <== NOT EXECUTED
_Scheduler_simple_Schedule();
3000b490: 0b000043 bleq 3000b5a4 <_Scheduler_simple_Schedule> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000b494: e59f3010 ldr r3, [pc, #16] ; 3000b4ac <_Scheduler_simple_Block+0x34><== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) )
3000b498: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000b49c: e1540002 cmp r4, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000b4a0: 03a02001 moveq r2, #1 <== NOT EXECUTED
3000b4a4: 05c32010 strbeq r2, [r3, #16] <== NOT EXECUTED
3000b4a8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b4b4 <_Scheduler_simple_Enqueue>:
void _Scheduler_simple_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler_simple_Ready_queue_Enqueue( the_thread );
3000b4b4: ea000024 b 3000b54c <_Scheduler_simple_Ready_queue_Enqueue><== NOT EXECUTED
3000b4b0 <_Scheduler_simple_Enqueue_first>:
void _Scheduler_simple_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler_simple_Ready_queue_Enqueue_first( the_thread );
3000b4b0: ea000014 b 3000b508 <_Scheduler_simple_Ready_queue_Enqueue_first><== NOT EXECUTED
3000b4b8 <_Scheduler_simple_Extract>:
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
3000b4b8: e890000c ldm r0, {r2, r3} <== NOT EXECUTED
previous = the_node->previous; next->previous = previous;
3000b4bc: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000b4c0: e5832000 str r2, [r3] <== NOT EXECUTED
void _Scheduler_simple_Extract(
Thread_Control *the_thread
)
{
_Chain_Extract_unprotected( &the_thread->Object.Node );
}
3000b4c4: e12fff1e bx lr <== NOT EXECUTED
3000b4d4 <_Scheduler_simple_Free>:
*/
void _Scheduler_simple_Free(
Thread_Control *the_thread
)
{
}
3000b4d4: e12fff1e bx lr <== NOT EXECUTED
3000b54c <_Scheduler_simple_Ready_queue_Enqueue>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Ready_queue_Enqueue(
Thread_Control *the_thread
)
{
3000b54c: e92d4010 push {r4, lr}
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
3000b550: e59f3048 ldr r3, [pc, #72] ; 3000b5a0 <_Scheduler_simple_Ready_queue_Enqueue+0x54> 3000b554: e5933000 ldr r3, [r3]
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000b558: 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));
3000b55c: 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 ) {
3000b560: ea000006 b 3000b580 <_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 ) {
3000b564: e5904014 ldr r4, [r0, #20] 3000b568: 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;
3000b56c: e1a03002 mov r3, r2
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
3000b570: e154000c cmp r4, ip
current = (Thread_Control *)current->Object.Node.previous;
3000b574: 35923004 ldrcc r3, [r2, #4]
break;
3000b578: 3a000002 bcc 3000b588 <_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 ) {
3000b57c: e5922000 ldr r2, [r2] <== NOT EXECUTED
3000b580: e1520001 cmp r2, r1
3000b584: 1afffff6 bne 3000b564 <_Scheduler_simple_Ready_queue_Enqueue+0x18>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b588: e5932000 ldr r2, [r3]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b58c: e5803004 str r3, [r0, #4]
before_node = after_node->next; after_node->next = the_node;
3000b590: e5830000 str r0, [r3]
the_node->next = before_node; before_node->previous = the_node;
3000b594: 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;
3000b598: e5802000 str r2, [r0]
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000b59c: e8bd8010 pop {r4, pc}
3000b508 <_Scheduler_simple_Ready_queue_Enqueue_first>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
3000b508: e59f3038 ldr r3, [pc, #56] ; 3000b548 <_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 ) {
3000b50c: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000b510: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000b514: 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 ) {
3000b518: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED 3000b51c: e1520001 cmp r2, r1 <== NOT EXECUTED 3000b520: 8a000006 bhi 3000b540 <_Scheduler_simple_Ready_queue_Enqueue_first+0x38><== NOT EXECUTED
current = (Thread_Control *)current->Object.Node.previous;
3000b524: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b528: e5932000 ldr r2, [r3] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b52c: e5803004 str r3, [r0, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b530: e5830000 str r0, [r3] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b534: 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;
3000b538: e5802000 str r2, [r0] <== NOT EXECUTED
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000b53c: 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 ) {
3000b540: 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;
}
}
3000b544: eafffff3 b 3000b518 <_Scheduler_simple_Ready_queue_Enqueue_first+0x10><== NOT EXECUTED
3000b5a4 <_Scheduler_simple_Schedule>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Schedule(void)
{
_Thread_Heir = (Thread_Control *) _Chain_First(
(Chain_Control *) _Scheduler.information
3000b5a4: e59f3010 ldr r3, [pc, #16] ; 3000b5bc <_Scheduler_simple_Schedule+0x18><== NOT EXECUTED
); }
3000b5a8: 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(
3000b5ac: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b5b0: e59f3008 ldr r3, [pc, #8] ; 3000b5c0 <_Scheduler_simple_Schedule+0x1c><== NOT EXECUTED 3000b5b4: e5832008 str r2, [r3, #8] <== NOT EXECUTED
(Chain_Control *) _Scheduler.information
);
}
3000b5b8: e12fff1e bx lr <== NOT EXECUTED
3000b5c4 <_Scheduler_simple_Unblock>:
#include <rtems/score/thread.h>
void _Scheduler_simple_Unblock(
Thread_Control *the_thread
)
{
3000b5c4: e92d4010 push {r4, lr}
3000b5c8: e1a04000 mov r4, r0
_Scheduler_simple_Ready_queue_Enqueue(the_thread);
3000b5cc: ebffffde bl 3000b54c <_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 ) {
3000b5d0: e59f303c ldr r3, [pc, #60] ; 3000b614 <_Scheduler_simple_Unblock+0x50>
3000b5d4: e5942014 ldr r2, [r4, #20]
3000b5d8: e5931008 ldr r1, [r3, #8]
3000b5dc: e5911014 ldr r1, [r1, #20]
3000b5e0: e1520001 cmp r2, r1
3000b5e4: 28bd8010 popcs {r4, pc}
_Thread_Heir = the_thread;
3000b5e8: e5834008 str r4, [r3, #8]
if ( _Thread_Executing->is_preemptible ||
3000b5ec: e5933004 ldr r3, [r3, #4] 3000b5f0: e5d33074 ldrb r3, [r3, #116] ; 0x74 3000b5f4: e3530000 cmp r3, #0
3000b5f8: 1a000001 bne 3000b604 <_Scheduler_simple_Unblock+0x40>
3000b5fc: e3520000 cmp r2, #0 <== NOT EXECUTED
3000b600: 18bd8010 popne {r4, pc} <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000b604: e59f3008 ldr r3, [pc, #8] ; 3000b614 <_Scheduler_simple_Unblock+0x50>
3000b608: e3a02001 mov r2, #1
3000b60c: e5c32010 strb r2, [r3, #16]
3000b610: e8bd8010 pop {r4, pc}
3000b618 <_Scheduler_simple_Yield>:
#include <rtems/score/scheduler.h>
#include <rtems/score/thread.h>
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Yield( void )
{
3000b618: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing;
executing = _Thread_Executing;
3000b61c: e59f5048 ldr r5, [pc, #72] ; 3000b66c <_Scheduler_simple_Yield+0x54><== NOT EXECUTED 3000b620: 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 (
3000b624: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000b628: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000b62c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
3000b630: e894000c ldm r4, {r2, r3} <== NOT EXECUTED
{
/* extract */
_Chain_Extract_unprotected( &the_thread->Object.Node );
/* enqueue */
_Scheduler_simple_Ready_queue_Enqueue( the_thread );
3000b634: e1a00004 mov r0, r4 <== NOT EXECUTED
previous = the_node->previous; next->previous = previous;
3000b638: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000b63c: e5832000 str r2, [r3] <== NOT EXECUTED 3000b640: ebffffc1 bl 3000b54c <_Scheduler_simple_Ready_queue_Enqueue><== NOT EXECUTED
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000b644: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000b648: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000b64c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_Scheduler_simple_Ready_queue_Requeue(&_Scheduler, executing);
_ISR_Flash( level );
_Scheduler_simple_Schedule();
3000b650: ebffffd3 bl 3000b5a4 <_Scheduler_simple_Schedule> <== NOT EXECUTED
if ( !_Thread_Is_heir( executing ) )
3000b654: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000b658: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000b65c: 13a03001 movne r3, #1 <== NOT EXECUTED 3000b660: 15c53010 strbne r3, [r5, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b664: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
}
3000b668: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000a610 <_TOD_Get_uptime_as_timespec>:
*/
void _TOD_Get_uptime_as_timespec(
struct timespec *uptime
)
{
3000a610: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED
3000a614: e1a04000 mov r4, r0 <== NOT EXECUTED
Timestamp_Control uptime_ts;
/* assume time checked for NULL by caller */
_TOD_Get_uptime( &uptime_ts );
3000a618: e1a0000d mov r0, sp <== NOT EXECUTED 3000a61c: eb0013a6 bl 3000f4bc <_TOD_Get_uptime> <== NOT EXECUTED
_Timestamp_To_timespec( &uptime_ts, uptime );
3000a620: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
3000a624: e884000c stm r4, {r2, r3} <== NOT EXECUTED
}
3000a628: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED
3000a294 <_TOD_Tickle_ticks>:
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
3000a294: 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() );
3000a298: e3a03000 mov r3, #0 3000a29c: e58d3000 str r3, [sp] 3000a2a0: e59f3054 ldr r3, [pc, #84] ; 3000a2fc <_TOD_Tickle_ticks+0x68> 3000a2a4: e3a02ffa mov r2, #1000 ; 0x3e8 3000a2a8: 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 );
3000a2ac: 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() );
3000a2b0: e0030392 mul r3, r2, r3 3000a2b4: e58d3004 str r3, [sp, #4]
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000a2b8: e59f3040 ldr r3, [pc, #64] ; 3000a300 <_TOD_Tickle_ticks+0x6c>
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000a2bc: e59f0040 ldr r0, [pc, #64] ; 3000a304 <_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;
3000a2c0: e5932000 ldr r2, [r3] 3000a2c4: e2822001 add r2, r2, #1 3000a2c8: e5832000 str r2, [r3]
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000a2cc: eb0007ff bl 3000c2d0 <_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 );
3000a2d0: e59f0030 ldr r0, [pc, #48] ; 3000a308 <_TOD_Tickle_ticks+0x74> 3000a2d4: e1a0100d mov r1, sp 3000a2d8: eb0007fc bl 3000c2d0 <_Timespec_Add_to> 3000a2dc: e1a04000 mov r4, r0
while ( seconds ) {
3000a2e0: ea000002 b 3000a2f0 <_TOD_Tickle_ticks+0x5c>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
3000a2e4: e59f0020 ldr r0, [pc, #32] ; 3000a30c <_TOD_Tickle_ticks+0x78><== NOT EXECUTED 3000a2e8: eb000946 bl 3000c808 <_Watchdog_Tickle> <== NOT EXECUTED
_Watchdog_Tickle_seconds();
seconds--;
3000a2ec: 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 ) {
3000a2f0: e3540000 cmp r4, #0
3000a2f4: 1afffffa bne 3000a2e4 <_TOD_Tickle_ticks+0x50>
_Watchdog_Tickle_seconds();
seconds--;
}
}
3000a2f8: e8bd801c pop {r2, r3, r4, pc}
3000a4b8 <_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();
3000a4b8: e59f30ac ldr r3, [pc, #172] ; 3000a56c <_TOD_Validate+0xb4>
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
3000a4bc: 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) ||
3000a4c0: 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();
3000a4c4: 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;
3000a4c8: 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) ||
3000a4cc: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
3000a4d0: e59f0098 ldr r0, [pc, #152] ; 3000a570 <_TOD_Validate+0xb8> 3000a4d4: eb0047b6 bl 3001c3b4 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
3000a4d8: e5943018 ldr r3, [r4, #24] 3000a4dc: e1530000 cmp r3, r0
3000a4e0: 2a00001d bcs 3000a55c <_TOD_Validate+0xa4>
(the_tod->ticks >= ticks_per_second) ||
3000a4e4: e5943014 ldr r3, [r4, #20] 3000a4e8: e353003b cmp r3, #59 ; 0x3b
3000a4ec: 8a00001a bhi 3000a55c <_TOD_Validate+0xa4>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
3000a4f0: e5943010 ldr r3, [r4, #16] 3000a4f4: e353003b cmp r3, #59 ; 0x3b
3000a4f8: 8a000017 bhi 3000a55c <_TOD_Validate+0xa4>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
3000a4fc: e594300c ldr r3, [r4, #12] 3000a500: e3530017 cmp r3, #23
3000a504: 8a000014 bhi 3000a55c <_TOD_Validate+0xa4>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
3000a508: 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) ||
3000a50c: 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;
3000a510: 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) ||
3000a514: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
3000a518: e353000c cmp r3, #12
3000a51c: 8a00000e bhi 3000a55c <_TOD_Validate+0xa4>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000a520: 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) ||
3000a524: e59f1048 ldr r1, [pc, #72] ; 3000a574 <_TOD_Validate+0xbc> 3000a528: e1520001 cmp r2, r1
3000a52c: 9a00000c bls 3000a564 <_TOD_Validate+0xac>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
3000a530: 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) ||
3000a534: e3500000 cmp r0, #0
3000a538: 08bd8010 popeq {r4, pc}
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
3000a53c: e3120003 tst r2, #3 3000a540: e59f2030 ldr r2, [pc, #48] ; 3000a578 <_TOD_Validate+0xc0>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
3000a544: 0283300d addeq r3, r3, #13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000a548: 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(
3000a54c: e1500004 cmp r0, r4
3000a550: 83a00000 movhi r0, #0
3000a554: 93a00001 movls r0, #1
3000a558: 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;
3000a55c: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a560: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a564: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
3000a568: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b440 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
3000b440: e92d40f0 push {r4, r5, r6, r7, lr}
3000b444: e1a04000 mov r4, r0
3000b448: e1a05001 mov r5, r1
3000b44c: e20260ff and r6, r2, #255 ; 0xff
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
3000b450: 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 );
3000b454: eb00031d bl 3000c0d0 <_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 )
3000b458: e5943014 ldr r3, [r4, #20] 3000b45c: e1530005 cmp r3, r5
_Thread_Set_priority( the_thread, new_priority );
3000b460: 11a00004 movne r0, r4 3000b464: 11a01005 movne r1, r5 3000b468: 1b000300 blne 3000c070 <_Thread_Set_priority>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b46c: e10f5000 mrs r5, CPSR 3000b470: e3853080 orr r3, r5, #128 ; 0x80 3000b474: 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;
3000b478: e5942010 ldr r2, [r4, #16] 3000b47c: e2077004 and r7, r7, #4
if ( state != STATES_TRANSIENT ) {
3000b480: e3520004 cmp r2, #4
3000b484: 0a00000b beq 3000b4b8 <_Thread_Change_priority+0x78>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
3000b488: 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);
3000b48c: 03c23004 biceq r3, r2, #4 <== NOT EXECUTED
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
3000b490: 05843010 streq r3, [r4, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b494: 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);
3000b498: e59f3090 ldr r3, [pc, #144] ; 3000b530 <_Thread_Change_priority+0xf0><== NOT EXECUTED 3000b49c: e0023003 and r3, r2, r3 <== NOT EXECUTED
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
3000b4a0: e3530000 cmp r3, #0 <== NOT EXECUTED
3000b4a4: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
3000b4a8: e5940044 ldr r0, [r4, #68] ; 0x44 <== NOT EXECUTED 3000b4ac: e1a01004 mov r1, r4 <== NOT EXECUTED
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
3000b4b0: 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 );
3000b4b4: ea0002c8 b 3000bfdc <_Thread_queue_Requeue> <== NOT EXECUTED
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
3000b4b8: e3570000 cmp r7, #0
3000b4bc: 1a00000a bne 3000b4ec <_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 )
3000b4c0: 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 );
3000b4c4: e5847010 str r7, [r4, #16] 3000b4c8: e59f3064 ldr r3, [pc, #100] ; 3000b534 <_Thread_Change_priority+0xf4>
if ( prepend_it )
3000b4cc: 0a000003 beq 3000b4e0 <_Thread_Change_priority+0xa0>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
3000b4d0: e1a00004 mov r0, r4 3000b4d4: e1a0e00f mov lr, pc 3000b4d8: e593f028 ldr pc, [r3, #40] ; 0x28 3000b4dc: ea000002 b 3000b4ec <_Thread_Change_priority+0xac>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
3000b4e0: e1a00004 mov r0, r4 3000b4e4: e1a0e00f mov lr, pc 3000b4e8: e593f024 ldr pc, [r3, #36] ; 0x24
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000b4ec: e10f3000 mrs r3, CPSR 3000b4f0: e129f005 msr CPSR_fc, r5 3000b4f4: 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();
3000b4f8: e59f3034 ldr r3, [pc, #52] ; 3000b534 <_Thread_Change_priority+0xf4> 3000b4fc: e1a0e00f mov lr, pc 3000b500: 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 );
3000b504: e59f302c ldr r3, [pc, #44] ; 3000b538 <_Thread_Change_priority+0xf8> 3000b508: 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() &&
3000b50c: e5931008 ldr r1, [r3, #8] 3000b510: e1520001 cmp r2, r1
3000b514: 0a000003 beq 3000b528 <_Thread_Change_priority+0xe8>
3000b518: e5d22074 ldrb r2, [r2, #116] ; 0x74 3000b51c: e3520000 cmp r2, #0
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
3000b520: 13a02001 movne r2, #1 3000b524: 15c32010 strbne r2, [r3, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b528: e129f005 msr CPSR_fc, r5
3000b52c: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000b704 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000b704: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000b708: e1a0100d mov r1, sp <== NOT EXECUTED 3000b70c: eb000058 bl 3000b874 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000b710: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000b714: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b718: 1a000005 bne 3000b734 <_Thread_Delay_ended+0x30> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
3000b71c: e59f1014 ldr r1, [pc, #20] ; 3000b738 <_Thread_Delay_ended+0x34><== NOT EXECUTED 3000b720: ebffff85 bl 3000b53c <_Thread_Clear_state> <== NOT EXECUTED 3000b724: e59f3010 ldr r3, [pc, #16] ; 3000b73c <_Thread_Delay_ended+0x38><== NOT EXECUTED 3000b728: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b72c: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000b730: e5832000 str r2, [r3] <== NOT EXECUTED
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
3000b734: e8bd8008 pop {r3, pc} <== NOT EXECUTED
3000b874 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
3000b874: 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 ) ) {
3000b878: e2501000 subs r1, r0, #0
3000b87c: 1a000007 bne 3000b8a0 <_Thread_Get+0x2c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b880: e59f3074 ldr r3, [pc, #116] ; 3000b8fc <_Thread_Get+0x88> 3000b884: e5930000 ldr r0, [r3] 3000b888: e2800001 add r0, r0, #1 3000b88c: e5830000 str r0, [r3]
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
tp = _Thread_Executing;
3000b890: e59f3068 ldr r3, [pc, #104] ; 3000b900 <_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;
3000b894: e5821000 str r1, [r2]
tp = _Thread_Executing;
3000b898: e5930004 ldr r0, [r3, #4]
goto done;
3000b89c: 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);
3000b8a0: e1a00c21 lsr r0, r1, #24 3000b8a4: 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 )
3000b8a8: e2403001 sub r3, r0, #1 3000b8ac: e3530002 cmp r3, #2
3000b8b0: 9a00000d bls 3000b8ec <_Thread_Get+0x78>
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
3000b8b4: e3a03001 mov r3, #1 3000b8b8: 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;
3000b8bc: e3a00000 mov r0, #0
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
3000b8c0: e12fff1e bx lr
}
api_information = _Objects_Information_table[ the_api ];
3000b8c4: e59fc038 ldr ip, [pc, #56] ; 3000b904 <_Thread_Get+0x90> 3000b8c8: 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 ) {
3000b8cc: e3500000 cmp r0, #0
3000b8d0: 0a000002 beq 3000b8e0 <_Thread_Get+0x6c>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
3000b8d4: e5900004 ldr r0, [r0, #4]
if ( !information ) {
3000b8d8: e3500000 cmp r0, #0
3000b8dc: 1a000001 bne 3000b8e8 <_Thread_Get+0x74>
*location = OBJECTS_ERROR;
3000b8e0: e5823000 str r3, [r2] <== NOT EXECUTED
goto done;
3000b8e4: e12fff1e bx lr <== NOT EXECUTED
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
3000b8e8: eafffcb2 b 3000abb8 <_Objects_Get>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000b8ec: 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 :) */
3000b8f0: e3530001 cmp r3, #1
3000b8f4: 0afffff2 beq 3000b8c4 <_Thread_Get+0x50>
3000b8f8: eaffffed b 3000b8b4 <_Thread_Get+0x40> <== NOT EXECUTED
3000c1e0 <_Thread_Start>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
3000c1e0: e590c010 ldr ip, [r0, #16]
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000c1e4: e92d4010 push {r4, lr}
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000c1e8: e21cc001 ands ip, ip, #1
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000c1ec: e1a04000 mov r4, r0
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000c1f0: 0a00000b beq 3000c224 <_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;
3000c1f4: e5803098 str r3, [r0, #152] ; 0x98
the_thread->Start.numeric_argument = numeric_argument;
3000c1f8: 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;
3000c1fc: e5802090 str r2, [r0, #144] ; 0x90
the_thread->Start.prototype = the_prototype;
3000c200: e5801094 str r1, [r0, #148] ; 0x94
the_thread->Start.pointer_argument = pointer_argument;
the_thread->Start.numeric_argument = numeric_argument;
3000c204: e580309c str r3, [r0, #156] ; 0x9c
_Thread_Load_environment( the_thread );
3000c208: eb000ca4 bl 3000f4a0 <_Thread_Load_environment>
_Thread_Ready( the_thread );
3000c20c: e1a00004 mov r0, r4 3000c210: eb000d3a bl 3000f700 <_Thread_Ready>
_User_extensions_Thread_start( the_thread );
3000c214: e1a00004 mov r0, r4 3000c218: eb0000d8 bl 3000c580 <_User_extensions_Thread_start>
return true;
3000c21c: e3a00001 mov r0, #1
3000c220: e8bd8010 pop {r4, pc}
}
return false;
3000c224: e1a0000c mov r0, ip <== NOT EXECUTED
}
3000c228: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c22c <_Thread_Tickle_timeslice>:
void _Thread_Tickle_timeslice( void )
{
Thread_Control *executing;
executing = _Thread_Executing;
3000c22c: e59f3090 ldr r3, [pc, #144] ; 3000c2c4 <_Thread_Tickle_timeslice+0x98>
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
3000c230: e92d4010 push {r4, lr}
Thread_Control *executing;
executing = _Thread_Executing;
3000c234: e5934004 ldr r4, [r3, #4]
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
3000c238: e5d43074 ldrb r3, [r4, #116] ; 0x74
3000c23c: e3530000 cmp r3, #0
3000c240: 08bd8010 popeq {r4, pc}
return;
if ( !_States_Is_ready( executing->current_state ) )
3000c244: e5943010 ldr r3, [r4, #16]
3000c248: e3530000 cmp r3, #0
3000c24c: 18bd8010 popne {r4, pc}
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
3000c250: e594307c ldr r3, [r4, #124] ; 0x7c
3000c254: e3530001 cmp r3, #1
3000c258: 38bd8010 popcc {r4, pc}
3000c25c: e3530002 cmp r3, #2 <== NOT EXECUTED
3000c260: 9a000002 bls 3000c270 <_Thread_Tickle_timeslice+0x44> <== NOT EXECUTED
3000c264: e3530003 cmp r3, #3 <== NOT EXECUTED
3000c268: 18bd8010 popne {r4, pc} <== NOT EXECUTED
3000c26c: ea00000b b 3000c2a0 <_Thread_Tickle_timeslice+0x74> <== NOT EXECUTED
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 ) {
3000c270: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000c274: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000c278: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c27c: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000c280: 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();
3000c284: e59f303c ldr r3, [pc, #60] ; 3000c2c8 <_Thread_Tickle_timeslice+0x9c><== NOT EXECUTED 3000c288: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c28c: 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;
3000c290: e59f3034 ldr r3, [pc, #52] ; 3000c2cc <_Thread_Tickle_timeslice+0xa0><== NOT EXECUTED
3000c294: e5933000 ldr r3, [r3] <== NOT EXECUTED
3000c298: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000c29c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
3000c2a0: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000c2a4: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000c2a8: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c2ac: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000c2b0: 18bd8010 popne {r4, pc} <== NOT EXECUTED
(*executing->budget_callout)( executing );
3000c2b4: e1a00004 mov r0, r4 <== NOT EXECUTED
3000c2b8: e1a0e00f mov lr, pc <== NOT EXECUTED
3000c2bc: e594f080 ldr pc, [r4, #128] ; 0x80 <== NOT EXECUTED
3000c2c0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b3f4 <_Thread_blocking_operation_Cancel>:
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000b3f4: e3a03000 mov r3, #0 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000b3f8: e92d4010 push {r4, lr} <== NOT EXECUTED
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000b3fc: 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 ) ) {
3000b400: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000b404: 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 ) ) {
3000b408: e3530002 cmp r3, #2 <== NOT EXECUTED 3000b40c: 1a000005 bne 3000b428 <_Thread_blocking_operation_Cancel+0x34><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000b410: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000b414: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000b418: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000b41c: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3000b420: eb0004cf bl 3000c764 <_Watchdog_Remove> <== NOT EXECUTED 3000b424: ea000000 b 3000b42c <_Thread_blocking_operation_Cancel+0x38><== NOT EXECUTED 3000b428: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000b42c: e59f1008 ldr r1, [pc, #8] ; 3000b43c <_Thread_blocking_operation_Cancel+0x48><== NOT EXECUTED 3000b430: 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
}
3000b434: e8bd4010 pop {r4, lr} <== NOT EXECUTED
3000b438: ea00003f b 3000b53c <_Thread_Clear_state> <== NOT EXECUTED
3000f4ec <_Thread_queue_Dequeue_fifo>:
*/
Thread_Control *_Thread_queue_Dequeue_fifo(
Thread_queue_Control *the_thread_queue
)
{
3000f4ec: e92d4030 push {r4, r5, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000f4f0: e10f3000 mrs r3, CPSR 3000f4f4: e3832080 orr r2, r3, #128 ; 0x80 3000f4f8: e129f002 msr CPSR_fc, r2
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
3000f4fc: e1a02000 mov r2, r0 3000f500: e4925004 ldr r5, [r2], #4
{
ISR_Level level;
Thread_Control *the_thread;
_ISR_Disable( level );
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
3000f504: e1550002 cmp r5, r2
3000f508: 0a000013 beq 3000f55c <_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;
3000f50c: e5952000 ldr r2, [r5]
the_thread = (Thread_Control *)
3000f510: e1a04005 mov r4, r5
head->next = new_first;
3000f514: e5802000 str r2, [r0]
new_first->previous = head;
3000f518: e5820004 str r0, [r2, #4]
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
3000f51c: e3a02000 mov r2, #0 3000f520: e5852044 str r2, [r5, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000f524: e5952050 ldr r2, [r5, #80] ; 0x50 3000f528: e3520002 cmp r2, #2
3000f52c: 0a000001 beq 3000f538 <_Thread_queue_Dequeue_fifo+0x4c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f530: e129f003 msr CPSR_fc, r3 3000f534: ea000004 b 3000f54c <_Thread_queue_Dequeue_fifo+0x60>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000f538: e3a02003 mov r2, #3 <== NOT EXECUTED 3000f53c: e5852050 str r2, [r5, #80] ; 0x50 <== NOT EXECUTED 3000f540: 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 );
3000f544: e2850048 add r0, r5, #72 ; 0x48 <== NOT EXECUTED 3000f548: ebfff485 bl 3000c764 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000f54c: e1a00005 mov r0, r5 3000f550: e59f1014 ldr r1, [pc, #20] ; 3000f56c <_Thread_queue_Dequeue_fifo+0x80> 3000f554: ebffeff8 bl 3000b53c <_Thread_Clear_state> 3000f558: ea000001 b 3000f564 <_Thread_queue_Dequeue_fifo+0x78> 3000f55c: e129f003 msr CPSR_fc, r3
return the_thread;
}
_ISR_Enable( level );
return NULL;
3000f560: e3a04000 mov r4, #0
}
3000f564: e1a00004 mov r0, r4
3000f568: e8bd8030 pop {r4, r5, pc}
3000bbe0 <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
3000bbe0: e92d4030 push {r4, r5, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bbe4: e10f1000 mrs r1, CPSR 3000bbe8: e3813080 orr r3, r1, #128 ; 0x80 3000bbec: 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 );
3000bbf0: e3a02000 mov r2, #0
for( index=0 ;
3000bbf4: 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 );
3000bbf8: e3a0c00c mov ip, #12 3000bbfc: 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 );
}
3000bc00: e7905002 ldr r5, [r0, r2] 3000bc04: e2844004 add r4, r4, #4 3000bc08: 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 ] ) ) {
3000bc0c: e1550004 cmp r5, r4
3000bc10: 0a000009 beq 3000bc3c <_Thread_queue_Dequeue_priority+0x5c>
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
3000bc14: e3a03000 mov r3, #0 3000bc18: 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 );
}
3000bc1c: e5953038 ldr r3, [r5, #56] ; 0x38 3000bc20: 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 ) ) {
3000bc24: 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(
3000bc28: 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;
3000bc2c: e5952000 ldr r2, [r5]
previous_node = the_thread->Object.Node.previous;
3000bc30: e5950004 ldr r0, [r5, #4]
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000bc34: 1a000007 bne 3000bc58 <_Thread_queue_Dequeue_priority+0x78>
3000bc38: ea000017 b 3000bc9c <_Thread_queue_Dequeue_priority+0xbc>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000bc3c: e2833001 add r3, r3, #1
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000bc40: e3530004 cmp r3, #4
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000bc44: e282200c add r2, r2, #12
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000bc48: 1affffeb bne 3000bbfc <_Thread_queue_Dequeue_priority+0x1c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bc4c: e129f001 msr CPSR_fc, r1
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
return NULL;
3000bc50: e3a04000 mov r4, #0 3000bc54: ea00001f b 3000bcd8 <_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 );
}
3000bc58: 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;
3000bc5c: e593e000 ldr lr, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000bc60: 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;
3000bc64: e5803000 str r3, [r0] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000bc68: 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;
3000bc6c: e5832000 str r2, [r3] <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000bc70: e5950038 ldr r0, [r5, #56] ; 0x38 <== NOT EXECUTED 3000bc74: e5952040 ldr r2, [r5, #64] ; 0x40 <== NOT EXECUTED 3000bc78: e1500002 cmp r0, r2 <== NOT EXECUTED 3000bc7c: 0a000008 beq 3000bca4 <_Thread_queue_Dequeue_priority+0xc4><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000bc80: 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;
3000bc84: 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;
3000bc88: e58e2004 str r2, [lr, #4] <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
3000bc8c: 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 );
3000bc90: 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;
3000bc94: e58c3000 str r3, [ip] <== NOT EXECUTED 3000bc98: ea000001 b 3000bca4 <_Thread_queue_Dequeue_priority+0xc4> <== NOT EXECUTED
}
} else {
previous_node->next = next_node;
3000bc9c: e5802000 str r2, [r0]
next_node->previous = previous_node;
3000bca0: e5820004 str r0, [r2, #4]
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000bca4: e5953050 ldr r3, [r5, #80] ; 0x50 3000bca8: e3530002 cmp r3, #2
3000bcac: 0a000001 beq 3000bcb8 <_Thread_queue_Dequeue_priority+0xd8>
3000bcb0: e129f001 msr CPSR_fc, r1 3000bcb4: ea000004 b 3000bccc <_Thread_queue_Dequeue_priority+0xec>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000bcb8: e3a03003 mov r3, #3 <== NOT EXECUTED 3000bcbc: e5853050 str r3, [r5, #80] ; 0x50 <== NOT EXECUTED 3000bcc0: 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 );
3000bcc4: e2850048 add r0, r5, #72 ; 0x48 <== NOT EXECUTED 3000bcc8: eb0002a5 bl 3000c764 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000bccc: e1a00005 mov r0, r5 3000bcd0: e59f1008 ldr r1, [pc, #8] ; 3000bce0 <_Thread_queue_Dequeue_priority+0x100> 3000bcd4: ebfffe18 bl 3000b53c <_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 );
}
3000bcd8: e1a00004 mov r0, r4
3000bcdc: e8bd8030 pop {r4, r5, pc}
3000f570 <_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
)
{
3000f570: e92d4010 push {r4, lr}
3000f574: e1a03000 mov r3, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000f578: e10fc000 mrs ip, CPSR 3000f57c: e38c0080 orr r0, ip, #128 ; 0x80 3000f580: e129f000 msr CPSR_fc, r0
Thread_blocking_operation_States sync_state;
ISR_Level level;
_ISR_Disable( level );
sync_state = the_thread_queue->sync_state;
3000f584: e5930030 ldr r0, [r3, #48] ; 0x30
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000f588: e3a04000 mov r4, #0
if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
3000f58c: 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;
3000f590: e5834030 str r4, [r3, #48] ; 0x30
if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
3000f594: 1a000008 bne 3000f5bc <_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;
3000f598: 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 );
3000f59c: e2834004 add r4, r3, #4
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3000f5a0: e5831008 str r1, [r3, #8]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3000f5a4: e5814000 str r4, [r1]
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
3000f5a8: 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;
3000f5ac: e5821000 str r1, [r2]
_Chain_Append_unprotected(
&the_thread_queue->Queues.Fifo,
&the_thread->Object.Node
);
the_thread->Wait.queue = the_thread_queue;
3000f5b0: e5813044 str r3, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f5b4: e129f00c msr CPSR_fc, ip
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000f5b8: 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;
3000f5bc: e582c000 str ip, [r2] <== NOT EXECUTED
return sync_state; }
3000f5c0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000bd84 <_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 );
3000bd84: 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;
3000bd88: e591c014 ldr ip, [r1, #20]
head->next = tail;
3000bd8c: e5813038 str r3, [r1, #56] ; 0x38
head->previous = NULL;
3000bd90: e3a03000 mov r3, #0 3000bd94: 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 ) )
3000bd98: e31c0020 tst ip, #32
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3000bd9c: 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
)
{
3000bda0: 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;
3000bda4: 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;
3000bda8: 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);
3000bdac: e1a0332c lsr r3, ip, #6
if ( _Thread_queue_Is_reverse_search( priority ) )
3000bdb0: 1a000026 bne 3000be50 <_Thread_queue_Enqueue_priority+0xcc>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
3000bdb4: e3a0600c mov r6, #12 3000bdb8: e0030396 mul r3, r6, r3 3000bdbc: 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));
3000bdc0: e2833004 add r3, r3, #4 3000bdc4: e0806003 add r6, r0, r3
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bdc8: e10f4000 mrs r4, CPSR 3000bdcc: e3843080 orr r3, r4, #128 ; 0x80 3000bdd0: e129f003 msr CPSR_fc, r3
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
3000bdd4: e3e05000 mvn r5, #0
_ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header );
3000bdd8: e5983000 ldr r3, [r8]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
3000bddc: ea00000b b 3000be10 <_Thread_queue_Enqueue_priority+0x8c>
search_priority = search_thread->current_priority;
3000bde0: e5935014 ldr r5, [r3, #20]
if ( priority <= search_priority )
3000bde4: e15c0005 cmp ip, r5
3000bde8: 9a00000a bls 3000be18 <_Thread_queue_Enqueue_priority+0x94>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000bdec: e10fa000 mrs sl, CPSR 3000bdf0: e129f004 msr CPSR_fc, r4 3000bdf4: 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);
3000bdf8: 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) ) {
3000bdfc: e117000a tst r7, sl
3000be00: 1a000001 bne 3000be0c <_Thread_queue_Enqueue_priority+0x88>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000be04: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000be08: eaffffee b 3000bdc8 <_Thread_queue_Enqueue_priority+0x44> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
3000be0c: 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 ) ) {
3000be10: e1530006 cmp r3, r6
3000be14: 1afffff1 bne 3000bde0 <_Thread_queue_Enqueue_priority+0x5c>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
3000be18: e5906030 ldr r6, [r0, #48] ; 0x30 3000be1c: e3560001 cmp r6, #1
3000be20: 1a000039 bne 3000bf0c <_Thread_queue_Enqueue_priority+0x188>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000be24: e3a02000 mov r2, #0
if ( priority == search_priority )
3000be28: 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;
3000be2c: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
3000be30: 0a00002b beq 3000bee4 <_Thread_queue_Enqueue_priority+0x160>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
3000be34: e5932004 ldr r2, [r3, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000be38: e5813000 str r3, [r1]
the_node->previous = previous_node;
3000be3c: e5812004 str r2, [r1, #4]
previous_node->next = the_node;
3000be40: e5821000 str r1, [r2]
search_node->previous = the_node;
3000be44: e5831004 str r1, [r3, #4]
the_thread->Wait.queue = the_thread_queue;
3000be48: e5810044 str r0, [r1, #68] ; 0x44
_ISR_Enable( level );
3000be4c: ea00002b b 3000bf00 <_Thread_queue_Enqueue_priority+0x17c>
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
3000be50: e3a0600c mov r6, #12 3000be54: 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;
3000be58: e59f80b8 ldr r8, [pc, #184] ; 3000bf18 <_Thread_queue_Enqueue_priority+0x194> 3000be5c: e5d85000 ldrb r5, [r8] 3000be60: e2855001 add r5, r5, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000be64: e10f4000 mrs r4, CPSR 3000be68: e3843080 orr r3, r4, #128 ; 0x80 3000be6c: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
3000be70: e5963008 ldr r3, [r6, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
3000be74: ea00000b b 3000bea8 <_Thread_queue_Enqueue_priority+0x124>
search_priority = search_thread->current_priority;
3000be78: e5935014 ldr r5, [r3, #20]
if ( priority >= search_priority )
3000be7c: e15c0005 cmp ip, r5
3000be80: 2a00000a bcs 3000beb0 <_Thread_queue_Enqueue_priority+0x12c>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000be84: e10fa000 mrs sl, CPSR <== NOT EXECUTED 3000be88: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000be8c: e129f00a msr CPSR_fc, sl <== NOT EXECUTED 3000be90: 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) ) {
3000be94: e117000a tst r7, sl <== NOT EXECUTED 3000be98: 1a000001 bne 3000bea4 <_Thread_queue_Enqueue_priority+0x120><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000be9c: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000bea0: eaffffed b 3000be5c <_Thread_queue_Enqueue_priority+0xd8> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
3000bea4: 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 ) ) {
3000bea8: e1530006 cmp r3, r6
3000beac: 1afffff1 bne 3000be78 <_Thread_queue_Enqueue_priority+0xf4>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
3000beb0: e5906030 ldr r6, [r0, #48] ; 0x30 3000beb4: e3560001 cmp r6, #1
3000beb8: 1a000013 bne 3000bf0c <_Thread_queue_Enqueue_priority+0x188>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000bebc: e3a02000 mov r2, #0
if ( priority == search_priority )
3000bec0: 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;
3000bec4: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
3000bec8: 0a000005 beq 3000bee4 <_Thread_queue_Enqueue_priority+0x160>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
3000becc: e5932000 ldr r2, [r3]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
3000bed0: e881000c stm r1, {r2, r3}
search_node->next = the_node; next_node->previous = the_node;
3000bed4: 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;
3000bed8: e5831000 str r1, [r3]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
3000bedc: e5810044 str r0, [r1, #68] ; 0x44
_ISR_Enable( level );
3000bee0: ea000006 b 3000bf00 <_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;
3000bee4: 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 );
3000bee8: e283c03c add ip, r3, #60 ; 0x3c <== NOT EXECUTED
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000beec: e581c000 str ip, [r1] <== NOT EXECUTED
the_node->previous = previous_node;
3000bef0: e5812004 str r2, [r1, #4] <== NOT EXECUTED
previous_node->next = the_node;
3000bef4: e5821000 str r1, [r2] <== NOT EXECUTED
search_node->previous = the_node;
3000bef8: e5831040 str r1, [r3, #64] ; 0x40 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
3000befc: e5810044 str r0, [r1, #68] ; 0x44 <== NOT EXECUTED
3000bf00: e129f004 msr CPSR_fc, r4
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000bf04: e3a00001 mov r0, #1
3000bf08: 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;
3000bf0c: e5824000 str r4, [r2] <== NOT EXECUTED
return the_thread_queue->sync_state;
3000bf10: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
}
3000bf14: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30010f94 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
30010f94: e92d4010 push {r4, lr}
30010f98: e1a04001 mov r4, r1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30010f9c: e10f3000 mrs r3, CPSR 30010fa0: e3832080 orr r2, r3, #128 ; 0x80 30010fa4: e129f002 msr CPSR_fc, r2 30010fa8: e59f2060 ldr r2, [pc, #96] ; 30011010 <_Thread_queue_Extract_fifo+0x7c> 30010fac: e5911010 ldr r1, [r1, #16] 30010fb0: e0012002 and r2, r1, r2
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
30010fb4: e3520000 cmp r2, #0
30010fb8: 1a000001 bne 30010fc4 <_Thread_queue_Extract_fifo+0x30>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30010fbc: 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
}
30010fc0: e8bd8010 pop {r4, pc}
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
30010fc4: e8940006 ldm r4, {r1, r2}
next->previous = previous;
30010fc8: e5812004 str r2, [r1, #4]
previous->next = next;
30010fcc: e5821000 str r1, [r2]
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
30010fd0: e3a02000 mov r2, #0 30010fd4: e5842044 str r2, [r4, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30010fd8: e5942050 ldr r2, [r4, #80] ; 0x50 30010fdc: e3520002 cmp r2, #2
30010fe0: 0a000001 beq 30010fec <_Thread_queue_Extract_fifo+0x58>
30010fe4: e129f003 msr CPSR_fc, r3 30010fe8: ea000004 b 30011000 <_Thread_queue_Extract_fifo+0x6c>
30010fec: e3a02003 mov r2, #3 <== NOT EXECUTED 30010ff0: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 30010ff4: 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 );
30010ff8: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30010ffc: ebffedd8 bl 3000c764 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30011000: e59f100c ldr r1, [pc, #12] ; 30011014 <_Thread_queue_Extract_fifo+0x80> 30011004: e1a00004 mov r0, r4
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
30011008: e8bd4010 pop {r4, lr}
3001100c: eaffe94a b 3000b53c <_Thread_Clear_state>
3000f5dc <_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
)
{
3000f5dc: e92d4070 push {r4, r5, r6, lr}
3000f5e0: e20220ff and r2, r2, #255 ; 0xff
3000f5e4: e1a04001 mov r4, r1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000f5e8: e10f1000 mrs r1, CPSR 3000f5ec: e3813080 orr r3, r1, #128 ; 0x80 3000f5f0: 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);
3000f5f4: e59f30b0 ldr r3, [pc, #176] ; 3000f6ac <_Thread_queue_Extract_priority_helper+0xd0> 3000f5f8: e5940010 ldr r0, [r4, #16] 3000f5fc: 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 ) ) {
3000f600: e3530000 cmp r3, #0
3000f604: 1a000000 bne 3000f60c <_Thread_queue_Extract_priority_helper+0x30>
_ISR_Enable( level );
3000f608: ea000017 b 3000f66c <_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
}
3000f60c: 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;
3000f610: 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 );
3000f614: e284503c add r5, r4, #60 ; 0x3c <== NOT EXECUTED
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000f618: 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;
3000f61c: 058c0000 streq r0, [ip] <== NOT EXECUTED
next_node->previous = previous_node;
3000f620: 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 ) ) {
3000f624: 0a00000e beq 3000f664 <_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
}
3000f628: 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;
3000f62c: e5936000 ldr r6, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000f630: 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;
3000f634: e58c3000 str r3, [ip] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000f638: e8831001 stm r3, {r0, ip} <== NOT EXECUTED
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000f63c: e594c038 ldr ip, [r4, #56] ; 0x38 <== NOT EXECUTED 3000f640: e5940040 ldr r0, [r4, #64] ; 0x40 <== NOT EXECUTED 3000f644: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000f648: 0a000005 beq 3000f664 <_Thread_queue_Extract_priority_helper+0x88><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000f64c: 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;
3000f650: 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;
3000f654: e5860004 str r0, [r6, #4] <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
3000f658: 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 );
3000f65c: 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;
3000f660: e5853000 str r3, [r5] <== NOT EXECUTED
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
3000f664: e3520000 cmp r2, #0 <== NOT EXECUTED 3000f668: 0a000001 beq 3000f674 <_Thread_queue_Extract_priority_helper+0x98><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f66c: e129f001 msr CPSR_fc, r1
3000f670: e8bd8070 pop {r4, r5, r6, pc}
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000f674: e5943050 ldr r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000f678: e3530002 cmp r3, #2 <== NOT EXECUTED 3000f67c: 0a000001 beq 3000f688 <_Thread_queue_Extract_priority_helper+0xac><== NOT EXECUTED 3000f680: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 3000f684: ea000004 b 3000f69c <_Thread_queue_Extract_priority_helper+0xc0><== NOT EXECUTED 3000f688: e3a03003 mov r3, #3 <== NOT EXECUTED 3000f68c: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000f690: 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 );
3000f694: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000f698: ebfff431 bl 3000c764 <_Watchdog_Remove> <== NOT EXECUTED 3000f69c: e59f100c ldr r1, [pc, #12] ; 3000f6b0 <_Thread_queue_Extract_priority_helper+0xd4><== NOT EXECUTED 3000f6a0: 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
}
3000f6a4: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
3000f6a8: eaffefa3 b 3000b53c <_Thread_Clear_state> <== NOT EXECUTED
3000dfd8 <_Thread_queue_First_priority>:
*/
Thread_Control *_Thread_queue_First_priority (
Thread_queue_Control *the_thread_queue
)
{
3000dfd8: e92d4010 push {r4, lr} <== NOT EXECUTED
3000dfdc: e3a02000 mov r2, #0 <== NOT EXECUTED
uint32_t index;
for( index=0 ;
3000dfe0: e1a03002 mov r3, r2 <== 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 );
3000dfe4: e3a0c00c mov ip, #12 <== NOT EXECUTED 3000dfe8: e004039c mul r4, ip, r3 <== NOT EXECUTED
return (Thread_Control *) _Chain_First(
&the_thread_queue->Queues.Priority[ index ]
);
}
return NULL;
}
3000dfec: e7901002 ldr r1, [r0, r2] <== NOT EXECUTED 3000dff0: e2844004 add r4, r4, #4 <== NOT EXECUTED 3000dff4: 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 ] ) )
3000dff8: e1510004 cmp r1, r4 <== NOT EXECUTED 3000dffc: 0a000001 beq 3000e008 <_Thread_queue_First_priority+0x30> <== NOT EXECUTED
return (Thread_Control *) _Chain_First(
3000e000: e1a00001 mov r0, r1 <== NOT EXECUTED
3000e004: e8bd8010 pop {r4, pc} <== NOT EXECUTED
{
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000e008: e2833001 add r3, r3, #1 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3000e00c: e3530004 cmp r3, #4 <== NOT EXECUTED
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000e010: e282200c add r2, r2, #12 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3000e014: 1afffff3 bne 3000dfe8 <_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;
3000e018: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000e01c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000f6b4 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
3000f6b4: e1a01000 mov r1, r0 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
3000f6b8: 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 &&
3000f6bc: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000f6c0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f6c4: 0a000009 beq 3000f6f0 <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000f6c8: e59f202c ldr r2, [pc, #44] ; 3000f6fc <_Thread_queue_Process_timeout+0x48><== NOT EXECUTED 3000f6cc: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 3000f6d0: e1510002 cmp r1, r2 <== NOT EXECUTED 3000f6d4: 1a000005 bne 3000f6f0 <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
3000f6d8: e3530003 cmp r3, #3 <== NOT EXECUTED
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
3000f6dc: 1590303c ldrne r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000f6e0: 15813034 strne r3, [r1, #52] ; 0x34 <== NOT EXECUTED
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
3000f6e4: 13a03002 movne r3, #2 <== NOT EXECUTED 3000f6e8: 15803030 strne r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000f6ec: e12fff1e bx lr <== NOT EXECUTED
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
3000f6f0: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000f6f4: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
3000f6f8: eaffffb1 b 3000f5c4 <_Thread_queue_Extract> <== NOT EXECUTED
3000bfdc <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000bfdc: 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 )
3000bfe0: e2504000 subs r4, r0, #0 <== NOT EXECUTED
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000bfe4: 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 )
3000bfe8: 0a000011 beq 3000c034 <_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 ) {
3000bfec: e5942034 ldr r2, [r4, #52] ; 0x34 <== NOT EXECUTED 3000bff0: e3520001 cmp r2, #1 <== NOT EXECUTED 3000bff4: 1a00000e bne 3000c034 <_Thread_queue_Requeue+0x58> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bff8: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000bffc: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000c000: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 3000c004: e59f302c ldr r3, [pc, #44] ; 3000c038 <_Thread_queue_Requeue+0x5c><== NOT EXECUTED 3000c008: e591c010 ldr ip, [r1, #16] <== NOT EXECUTED 3000c00c: 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 ) ) {
3000c010: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c014: 0a000005 beq 3000c030 <_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;
3000c018: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
3000c01c: eb000d6e bl 3000f5dc <_Thread_queue_Extract_priority_helper><== NOT EXECUTED
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
3000c020: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c024: e1a01005 mov r1, r5 <== NOT EXECUTED 3000c028: e1a0200d mov r2, sp <== NOT EXECUTED 3000c02c: ebffff54 bl 3000bd84 <_Thread_queue_Enqueue_priority> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c030: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
}
_ISR_Enable( level );
}
}
3000c034: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000c03c <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000c03c: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000c040: e1a0100d mov r1, sp <== NOT EXECUTED 3000c044: ebfffe0a bl 3000b874 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000c048: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000c04c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c050: 1a000004 bne 3000c068 <_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 );
3000c054: eb000d96 bl 3000f6b4 <_Thread_queue_Process_timeout> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000c058: e59f300c ldr r3, [pc, #12] ; 3000c06c <_Thread_queue_Timeout+0x30><== NOT EXECUTED 3000c05c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c060: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000c064: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000c068: 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: eb0010c5 bl 3001ca28 <_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: eb0010bc bl 3001ca28 <_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: 3b00108f blcc 3001c988 <_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: eb00029b bl 300191c4 <_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: eb0010d4 bl 3001cad4 <_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: eb000ece bl 3001c358 <_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: eb000c9f bl 3001bab0 <_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: eb0010fc bl 3001cc34 <_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: eb0010fa bl 3001cc34 <_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: eb001185 bl 3001cc34 <_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: ea001121 b 3001cad4 <_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: eb001171 bl 3001cc34 <_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: ea00110d b 3001cad4 <_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: eb001083 bl 3001cad4 <_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: eb001065 bl 3001cad4 <_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: ea000c56 b 3001bab0 <_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: ea000205 b 30019178 <_Chain_Append> <== NOT EXECUTED
3000c2d0 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
3000c2d0: e1a03000 mov r3, r0
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000c2d4: e5932000 ldr r2, [r3]
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
uint32_t seconds = add->tv_sec;
3000c2d8: e5910000 ldr r0, [r1]
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
3000c2dc: e593c004 ldr ip, [r3, #4]
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000c2e0: e0822000 add r2, r2, r0 3000c2e4: e5832000 str r2, [r3]
time->tv_nsec += add->tv_nsec;
3000c2e8: e5912004 ldr r2, [r1, #4] 3000c2ec: e08c2002 add r2, ip, r2 3000c2f0: e5832004 str r2, [r3, #4]
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000c2f4: e59fc02c ldr ip, [pc, #44] ; 3000c328 <_Timespec_Add_to+0x58> 3000c2f8: ea000006 b 3000c318 <_Timespec_Add_to+0x48>
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000c2fc: e59f2028 ldr r2, [pc, #40] ; 3000c32c <_Timespec_Add_to+0x5c><== NOT EXECUTED
time->tv_sec++;
seconds++;
3000c300: 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;
3000c304: e0812002 add r2, r1, r2 <== NOT EXECUTED 3000c308: e5832004 str r2, [r3, #4] <== NOT EXECUTED
time->tv_sec++;
3000c30c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c310: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000c314: 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 ) {
3000c318: e5931004 ldr r1, [r3, #4] 3000c31c: e151000c cmp r1, ip
3000c320: 8afffff5 bhi 3000c2fc <_Timespec_Add_to+0x2c>
time->tv_sec++;
seconds++;
}
return seconds;
}
3000c324: e12fff1e bx lr
3000ddfc <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000ddfc: e92d40f0 push {r4, r5, r6, r7, lr}
3000de00: 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;
3000de04: 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;
3000de08: 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;
3000de0c: e590c000 ldr ip, [r0]
left += lhs->tv_nsec;
3000de10: e5906004 ldr r6, [r0, #4]
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000de14: e59f0064 ldr r0, [pc, #100] ; 3000de80 <_Timespec_Divide+0x84>
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000de18: 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;
3000de1c: e1a03fc2 asr r3, r2, #31 3000de20: e0e32790 smlal r2, r3, r0, r7
if ( right == 0 ) {
3000de24: e1921003 orrs r1, r2, r3
*ival_percentage = 0;
3000de28: 05851000 streq r1, [r5]
*fval_percentage = 0;
3000de2c: 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 ) {
3000de30: 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;
3000de34: e1a07fc6 asr r7, r6, #31 <== NOT EXECUTED 3000de38: 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;
3000de3c: e59fc040 ldr ip, [pc, #64] ; 3000de84 <_Timespec_Divide+0x88><== NOT EXECUTED 3000de40: e0810c96 umull r0, r1, r6, ip <== NOT EXECUTED 3000de44: e021179c mla r1, ip, r7, r1 <== NOT EXECUTED 3000de48: eb003f5d bl 3001dbc4 <__udivdi3> <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000de4c: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000de50: 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;
3000de54: e1a07000 mov r7, r0 <== NOT EXECUTED 3000de58: e1a06001 mov r6, r1 <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000de5c: eb003f58 bl 3001dbc4 <__udivdi3> <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000de60: e1a01006 mov r1, r6 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
3000de64: e5850000 str r0, [r5] <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000de68: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
3000de6c: e1a00007 mov r0, r7 <== NOT EXECUTED
3000de70: e3a03000 mov r3, #0 <== NOT EXECUTED
3000de74: eb004064 bl 3001e00c <__umoddi3> <== NOT EXECUTED
3000de78: e5840000 str r0, [r4] <== NOT EXECUTED
3000de7c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000de08 <_Timespec_Divide_by_integer>:
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3000de08: 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;
3000de0c: e59fc06c ldr ip, [pc, #108] ; 3000de80 <_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;
3000de10: e590e000 ldr lr, [r0] <== NOT EXECUTED
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3000de14: e1a03001 mov r3, r1 <== NOT EXECUTED 3000de18: 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;
3000de1c: 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;
3000de20: e1a0500e mov r5, lr <== NOT EXECUTED 3000de24: e1a06fc5 asr r6, r5, #31 <== NOT EXECUTED
t *= TOD_NANOSECONDS_PER_SECOND;
3000de28: e022269c mla r2, ip, r6, r2 <== NOT EXECUTED
t += time->tv_nsec;
3000de2c: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3000de30: e0915000 adds r5, r1, r0 <== NOT EXECUTED 3000de34: e0a26fc0 adc r6, r2, r0, asr #31 <== NOT EXECUTED 3000de38: e1a01006 mov r1, r6 <== NOT EXECUTED 3000de3c: e1a02003 mov r2, r3 <== NOT EXECUTED 3000de40: e1a00005 mov r0, r5 <== NOT EXECUTED 3000de44: e3a03000 mov r3, #0 <== NOT EXECUTED 3000de48: eb003d9c bl 3001d4c0 <__udivdi3> <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000de4c: e59f202c ldr r2, [pc, #44] ; 3000de80 <_Timespec_Divide_by_integer+0x78><== NOT EXECUTED 3000de50: e3a03000 mov r3, #0 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3000de54: e1a06000 mov r6, r0 <== NOT EXECUTED 3000de58: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000de5c: eb003d97 bl 3001d4c0 <__udivdi3> <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
3000de60: e1a01005 mov r1, r5 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000de64: e5840000 str r0, [r4] <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
3000de68: e59f2010 ldr r2, [pc, #16] ; 3000de80 <_Timespec_Divide_by_integer+0x78><== NOT EXECUTED 3000de6c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000de70: e3a03000 mov r3, #0 <== NOT EXECUTED 3000de74: eb003ea3 bl 3001d908 <__umoddi3> <== NOT EXECUTED 3000de78: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
3000de7c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30021ab4 <_Timespec_From_ticks>:
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
30021ab4: e59f3038 ldr r3, [pc, #56] ; 30021af4 <_Timespec_From_ticks+0x40><== NOT EXECUTED
void _Timespec_From_ticks(
uint32_t ticks,
struct timespec *time
)
{
30021ab8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
30021abc: e593500c ldr r5, [r3, #12] <== NOT EXECUTED
void _Timespec_From_ticks(
uint32_t ticks,
struct timespec *time
)
{
30021ac0: e1a04001 mov r4, r1 <== NOT EXECUTED
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
30021ac4: e0050590 mul r5, r0, r5 <== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
30021ac8: e59f1028 ldr r1, [pc, #40] ; 30021af8 <_Timespec_From_ticks+0x44><== NOT EXECUTED 30021acc: e1a00005 mov r0, r5 <== NOT EXECUTED 30021ad0: ebfff677 bl 3001f4b4 <__aeabi_uidiv> <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
30021ad4: e59f101c ldr r1, [pc, #28] ; 30021af8 <_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;
30021ad8: e5840000 str r0, [r4] <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
30021adc: e1a00005 mov r0, r5 <== NOT EXECUTED 30021ae0: ebfff70b bl 3001f714 <__umodsi3> <== NOT EXECUTED 30021ae4: e3a03ffa mov r3, #1000 ; 0x3e8 <== NOT EXECUTED 30021ae8: e0030390 mul r3, r0, r3 <== NOT EXECUTED 30021aec: e5843004 str r3, [r4, #4] <== NOT EXECUTED
TOD_NANOSECONDS_PER_MICROSECOND;
}
30021af0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30021afc <_Timespec_Is_valid>:
bool _Timespec_Is_valid(
const struct timespec *time
)
{
if ( !time )
30021afc: e3500000 cmp r0, #0 <== NOT EXECUTED 30021b00: 012fff1e bxeq lr <== NOT EXECUTED
return false;
if ( time->tv_sec < 0 )
30021b04: e5903000 ldr r3, [r0] <== NOT EXECUTED 30021b08: e3530000 cmp r3, #0 <== NOT EXECUTED
return false;
30021b0c: b3a00000 movlt r0, #0 <== NOT EXECUTED
)
{
if ( !time )
return false;
if ( time->tv_sec < 0 )
30021b10: b12fff1e bxlt lr <== NOT EXECUTED
return false;
if ( time->tv_nsec < 0 )
30021b14: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 30021b18: e3530000 cmp r3, #0 <== NOT EXECUTED 30021b1c: ba000004 blt 30021b34 <_Timespec_Is_valid+0x38> <== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
30021b20: e59f0014 ldr r0, [pc, #20] ; 30021b3c <_Timespec_Is_valid+0x40><== NOT EXECUTED 30021b24: e1530000 cmp r3, r0 <== NOT EXECUTED 30021b28: 83a00000 movhi r0, #0 <== NOT EXECUTED 30021b2c: 93a00001 movls r0, #1 <== NOT EXECUTED 30021b30: e12fff1e bx lr <== NOT EXECUTED
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
30021b34: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
30021b38: e12fff1e bx lr <== NOT EXECUTED
3000f800 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
3000f800: e5902000 ldr r2, [r0] 3000f804: e5913000 ldr r3, [r1] 3000f808: e1520003 cmp r2, r3
return true;
3000f80c: b3a00001 movlt r0, #1
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
3000f810: b12fff1e bxlt lr
return true;
if ( lhs->tv_sec > rhs->tv_sec )
3000f814: ca000005 bgt 3000f830 <_Timespec_Less_than+0x30>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Less_than(
3000f818: e5900004 ldr r0, [r0, #4] 3000f81c: e5913004 ldr r3, [r1, #4] 3000f820: e1500003 cmp r0, r3 3000f824: a3a00000 movge r0, #0 3000f828: b3a00001 movlt r0, #1 3000f82c: e12fff1e bx lr
{
if ( lhs->tv_sec < rhs->tv_sec )
return true;
if ( lhs->tv_sec > rhs->tv_sec )
return false;
3000f830: e3a00000 mov r0, #0 <== NOT EXECUTED
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
return true;
return false;
}
3000f834: e12fff1e bx lr <== NOT EXECUTED
3000f730 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
3000f730: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
3000f734: e5906000 ldr r6, [r0] <== NOT EXECUTED
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
3000f738: e1a05000 mov r5, r0 <== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
3000f73c: e3560000 cmp r6, #0 <== NOT EXECUTED
3000f740: 1a000002 bne 3000f750 <_Timespec_To_ticks+0x20> <== NOT EXECUTED
3000f744: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED
3000f748: e3500000 cmp r0, #0 <== NOT EXECUTED
3000f74c: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
3000f750: eb0005e7 bl 30010ef4 <TOD_TICKS_PER_SECOND_method> <== NOT EXECUTED
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
3000f754: e59f3020 ldr r3, [pc, #32] ; 3000f77c <_Timespec_To_ticks+0x4c><== NOT EXECUTED 3000f758: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000f75c: 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;
3000f760: e0040096 mul r4, r6, r0 <== NOT EXECUTED
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
3000f764: e0010193 mul r1, r3, r1 <== NOT EXECUTED 3000f768: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 3000f76c: eb001417 bl 300147d0 <__aeabi_uidiv> <== NOT EXECUTED
if (ticks)
3000f770: e0940000 adds r0, r4, r0 <== NOT EXECUTED
return ticks;
return 1;
3000f774: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
3000f778: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000c494 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000c494: 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 );
}
}
3000c498: e59f503c ldr r5, [pc, #60] ; 3000c4dc <_User_extensions_Fatal+0x48>
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000c49c: e1a08000 mov r8, r0 3000c4a0: e1a07002 mov r7, r2 3000c4a4: 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 );
}
}
3000c4a8: e5954008 ldr r4, [r5, #8]
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000c4ac: ea000007 b 3000c4d0 <_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 )
3000c4b0: e5943030 ldr r3, [r4, #48] ; 0x30 3000c4b4: e3530000 cmp r3, #0
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
3000c4b8: 11a00008 movne r0, r8 3000c4bc: 11a01006 movne r1, r6 3000c4c0: 11a02007 movne r2, r7 3000c4c4: 11a0e00f movne lr, pc 3000c4c8: 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 ) {
3000c4cc: e5944004 ldr r4, [r4, #4]
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000c4d0: e1540005 cmp r4, r5
3000c4d4: 1afffff5 bne 3000c4b0 <_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 );
}
}
3000c4d8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000db20 <_User_extensions_Remove_set>:
#include <rtems/score/userext.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
3000db20: e92d4010 push {r4, lr}
3000db24: e1a04000 mov r4, r0
_Chain_Extract( &the_extension->Node );
3000db28: ebfff675 bl 3000b504 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
3000db2c: e5943024 ldr r3, [r4, #36] ; 0x24
3000db30: e3530000 cmp r3, #0
3000db34: 08bd8010 popeq {r4, pc}
_Chain_Extract( &the_extension->Switch.Node );
3000db38: e2840008 add r0, r4, #8 <== NOT EXECUTED
}
3000db3c: 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 );
3000db40: eafff66f b 3000b504 <_Chain_Extract> <== NOT EXECUTED
3000e198 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
3000e198: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000e19c: e1a04000 mov r4, r0
3000e1a0: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000e1a4: e10f3000 mrs r3, CPSR 3000e1a8: e3832080 orr r2, r3, #128 ; 0x80 3000e1ac: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
3000e1b0: e1a06000 mov r6, r0 3000e1b4: 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 ) ) {
3000e1b8: e1520006 cmp r2, r6
3000e1bc: 0a00001b beq 3000e230 <_Watchdog_Adjust+0x98>
switch ( direction ) {
3000e1c0: 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;
3000e1c4: 03a08001 moveq r8, #1 <== NOT EXECUTED
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000e1c8: 0a000016 beq 3000e228 <_Watchdog_Adjust+0x90> <== NOT EXECUTED 3000e1cc: e3510001 cmp r1, #1 <== NOT EXECUTED 3000e1d0: 1a000016 bne 3000e230 <_Watchdog_Adjust+0x98> <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
3000e1d4: e5921010 ldr r1, [r2, #16] <== NOT EXECUTED 3000e1d8: e0815005 add r5, r1, r5 <== NOT EXECUTED 3000e1dc: ea000004 b 3000e1f4 <_Watchdog_Adjust+0x5c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000e1e0: e5942000 ldr r2, [r4] <== NOT EXECUTED
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
3000e1e4: e5927010 ldr r7, [r2, #16] <== NOT EXECUTED 3000e1e8: e1550007 cmp r5, r7 <== NOT EXECUTED 3000e1ec: 2a000002 bcs 3000e1fc <_Watchdog_Adjust+0x64> <== NOT EXECUTED
_Watchdog_First( header )->delta_interval -= units;
3000e1f0: e0655007 rsb r5, r5, r7 <== NOT EXECUTED 3000e1f4: e5825010 str r5, [r2, #16] <== NOT EXECUTED
break;
3000e1f8: ea00000c b 3000e230 <_Watchdog_Adjust+0x98> <== NOT EXECUTED
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000e1fc: e5828010 str r8, [r2, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000e200: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Tickle( header );
3000e204: e1a00004 mov r0, r4 <== NOT EXECUTED 3000e208: eb00008b bl 3000e43c <_Watchdog_Tickle> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000e20c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000e210: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000e214: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000e218: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000e21c: e1520006 cmp r2, r6 <== NOT EXECUTED 3000e220: 0a000002 beq 3000e230 <_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;
3000e224: e0675005 rsb r5, r7, r5 <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000e228: e3550000 cmp r5, #0 <== NOT EXECUTED 3000e22c: 1affffeb bne 3000e1e0 <_Watchdog_Adjust+0x48> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000e230: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
3000e234: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3001ca28 <_Watchdog_Adjust_to_chain>:
{
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
if ( units <= 0 ) {
3001ca28: e3510000 cmp r1, #0 <== NOT EXECUTED
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
3001ca2c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
if ( units <= 0 ) {
3001ca30: 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 (
3001ca34: e10f5000 mrs r5, CPSR <== NOT EXECUTED 3001ca38: e3853080 orr r3, r5, #128 ; 0x80 <== NOT EXECUTED 3001ca3c: 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;
3001ca40: 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 );
3001ca44: 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 );
3001ca48: e2827004 add r7, r2, #4 <== NOT EXECUTED 3001ca4c: ea000001 b 3001ca58 <_Watchdog_Adjust_to_chain+0x30> <== NOT EXECUTED
}
_ISR_Disable( level );
while ( 1 ) {
if ( units <= 0 ) {
3001ca50: e3510000 cmp r1, #0 <== NOT EXECUTED 3001ca54: 0a00001c beq 3001cacc <_Watchdog_Adjust_to_chain+0xa4> <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001ca58: e590c000 ldr ip, [r0] <== NOT EXECUTED
while ( 1 ) {
if ( units <= 0 ) {
break;
}
if ( _Chain_Is_empty( header ) ) {
3001ca5c: e15c0006 cmp ip, r6 <== NOT EXECUTED 3001ca60: 0a000019 beq 3001cacc <_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 ) {
3001ca64: e59c4010 ldr r4, [ip, #16] <== NOT EXECUTED 3001ca68: e1a0300c mov r3, ip <== NOT EXECUTED 3001ca6c: e1510004 cmp r1, r4 <== NOT EXECUTED
first->delta_interval -= units;
3001ca70: 30611004 rsbcc r1, r1, r4 <== NOT EXECUTED 3001ca74: 358c1010 strcc r1, [ip, #16] <== NOT EXECUTED
break;
3001ca78: 3a000013 bcc 3001cacc <_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;
3001ca7c: e0641001 rsb r1, r4, r1 <== NOT EXECUTED
first->delta_interval = 0;
3001ca80: e58c8010 str r8, [ip, #16] <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3001ca84: e8931010 ldm r3, {r4, ip} <== NOT EXECUTED
next->previous = previous;
3001ca88: e584c004 str ip, [r4, #4] <== NOT EXECUTED
previous->next = next;
3001ca8c: 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;
3001ca90: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
the_node->next = tail;
3001ca94: e5837000 str r7, [r3] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node;
3001ca98: 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;
3001ca9c: e5823008 str r3, [r2, #8] <== NOT EXECUTED
old_last->next = the_node; the_node->previous = old_last;
3001caa0: e583c004 str ip, [r3, #4] <== NOT EXECUTED
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3001caa4: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001caa8: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED 3001caac: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001cab0: 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 ) )
3001cab4: e1530006 cmp r3, r6 <== NOT EXECUTED 3001cab8: 0affffe4 beq 3001ca50 <_Watchdog_Adjust_to_chain+0x28> <== NOT EXECUTED
break;
first = _Watchdog_First( header );
if ( first->delta_interval != 0 )
3001cabc: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001cac0: e35c0000 cmp ip, #0 <== NOT EXECUTED 3001cac4: 0affffee beq 3001ca84 <_Watchdog_Adjust_to_chain+0x5c> <== NOT EXECUTED 3001cac8: eaffffe0 b 3001ca50 <_Watchdog_Adjust_to_chain+0x28> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001cacc: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
3001cad0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c604 <_Watchdog_Insert>:
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
3000c604: e59f30f4 ldr r3, [pc, #244] ; 3000c700 <_Watchdog_Insert+0xfc>
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
3000c608: 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;
3000c60c: e5934000 ldr r4, [r3]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c610: e10fc000 mrs ip, CPSR 3000c614: e38c3080 orr r3, ip, #128 ; 0x80 3000c618: 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 ) {
3000c61c: e5913008 ldr r3, [r1, #8] 3000c620: e3530000 cmp r3, #0
3000c624: 0a000000 beq 3000c62c <_Watchdog_Insert+0x28>
_ISR_Enable( level );
3000c628: ea000032 b 3000c6f8 <_Watchdog_Insert+0xf4> <== NOT EXECUTED
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
3000c62c: e3a03001 mov r3, #1 3000c630: e5813008 str r3, [r1, #8]
_Watchdog_Sync_count++;
3000c634: e59f30c8 ldr r3, [pc, #200] ; 3000c704 <_Watchdog_Insert+0x100>
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000c638: e59f60c8 ldr r6, [pc, #200] ; 3000c708 <_Watchdog_Insert+0x104>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
3000c63c: e5932000 ldr r2, [r3]
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000c640: e1a07006 mov r7, r6
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
3000c644: e2822001 add r2, r2, #1 3000c648: e5832000 str r2, [r3]
restart:
delta_interval = the_watchdog->initial;
3000c64c: e591200c ldr r2, [r1, #12]
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000c650: e5903000 ldr r3, [r0]
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000c654: e3520000 cmp r2, #0
3000c658: 0a000014 beq 3000c6b0 <_Watchdog_Insert+0xac>
3000c65c: e5935000 ldr r5, [r3] 3000c660: e3550000 cmp r5, #0
3000c664: 0a000011 beq 3000c6b0 <_Watchdog_Insert+0xac>
break;
if ( delta_interval < after->delta_interval ) {
3000c668: e5935010 ldr r5, [r3, #16] 3000c66c: e1520005 cmp r2, r5
after->delta_interval -= delta_interval;
3000c670: 30625005 rsbcc r5, r2, r5 3000c674: 35835010 strcc r5, [r3, #16]
break;
3000c678: 3a00000c bcc 3000c6b0 <_Watchdog_Insert+0xac>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000c67c: e10f8000 mrs r8, CPSR 3000c680: e129f00c msr CPSR_fc, ip 3000c684: e129f008 msr CPSR_fc, r8
delta_interval -= after->delta_interval;
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
3000c688: e5918008 ldr r8, [r1, #8] 3000c68c: e3580001 cmp r8, #1
3000c690: 1a000012 bne 3000c6e0 <_Watchdog_Insert+0xdc>
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000c694: e5968000 ldr r8, [r6] 3000c698: e1580004 cmp r8, r4
_Watchdog_Sync_level = insert_isr_nest_level;
3000c69c: 85874000 strhi r4, [r7]
goto restart;
3000c6a0: 8affffe9 bhi 3000c64c <_Watchdog_Insert+0x48>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
3000c6a4: e0652002 rsb r2, r5, r2
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
3000c6a8: e5933000 ldr r3, [r3]
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
goto restart;
}
}
3000c6ac: eaffffe8 b 3000c654 <_Watchdog_Insert+0x50>
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
3000c6b0: e5933004 ldr r3, [r3, #4]
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
3000c6b4: e3a00002 mov r0, #2
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
3000c6b8: e5812010 str r2, [r1, #16] 3000c6bc: e5810008 str r0, [r1, #8]
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000c6c0: e5932000 ldr r2, [r3]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000c6c4: e5813004 str r3, [r1, #4]
before_node = after_node->next; after_node->next = the_node;
3000c6c8: e5831000 str r1, [r3]
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
3000c6cc: e59f3038 ldr r3, [pc, #56] ; 3000c70c <_Watchdog_Insert+0x108>
the_node->next = before_node; before_node->previous = the_node;
3000c6d0: e5821004 str r1, [r2, #4] 3000c6d4: 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;
3000c6d8: e5812000 str r2, [r1] 3000c6dc: e5813014 str r3, [r1, #20]
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
3000c6e0: e59f3020 ldr r3, [pc, #32] ; 3000c708 <_Watchdog_Insert+0x104> 3000c6e4: e5834000 str r4, [r3]
_Watchdog_Sync_count--;
3000c6e8: e59f3014 ldr r3, [pc, #20] ; 3000c704 <_Watchdog_Insert+0x100> 3000c6ec: e5932000 ldr r2, [r3] 3000c6f0: e2422001 sub r2, r2, #1 3000c6f4: e5832000 str r2, [r3]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c6f8: e129f00c msr CPSR_fc, ip
3000c6fc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000dc60 <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
3000dc60: e92d401f push {r0, r1, r2, r3, r4, lr} <== NOT EXECUTED
3000dc64: e1a03001 mov r3, r1 <== NOT EXECUTED
printk(
3000dc68: e2501000 subs r1, r0, #0 <== NOT EXECUTED
3000dc6c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
3000dc70: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED
3000dc74: e593001c ldr r0, [r3, #28] <== NOT EXECUTED
3000dc78: 059f102c ldreq r1, [pc, #44] ; 3000dcac <_Watchdog_Report+0x4c><== NOT EXECUTED
3000dc7c: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
3000dc80: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
3000dc84: 01a02001 moveq r2, r1 <== NOT EXECUTED
3000dc88: e58d000c str r0, [sp, #12] <== NOT EXECUTED
3000dc8c: e5930024 ldr r0, [r3, #36] ; 0x24 <== NOT EXECUTED
3000dc90: 159f2018 ldrne r2, [pc, #24] ; 3000dcb0 <_Watchdog_Report+0x50><== NOT EXECUTED
3000dc94: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
3000dc98: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
3000dc9c: e59f0010 ldr r0, [pc, #16] ; 3000dcb4 <_Watchdog_Report+0x54><== NOT EXECUTED
3000dca0: ebffe83a bl 30007d90 <printk> <== NOT EXECUTED
watch,
watch->routine,
watch->id,
watch->user_data
);
}
3000dca4: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000dca8: e8bd8000 pop {pc} <== NOT EXECUTED
3000dbe8 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
3000dbe8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000dbec: e1a04000 mov r4, r0 <== NOT EXECUTED
3000dbf0: e1a05001 mov r5, r1 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000dbf4: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000dbf8: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000dbfc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
3000dc00: e59f004c ldr r0, [pc, #76] ; 3000dc54 <_Watchdog_Report_chain+0x6c><== NOT EXECUTED 3000dc04: e1a02005 mov r2, r5 <== NOT EXECUTED 3000dc08: e1a01004 mov r1, r4 <== NOT EXECUTED 3000dc0c: ebffe85f bl 30007d90 <printk> <== NOT EXECUTED
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
3000dc10: 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 ) ) {
3000dc14: e1570005 cmp r7, r5 <== NOT EXECUTED 3000dc18: 0a000009 beq 3000dc44 <_Watchdog_Report_chain+0x5c> <== NOT EXECUTED
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
3000dc1c: e1a01007 mov r1, r7 <== NOT EXECUTED 3000dc20: e3a00000 mov r0, #0 <== NOT EXECUTED 3000dc24: eb00000d bl 3000dc60 <_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 )
3000dc28: 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 ) ;
3000dc2c: e1570005 cmp r7, r5 <== NOT EXECUTED 3000dc30: 1afffff9 bne 3000dc1c <_Watchdog_Report_chain+0x34> <== NOT EXECUTED
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
3000dc34: e59f001c ldr r0, [pc, #28] ; 3000dc58 <_Watchdog_Report_chain+0x70><== NOT EXECUTED 3000dc38: e1a01004 mov r1, r4 <== NOT EXECUTED 3000dc3c: ebffe853 bl 30007d90 <printk> <== NOT EXECUTED 3000dc40: ea000001 b 3000dc4c <_Watchdog_Report_chain+0x64> <== NOT EXECUTED
} else {
printk( "Chain is empty\n" );
3000dc44: e59f0010 ldr r0, [pc, #16] ; 3000dc5c <_Watchdog_Report_chain+0x74><== NOT EXECUTED 3000dc48: ebffe850 bl 30007d90 <printk> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000dc4c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
}
_ISR_Enable( level );
}
3000dc50: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000c808 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
3000c808: e92d40f0 push {r4, r5, r6, r7, lr}
3000c80c: e1a06000 mov r6, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c810: e10f7000 mrs r7, CPSR 3000c814: e3873080 orr r3, r7, #128 ; 0x80 3000c818: e129f003 msr CPSR_fc, r3
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000c81c: e1a05000 mov r5, r0 3000c820: e4953004 ldr r3, [r5], #4
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000c824: e1530005 cmp r3, r5
3000c828: 0a000018 beq 3000c890 <_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) {
3000c82c: e5932010 ldr r2, [r3, #16]
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000c830: e1a04003 mov r4, r3 3000c834: e3520000 cmp r2, #0
3000c838: 0a000003 beq 3000c84c <_Watchdog_Tickle+0x44>
the_watchdog->delta_interval--;
3000c83c: e2422001 sub r2, r2, #1 3000c840: e5832010 str r2, [r3, #16]
if ( the_watchdog->delta_interval != 0 )
3000c844: e3520000 cmp r2, #0
3000c848: 1a000010 bne 3000c890 <_Watchdog_Tickle+0x88>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
3000c84c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c850: ebffffc3 bl 3000c764 <_Watchdog_Remove> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c854: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
switch( watchdog_state ) {
3000c858: e3500002 cmp r0, #2 <== NOT EXECUTED
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
3000c85c: 05940020 ldreq r0, [r4, #32] <== NOT EXECUTED 3000c860: 05941024 ldreq r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000c864: 01a0e00f moveq lr, pc <== NOT EXECUTED 3000c868: 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 (
3000c86c: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000c870: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3000c874: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000c878: e5964000 ldr r4, [r6] <== NOT EXECUTED
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
3000c87c: e1540005 cmp r4, r5 <== NOT EXECUTED 3000c880: 0a000002 beq 3000c890 <_Watchdog_Tickle+0x88> <== NOT EXECUTED
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
3000c884: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 3000c888: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c88c: eaffffed b 3000c848 <_Watchdog_Tickle+0x40> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c890: e129f007 msr CPSR_fc, r7
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000c894: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000c918 <_Workspace_Allocate_or_fatal_error>:
3000c918: e3a02000 mov r2, #0
* _Workspace_Allocate_or_fatal_error
*/
void *_Workspace_Allocate_or_fatal_error(
size_t size
)
{
3000c91c: e1a01000 mov r1, r0
3000c920: e52de004 push {lr} ; (str lr, [sp, #-4]!)
3000c924: e59f0018 ldr r0, [pc, #24] ; 3000c944 <_Workspace_Allocate_or_fatal_error+0x2c>
3000c928: e1a03002 mov r3, r2
3000c92c: eb0009df bl 3000f0b0 <_Heap_Allocate_aligned_with_boundary>
__builtin_return_address( 1 ),
memory
);
#endif
if ( memory == NULL )
3000c930: e3500000 cmp r0, #0
3000c934: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
_Internal_error_Occurred(
3000c938: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c93c: e3a02003 mov r2, #3 <== NOT EXECUTED 3000c940: ebfff769 bl 3000a6ec <_Internal_error_Occurred> <== NOT EXECUTED
3000c898 <_Workspace_Handler_initialization>:
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
3000c898: e59f3048 ldr r3, [pc, #72] ; 3000c8e8 <_Workspace_Handler_initialization+0x50>
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
3000c89c: e92d4030 push {r4, r5, lr}
uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start;
3000c8a0: e5935000 ldr r5, [r3]
uintptr_t size = Configuration.work_space_size;
3000c8a4: e5934004 ldr r4, [r3, #4]
if ( Configuration.do_zero_of_workspace )
3000c8a8: e5d33028 ldrb r3, [r3, #40] ; 0x28 3000c8ac: e3530000 cmp r3, #0
memset( starting_address, 0, size );
3000c8b0: 11a00005 movne r0, r5 3000c8b4: 13a01000 movne r1, #0 3000c8b8: 11a02004 movne r2, r4 3000c8bc: 1b001465 blne 30011a58 <memset>
memory_available = _Heap_Initialize(
3000c8c0: e59f0024 ldr r0, [pc, #36] ; 3000c8ec <_Workspace_Handler_initialization+0x54> 3000c8c4: e1a01005 mov r1, r5 3000c8c8: e1a02004 mov r2, r4 3000c8cc: e3a03008 mov r3, #8 3000c8d0: ebfff6f2 bl 3000a4a0 <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
3000c8d4: e3500000 cmp r0, #0
3000c8d8: 18bd8030 popne {r4, r5, pc}
_Internal_error_Occurred(
3000c8dc: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c8e0: e3a02002 mov r2, #2 <== NOT EXECUTED 3000c8e4: ebfff780 bl 3000a6ec <_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: eb000fe9 bl 3000d1b4 <rtems_fatal_error_occurred> <== NOT EXECUTED
3001507c <__env_lock>:
3001507c: e12fff1e bx lr <== NOT EXECUTED
30015080 <__env_unlock>:
30015080: e12fff1e bx lr <== NOT EXECUTED
3000697c <__getpid>:
#include <unistd.h>
pid_t __getpid(void)
{
return getpid();
3000697c: eaffffff b 30006980 <getpid> <== NOT EXECUTED
30007bd4 <_chown_helper>:
const char *path,
uid_t owner,
gid_t group,
int follow_link
)
{
30007bd4: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30007bd8: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
30007bdc: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30007be0: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
30007be4: e1a08003 mov r8, r3 <== NOT EXECUTED
30007be8: e1a05822 lsr r5, r2, #16 <== NOT EXECUTED
30007bec: e1a07000 mov r7, r0 <== NOT EXECUTED
30007bf0: 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 ) )
30007bf4: eb003431 bl 30014cc0 <strlen> <== NOT EXECUTED 30007bf8: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30007bfc: e1a01000 mov r1, r0 <== NOT EXECUTED 30007c00: e3a02000 mov r2, #0 <== NOT EXECUTED 30007c04: e1a00007 mov r0, r7 <== NOT EXECUTED 30007c08: e1a03004 mov r3, r4 <== NOT EXECUTED 30007c0c: e58d8000 str r8, [sp] <== NOT EXECUTED 30007c10: eb000030 bl 30007cd8 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 30007c14: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30007c18: 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 ) )
30007c1c: 1a000008 bne 30007c44 <_chown_helper+0x70> <== NOT EXECUTED
return -1;
result = (*loc.ops->chown_h)( &loc, owner, group );
30007c20: e1a02005 mov r2, r5 <== NOT EXECUTED 30007c24: e1a00004 mov r0, r4 <== NOT EXECUTED 30007c28: e1a01006 mov r1, r6 <== NOT EXECUTED 30007c2c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30007c30: e1a0e00f mov lr, pc <== NOT EXECUTED 30007c34: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED 30007c38: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30007c3c: e1a00004 mov r0, r4 <== NOT EXECUTED 30007c40: eb000054 bl 30007d98 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
30007c44: e1a00005 mov r0, r5 <== NOT EXECUTED
30007c48: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30007c4c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30018154 <_execve>:
int _execve(
const char *path __attribute__((unused)),
char *const argv[] __attribute__((unused)),
char *const envp[] __attribute__((unused))
)
{
30018154: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30018158: ebffe61e bl 300119d8 <__errno> <== NOT EXECUTED 3001815c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30018160: e5803000 str r3, [r0] <== NOT EXECUTED
}
30018164: e3e00000 mvn r0, #0 <== NOT EXECUTED
30018168: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== 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
30025540 <_getpid_r>:
pid_t _getpid_r(
struct _reent *ptr __attribute__((unused))
)
{
return getpid();
}
30025540: e3a00001 mov r0, #1 <== NOT EXECUTED 30025544: 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
30025728 <_kill_r>:
struct _reent *ptr,
pid_t pid,
int sig
)
{
return killinfo( pid, sig, NULL );
30025728: e1a00001 mov r0, r1 <== NOT EXECUTED 3002572c: e1a01002 mov r1, r2 <== NOT EXECUTED 30025730: e3a02000 mov r2, #0 <== NOT EXECUTED 30025734: ea00002a b 300257e4 <killinfo> <== 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
3001696c <_lseek_r>:
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
3001696c: e1a00001 mov r0, r1 <== NOT EXECUTED 30016970: e1a01002 mov r1, r2 <== NOT EXECUTED 30016974: e1a02003 mov r2, r3 <== NOT EXECUTED 30016978: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3001697c: eaffffc1 b 30016888 <lseek> <== NOT EXECUTED
3000838c <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
3000838c: e1a00001 mov r0, r1 <== NOT EXECUTED 30008390: e1a01002 mov r1, r2 <== NOT EXECUTED 30008394: eaffffd9 b 30008300 <lstat> <== NOT EXECUTED
30016abc <_read_r>:
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
30016abc: e1a00001 mov r0, r1 <== NOT EXECUTED 30016ac0: e1a01002 mov r1, r2 <== NOT EXECUTED 30016ac4: e1a02003 mov r2, r3 <== NOT EXECUTED 30016ac8: eaffffd0 b 30016a10 <read> <== NOT EXECUTED
30016acc <_realloc_r>:
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
return realloc( ptr, size );
30016acc: e1a00001 mov r0, r1 <== NOT EXECUTED 30016ad0: e1a01002 mov r1, r2 <== NOT EXECUTED 30016ad4: ea000011 b 30016b20 <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: eb00362b bl 30017fd8 <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: eb003624 bl 30017fd8 <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: eb00292a bl 30014cac <__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: eb002164 bl 30011398 <__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: eb002ef1 bl 300149f8 <__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: eb002f84 bl 30014c58 <__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: eb000dc4 bl 3000c578 <_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
30009660 <adjtime>:
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
30009660: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
long adjustment;
/*
* Simple validations
*/
if ( !delta )
30009664: e2505000 subs r5, r0, #0 <== NOT EXECUTED
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
30009668: e1a04001 mov r4, r1 <== NOT EXECUTED
long adjustment;
/*
* Simple validations
*/
if ( !delta )
3000966c: 0a000003 beq 30009680 <adjtime+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
30009670: e5952004 ldr r2, [r5, #4] <== NOT EXECUTED 30009674: e59f30f0 ldr r3, [pc, #240] ; 3000976c <adjtime+0x10c> <== NOT EXECUTED 30009678: e1520003 cmp r2, r3 <== NOT EXECUTED 3000967c: 9a000004 bls 30009694 <adjtime+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009680: eb0021b3 bl 30011d54 <__errno> <== NOT EXECUTED 30009684: e3a03016 mov r3, #22 <== NOT EXECUTED 30009688: e5803000 str r3, [r0] <== NOT EXECUTED 3000968c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009690: ea000034 b 30009768 <adjtime+0x108> <== NOT EXECUTED
if ( olddelta ) {
30009694: e3510000 cmp r1, #0 <== NOT EXECUTED
olddelta->tv_sec = 0;
30009698: 13a03000 movne r3, #0 <== NOT EXECUTED 3000969c: 15813000 strne r3, [r1] <== NOT EXECUTED
olddelta->tv_usec = 0;
300096a0: 15813004 strne r3, [r1, #4] <== NOT EXECUTED
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
adjustment += delta->tv_usec;
300096a4: e895000c ldm r5, {r2, r3} <== NOT EXECUTED
300096a8: e59f10c0 ldr r1, [pc, #192] ; 30009770 <adjtime+0x110> <== NOT EXECUTED
300096ac: e0223291 mla r2, r1, r2, r3 <== NOT EXECUTED
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
300096b0: e59f30bc ldr r3, [pc, #188] ; 30009774 <adjtime+0x114> <== NOT EXECUTED 300096b4: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 300096b8: e1520003 cmp r2, r3 <== NOT EXECUTED 300096bc: 3a000028 bcc 30009764 <adjtime+0x104> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
300096c0: e59f30b0 ldr r3, [pc, #176] ; 30009778 <adjtime+0x118> <== NOT EXECUTED 300096c4: e5932000 ldr r2, [r3] <== NOT EXECUTED 300096c8: e2822001 add r2, r2, #1 <== NOT EXECUTED 300096cc: e5832000 str r2, [r3] <== NOT EXECUTED
* This prevents context switches while we are adjusting the TOD
*/
_Thread_Disable_dispatch();
_TOD_Get( &ts );
300096d0: e1a0000d mov r0, sp <== NOT EXECUTED 300096d4: eb00059f bl 3000ad58 <_TOD_Get> <== NOT EXECUTED
ts.tv_sec += delta->tv_sec;
300096d8: e5953000 ldr r3, [r5] <== NOT EXECUTED
300096dc: e89d0006 ldm sp, {r1, r2} <== NOT EXECUTED
300096e0: e0811003 add r1, r1, r3 <== NOT EXECUTED
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
300096e4: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 300096e8: e3a00ffa mov r0, #1000 ; 0x3e8 <== NOT EXECUTED 300096ec: e0232390 mla r3, r0, r3, r2 <== NOT EXECUTED
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
300096f0: e59f0084 ldr r0, [pc, #132] ; 3000977c <adjtime+0x11c> <== NOT EXECUTED 300096f4: ea000002 b 30009704 <adjtime+0xa4> <== NOT EXECUTED 300096f8: e2833331 add r3, r3, #-1006632960 ; 0xc4000000 <== NOT EXECUTED 300096fc: e2833865 add r3, r3, #6619136 ; 0x650000 <== NOT EXECUTED 30009700: e2833c36 add r3, r3, #13824 ; 0x3600 <== NOT EXECUTED 30009704: e1530000 cmp r3, r0 <== NOT EXECUTED 30009708: e1a02001 mov r2, r1 <== NOT EXECUTED 3000970c: e2811001 add r1, r1, #1 <== NOT EXECUTED 30009710: 8afffff8 bhi 300096f8 <adjtime+0x98> <== NOT EXECUTED
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
30009714: e59f0064 ldr r0, [pc, #100] ; 30009780 <adjtime+0x120> <== NOT EXECUTED 30009718: ea000002 b 30009728 <adjtime+0xc8> <== NOT EXECUTED
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000971c: e28335ee add r3, r3, #998244352 ; 0x3b800000 <== NOT EXECUTED 30009720: e283396b add r3, r3, #1753088 ; 0x1ac000 <== NOT EXECUTED 30009724: e2833c0a add r3, r3, #2560 ; 0xa00 <== NOT EXECUTED
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
30009728: e1530000 cmp r3, r0 <== NOT EXECUTED
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000972c: e1a01002 mov r1, r2 <== NOT EXECUTED 30009730: e2422001 sub r2, r2, #1 <== NOT EXECUTED
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
30009734: 9afffff8 bls 3000971c <adjtime+0xbc> <== NOT EXECUTED 30009738: e28d0008 add r0, sp, #8 <== NOT EXECUTED 3000973c: e5201008 str r1, [r0, #-8]! <== NOT EXECUTED
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec--;
}
_TOD_Set( &ts );
30009740: e1a0000d mov r0, sp <== NOT EXECUTED
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
30009744: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec--;
}
_TOD_Set( &ts );
30009748: eb0005a8 bl 3000adf0 <_TOD_Set> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000974c: eb000b13 bl 3000c3a0 <_Thread_Enable_dispatch> <== NOT EXECUTED
/* set the user's output */
if ( olddelta )
30009750: e3540000 cmp r4, #0 <== NOT EXECUTED
*olddelta = *delta;
return 0;
30009754: 01a00004 moveq r0, r4 <== NOT EXECUTED
_TOD_Set( &ts );
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
30009758: 0a000002 beq 30009768 <adjtime+0x108> <== NOT EXECUTED
*olddelta = *delta;
3000975c: e895000c ldm r5, {r2, r3} <== NOT EXECUTED
30009760: e884000c stm r4, {r2, r3} <== NOT EXECUTED
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
return 0;
30009764: e3a00000 mov r0, #0 <== NOT EXECUTED
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
30009768: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED
30009dac <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
30009dac: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
30009db0: e59f4198 ldr r4, [pc, #408] ; 30009f50 <aio_cancel+0x1a4> <== NOT EXECUTED
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
30009db4: e1a07000 mov r7, r0 <== NOT EXECUTED
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
30009db8: e1a00004 mov r0, r4 <== NOT EXECUTED
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
30009dbc: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
30009dc0: eb000413 bl 3000ae14 <pthread_mutex_lock> <== NOT EXECUTED
if (fcntl (fildes, F_GETFD) < 0) {
30009dc4: e1a00007 mov r0, r7 <== NOT EXECUTED 30009dc8: e3a01001 mov r1, #1 <== NOT EXECUTED 30009dcc: eb001a35 bl 300106a8 <fcntl> <== NOT EXECUTED 30009dd0: e3500000 cmp r0, #0 <== NOT EXECUTED 30009dd4: aa000004 bge 30009dec <aio_cancel+0x40> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
30009dd8: e1a00004 mov r0, r4 <== NOT EXECUTED 30009ddc: eb00042b bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EBADF);
30009de0: eb002706 bl 30013a00 <__errno> <== NOT EXECUTED 30009de4: e3a03009 mov r3, #9 <== NOT EXECUTED 30009de8: ea00002f b 30009eac <aio_cancel+0x100> <== NOT EXECUTED
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
30009dec: e3550000 cmp r5, #0 <== NOT EXECUTED 30009df0: 1a000026 bne 30009e90 <aio_cancel+0xe4> <== NOT EXECUTED
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
30009df4: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30009df8: e1a01007 mov r1, r7 <== NOT EXECUTED 30009dfc: e1a02005 mov r2, r5 <== NOT EXECUTED 30009e00: eb0000a3 bl 3000a094 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
30009e04: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30009e08: 1a000017 bne 30009e6c <aio_cancel+0xc0> <== NOT EXECUTED
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
30009e0c: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 30009e10: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED 30009e14: e1520003 cmp r2, r3 <== NOT EXECUTED 30009e18: 0a00003b beq 30009f0c <aio_cancel+0x160> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
30009e1c: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 30009e20: e1a01007 mov r1, r7 <== NOT EXECUTED 30009e24: e1a02006 mov r2, r6 <== NOT EXECUTED 30009e28: eb000099 bl 3000a094 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
30009e2c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30009e30: 0a000035 beq 30009f0c <aio_cancel+0x160> <== NOT EXECUTED
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
pthread_mutex_destroy (&r_chain->mutex);
30009e34: e285701c add r7, r5, #28 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
30009e38: eb000a07 bl 3000c65c <_Chain_Extract> <== NOT EXECUTED
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
30009e3c: e1a00005 mov r0, r5 <== NOT EXECUTED 30009e40: eb000173 bl 3000a414 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
30009e44: e1a00007 mov r0, r7 <== NOT EXECUTED 30009e48: eb000353 bl 3000ab9c <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
30009e4c: e1a00007 mov r0, r7 <== NOT EXECUTED 30009e50: eb000285 bl 3000a86c <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
30009e54: e1a00005 mov r0, r5 <== NOT EXECUTED 30009e58: ebfff415 bl 30006eb4 <free> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
30009e5c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009e60: eb00040a bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
30009e64: e1a05006 mov r5, r6 <== NOT EXECUTED 30009e68: ea000036 b 30009f48 <aio_cancel+0x19c> <== NOT EXECUTED
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
30009e6c: e286701c add r7, r6, #28 <== NOT EXECUTED 30009e70: e1a00007 mov r0, r7 <== NOT EXECUTED 30009e74: eb0003e6 bl 3000ae14 <pthread_mutex_lock> <== NOT EXECUTED 30009e78: e1a00006 mov r0, r6 <== NOT EXECUTED 30009e7c: eb0009f6 bl 3000c65c <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
30009e80: e1a00006 mov r0, r6 <== NOT EXECUTED 30009e84: eb000162 bl 3000a414 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
30009e88: e1a00007 mov r0, r7 <== NOT EXECUTED 30009e8c: ea00002a b 30009f3c <aio_cancel+0x190> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
30009e90: e5956000 ldr r6, [r5] <== NOT EXECUTED 30009e94: e1560007 cmp r6, r7 <== NOT EXECUTED 30009e98: 0a000006 beq 30009eb8 <aio_cancel+0x10c> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
30009e9c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009ea0: eb0003fa bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EINVAL);
30009ea4: eb0026d5 bl 30013a00 <__errno> <== NOT EXECUTED 30009ea8: e3a03016 mov r3, #22 <== NOT EXECUTED 30009eac: e5803000 str r3, [r0] <== NOT EXECUTED 30009eb0: e3e05000 mvn r5, #0 <== NOT EXECUTED 30009eb4: ea000023 b 30009f48 <aio_cancel+0x19c> <== NOT EXECUTED
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
30009eb8: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30009ebc: e1a01006 mov r1, r6 <== NOT EXECUTED 30009ec0: e3a02000 mov r2, #0 <== NOT EXECUTED 30009ec4: eb000072 bl 3000a094 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
30009ec8: e2507000 subs r7, r0, #0 <== NOT EXECUTED 30009ecc: 1a000012 bne 30009f1c <aio_cancel+0x170> <== NOT EXECUTED
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
30009ed0: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 30009ed4: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED 30009ed8: e1520003 cmp r2, r3 <== NOT EXECUTED 30009edc: 0a00000a beq 30009f0c <aio_cancel+0x160> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
30009ee0: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 30009ee4: e1a01006 mov r1, r6 <== NOT EXECUTED 30009ee8: e1a02007 mov r2, r7 <== NOT EXECUTED 30009eec: eb000068 bl 3000a094 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
30009ef0: e3500000 cmp r0, #0 <== NOT EXECUTED 30009ef4: 0affffe8 beq 30009e9c <aio_cancel+0xf0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
30009ef8: e1a01005 mov r1, r5 <== NOT EXECUTED 30009efc: e2800008 add r0, r0, #8 <== NOT EXECUTED 30009f00: eb000155 bl 3000a45c <rtems_aio_remove_req> <== NOT EXECUTED 30009f04: e1a05000 mov r5, r0 <== NOT EXECUTED 30009f08: ea00000c b 30009f40 <aio_cancel+0x194> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
30009f0c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009f10: eb0003de bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
30009f14: e3a05002 mov r5, #2 <== NOT EXECUTED 30009f18: ea00000a b 30009f48 <aio_cancel+0x19c> <== NOT EXECUTED
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
30009f1c: e287801c add r8, r7, #28 <== NOT EXECUTED 30009f20: e1a00008 mov r0, r8 <== NOT EXECUTED 30009f24: eb0003ba bl 3000ae14 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
30009f28: e1a01005 mov r1, r5 <== NOT EXECUTED 30009f2c: e2870008 add r0, r7, #8 <== NOT EXECUTED 30009f30: eb000149 bl 3000a45c <rtems_aio_remove_req> <== NOT EXECUTED 30009f34: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
30009f38: e1a00008 mov r0, r8 <== NOT EXECUTED 30009f3c: eb0003d3 bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
30009f40: e1a00004 mov r0, r4 <== NOT EXECUTED 30009f44: eb0003d1 bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
30009f48: e1a00005 mov r0, r5 <== NOT EXECUTED
30009f4c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30009f54 <aio_error>:
int
aio_error (const struct aiocb *aiocbp)
{
return aiocbp->error_code;
}
30009f54: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED 30009f58: e12fff1e bx lr <== NOT EXECUTED
30009f5c <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
30009f5c: e3500a02 cmp r0, #8192 ; 0x2000 <== NOT EXECUTED
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
30009f60: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30009f64: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
30009f68: 13a05016 movne r5, #22 <== NOT EXECUTED
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
30009f6c: 1a00000c bne 30009fa4 <aio_fsync+0x48> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
30009f70: e5910000 ldr r0, [r1] <== NOT EXECUTED 30009f74: e3a01003 mov r1, #3 <== NOT EXECUTED 30009f78: eb0019ca bl 300106a8 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
30009f7c: e2000003 and r0, r0, #3 <== NOT EXECUTED 30009f80: e2400001 sub r0, r0, #1 <== NOT EXECUTED 30009f84: e3500001 cmp r0, #1 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
30009f88: 83a05009 movhi r5, #9 <== NOT EXECUTED
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
30009f8c: 8a000004 bhi 30009fa4 <aio_fsync+0x48> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
30009f90: e3a00018 mov r0, #24 <== NOT EXECUTED 30009f94: ebfff52c bl 3000744c <malloc> <== NOT EXECUTED
if (req == NULL)
30009f98: e2503000 subs r3, r0, #0 <== NOT EXECUTED 30009f9c: 1a000007 bne 30009fc0 <aio_fsync+0x64> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
30009fa0: e3a0500b mov r5, #11 <== NOT EXECUTED 30009fa4: e3e03000 mvn r3, #0 <== NOT EXECUTED 30009fa8: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 30009fac: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 30009fb0: eb002692 bl 30013a00 <__errno> <== NOT EXECUTED 30009fb4: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
30009fb8: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009fbc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
30009fc0: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_SYNC;
30009fc4: e3a03003 mov r3, #3 <== NOT EXECUTED 30009fc8: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
30009fcc: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
30009fd0: ea00013b b 3000a4c4 <rtems_aio_enqueue> <== NOT EXECUTED
3000a6cc <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
3000a6cc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000a6d0: e3a01003 mov r1, #3 <== NOT EXECUTED
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
3000a6d4: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000a6d8: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000a6dc: eb0017f1 bl 300106a8 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000a6e0: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000a6e4: e3500002 cmp r0, #2 <== NOT EXECUTED 3000a6e8: 13500000 cmpne r0, #0 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000a6ec: 13a05009 movne r5, #9 <== NOT EXECUTED
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000a6f0: 1a00000d bne 3000a72c <aio_read+0x60> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
3000a6f4: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000a6f8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a6fc: 1a000007 bne 3000a720 <aio_read+0x54> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
3000a700: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000a704: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a708: ba000004 blt 3000a720 <aio_read+0x54> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
3000a70c: e3a00018 mov r0, #24 <== NOT EXECUTED 3000a710: ebfff34d bl 3000744c <malloc> <== NOT EXECUTED
if (req == NULL)
3000a714: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000a718: 1a00000a bne 3000a748 <aio_read+0x7c> <== NOT EXECUTED 3000a71c: ea000001 b 3000a728 <aio_read+0x5c> <== NOT EXECUTED
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
3000a720: e3a05016 mov r5, #22 <== NOT EXECUTED 3000a724: ea000000 b 3000a72c <aio_read+0x60> <== NOT EXECUTED
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000a728: e3a0500b mov r5, #11 <== NOT EXECUTED 3000a72c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000a730: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000a734: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000a738: eb0024b0 bl 30013a00 <__errno> <== NOT EXECUTED 3000a73c: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
3000a740: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a744: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000a748: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_READ;
3000a74c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a750: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000a754: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
3000a758: eaffff59 b 3000a4c4 <rtems_aio_enqueue> <== NOT EXECUTED
3000a75c <aio_return>:
ssize_t
aio_return (const struct aiocb *aiocbp)
{
return aiocbp->return_value;
}
3000a75c: e5900034 ldr r0, [r0, #52] ; 0x34 <== NOT EXECUTED 3000a760: e12fff1e bx lr <== NOT EXECUTED
300092b4 <aio_suspend>:
int aio_suspend(
const struct aiocb * const list[] __attribute__((unused)),
int nent __attribute__((unused)),
const struct timespec *timeout __attribute__((unused))
)
{
300092b4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
300092b8: eb0021c6 bl 300119d8 <__errno> <== NOT EXECUTED 300092bc: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300092c0: e5803000 str r3, [r0] <== NOT EXECUTED
}
300092c4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300092c8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a764 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
3000a764: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000a768: e3a01003 mov r1, #3 <== NOT EXECUTED
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
3000a76c: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000a770: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000a774: eb0017cb bl 300106a8 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000a778: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000a77c: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3000a780: e3500001 cmp r0, #1 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000a784: 83a05009 movhi r5, #9 <== NOT EXECUTED
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000a788: 8a00000d bhi 3000a7c4 <aio_write+0x60> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
3000a78c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000a790: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a794: 1a000007 bne 3000a7b8 <aio_write+0x54> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
3000a798: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000a79c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a7a0: ba000004 blt 3000a7b8 <aio_write+0x54> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
3000a7a4: e3a00018 mov r0, #24 <== NOT EXECUTED 3000a7a8: ebfff327 bl 3000744c <malloc> <== NOT EXECUTED
if (req == NULL)
3000a7ac: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000a7b0: 1a00000a bne 3000a7e0 <aio_write+0x7c> <== NOT EXECUTED 3000a7b4: ea000001 b 3000a7c0 <aio_write+0x5c> <== NOT EXECUTED
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
3000a7b8: e3a05016 mov r5, #22 <== NOT EXECUTED 3000a7bc: ea000000 b 3000a7c4 <aio_write+0x60> <== NOT EXECUTED
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000a7c0: e3a0500b mov r5, #11 <== NOT EXECUTED 3000a7c4: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000a7c8: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000a7cc: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000a7d0: eb00248a bl 30013a00 <__errno> <== NOT EXECUTED 3000a7d4: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
3000a7d8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a7dc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000a7e0: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_WRITE;
3000a7e4: e3a03002 mov r3, #2 <== NOT EXECUTED 3000a7e8: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000a7ec: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
3000a7f0: eaffff33 b 3000a4c4 <rtems_aio_enqueue> <== NOT EXECUTED
3000b264 <alarm>:
}
unsigned int alarm(
unsigned int seconds
)
{
3000b264: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000b268: e59f607c ldr r6, [pc, #124] ; 3000b2ec <alarm+0x88> <== NOT EXECUTED
}
unsigned int alarm(
unsigned int seconds
)
{
3000b26c: e1a05000 mov r5, r0 <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000b270: e596401c ldr r4, [r6, #28] <== NOT EXECUTED 3000b274: e3540000 cmp r4, #0 <== NOT EXECUTED 3000b278: 1a000005 bne 3000b294 <alarm+0x30> <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000b27c: e59f306c ldr r3, [pc, #108] ; 3000b2f0 <alarm+0x8c> <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000b280: e5864008 str r4, [r6, #8] <== NOT EXECUTED
the_watchdog->routine = routine;
3000b284: e586301c str r3, [r6, #28] <== NOT EXECUTED
the_watchdog->id = id;
3000b288: e5864020 str r4, [r6, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000b28c: e5864024 str r4, [r6, #36] ; 0x24 <== NOT EXECUTED 3000b290: ea00000e b 3000b2d0 <alarm+0x6c> <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
3000b294: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b298: eb0012bb bl 3000fd8c <_Watchdog_Remove> <== NOT EXECUTED
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
3000b29c: e2400002 sub r0, r0, #2 <== NOT EXECUTED 3000b2a0: e3500001 cmp r0, #1 <== NOT EXECUTED
unsigned int alarm(
unsigned int seconds
)
{
unsigned int remaining = 0;
3000b2a4: 83a04000 movhi r4, #0 <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
3000b2a8: 8a000008 bhi 3000b2d0 <alarm+0x6c> <== NOT EXECUTED
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
remaining = the_timer->initial -
((the_timer->stop_time - the_timer->start_time) / TOD_TICKS_PER_SECOND);
3000b2ac: e5962018 ldr r2, [r6, #24] <== NOT EXECUTED 3000b2b0: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
* The stop_time and start_time fields are snapshots of ticks since
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
remaining = the_timer->initial -
3000b2b4: e596400c ldr r4, [r6, #12] <== NOT EXECUTED
((the_timer->stop_time - the_timer->start_time) / TOD_TICKS_PER_SECOND);
3000b2b8: e0636002 rsb r6, r3, r2 <== NOT EXECUTED 3000b2bc: eb00095b bl 3000d830 <TOD_TICKS_PER_SECOND_method> <== NOT EXECUTED 3000b2c0: e1a01000 mov r1, r0 <== NOT EXECUTED 3000b2c4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b2c8: eb00377d bl 300190c4 <__aeabi_uidiv> <== NOT EXECUTED
* The stop_time and start_time fields are snapshots of ticks since
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
remaining = the_timer->initial -
3000b2cc: e0604004 rsb r4, r0, r4 <== NOT EXECUTED
((the_timer->stop_time - the_timer->start_time) / TOD_TICKS_PER_SECOND);
}
}
if ( seconds )
3000b2d0: e3550000 cmp r5, #0 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000b2d4: 159f1010 ldrne r1, [pc, #16] ; 3000b2ec <alarm+0x88> <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000b2d8: 159f0014 ldrne r0, [pc, #20] ; 3000b2f4 <alarm+0x90> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000b2dc: 1581500c strne r5, [r1, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000b2e0: 1b001251 blne 3000fc2c <_Watchdog_Insert> <== NOT EXECUTED
_Watchdog_Insert_seconds( the_timer, seconds );
return remaining;
}
3000b2e4: e1a00004 mov r0, r4 <== NOT EXECUTED
3000b2e8: e8bd8070 pop {r4, r5, r6, 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: eb002dc7 bl 30012f50 <__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: eb002db7 bl 30012f50 <__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
30007b68 <chmod>:
int chmod(
const char *path,
mode_t mode
)
{
30007b68: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30007b6c: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30007b70: e1a05001 mov r5, r1 <== NOT EXECUTED
30007b74: 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 );
30007b78: eb003450 bl 30014cc0 <strlen> <== NOT EXECUTED 30007b7c: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30007b80: e3a03001 mov r3, #1 <== NOT EXECUTED 30007b84: e1a01000 mov r1, r0 <== NOT EXECUTED 30007b88: e58d3000 str r3, [sp] <== NOT EXECUTED 30007b8c: e1a00006 mov r0, r6 <== NOT EXECUTED 30007b90: e3a02000 mov r2, #0 <== NOT EXECUTED 30007b94: e1a03004 mov r3, r4 <== NOT EXECUTED 30007b98: eb00004e bl 30007cd8 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
if ( status != 0 )
30007b9c: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30007ba0: 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 )
30007ba4: 1a000007 bne 30007bc8 <chmod+0x60> <== NOT EXECUTED
return -1;
result = (*loc.handlers->fchmod_h)( &loc, mode );
30007ba8: e1a01005 mov r1, r5 <== NOT EXECUTED 30007bac: e1a00004 mov r0, r4 <== NOT EXECUTED 30007bb0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30007bb4: e1a0e00f mov lr, pc <== NOT EXECUTED 30007bb8: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED 30007bbc: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30007bc0: e1a00004 mov r0, r4 <== NOT EXECUTED 30007bc4: eb000073 bl 30007d98 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
30007bc8: e1a00005 mov r0, r5 <== NOT EXECUTED
30007bcc: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30007bd0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30007c50 <chown>:
int chown(
const char *path,
uid_t owner,
gid_t group
)
{
30007c50: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 30007c54: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
return _chown_helper( path, owner, group, true );
30007c58: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 30007c5c: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED 30007c60: e3a03001 mov r3, #1 <== NOT EXECUTED 30007c64: eaffffda b 30007bd4 <_chown_helper> <== NOT EXECUTED
300092cc <clock_getcpuclockid>:
int clock_getcpuclockid(
pid_t pid,
clockid_t *clock_id
)
{
300092cc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
300092d0: eb0021c0 bl 300119d8 <__errno> <== NOT EXECUTED 300092d4: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300092d8: e5803000 str r3, [r0] <== NOT EXECUTED
}
300092dc: e3e00000 mvn r0, #0 <== NOT EXECUTED
300092e0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300092e4 <clock_getenable_attr>:
int clock_getenable_attr(
clockid_t clock_id,
int *attr
)
{
300092e4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
300092e8: eb0021ba bl 300119d8 <__errno> <== NOT EXECUTED 300092ec: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300092f0: e5803000 str r3, [r0] <== NOT EXECUTED
}
300092f4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300092f8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009b2c <clock_getres>:
int clock_getres(
clockid_t clock_id,
struct timespec *res
)
{
30009b2c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !res )
30009b30: e2514000 subs r4, r1, #0 <== NOT EXECUTED 30009b34: 1a000004 bne 30009b4c <clock_getres+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009b38: eb00219c bl 300121b0 <__errno> <== NOT EXECUTED
30009b3c: e3a03016 mov r3, #22 <== NOT EXECUTED
30009b40: e5803000 str r3, [r0] <== NOT EXECUTED
30009b44: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009b48: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
switch ( clock_id ) {
30009b4c: e2400001 sub r0, r0, #1 <== NOT EXECUTED 30009b50: e3500002 cmp r0, #2 <== NOT EXECUTED 30009b54: 8a000009 bhi 30009b80 <clock_getres+0x54> <== NOT EXECUTED
case CLOCK_REALTIME:
case CLOCK_PROCESS_CPUTIME:
case CLOCK_THREAD_CPUTIME:
if ( res ) {
res->tv_sec = rtems_configuration_get_microseconds_per_tick() /
30009b58: e59f3034 ldr r3, [pc, #52] ; 30009b94 <clock_getres+0x68> <== NOT EXECUTED 30009b5c: e59f1034 ldr r1, [pc, #52] ; 30009b98 <clock_getres+0x6c> <== NOT EXECUTED 30009b60: e593500c ldr r5, [r3, #12] <== NOT EXECUTED 30009b64: e1a00005 mov r0, r5 <== NOT EXECUTED 30009b68: eb004c3e bl 3001cc68 <__aeabi_uidiv> <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND;
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
30009b6c: e3a03ffa mov r3, #1000 ; 0x3e8 <== NOT EXECUTED 30009b70: e0050593 mul r5, r3, r5 <== NOT EXECUTED
case CLOCK_REALTIME:
case CLOCK_PROCESS_CPUTIME:
case CLOCK_THREAD_CPUTIME:
if ( res ) {
res->tv_sec = rtems_configuration_get_microseconds_per_tick() /
30009b74: e8840021 stm r4, {r0, r5} <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return 0;
30009b78: e3a00000 mov r0, #0 <== NOT EXECUTED
30009b7c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
}
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30009b80: eb00218a bl 300121b0 <__errno> <== NOT EXECUTED 30009b84: e3a03016 mov r3, #22 <== NOT EXECUTED 30009b88: e5803000 str r3, [r0] <== NOT EXECUTED 30009b8c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
30009b90: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
300094b4 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
300094b4: e1a03000 mov r3, r0 <== NOT EXECUTED
if ( !tp )
300094b8: e2510000 subs r0, r1, #0 <== NOT EXECUTED
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
300094bc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !tp )
300094c0: 1a000002 bne 300094d0 <clock_gettime+0x1c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
300094c4: eb002378 bl 300122ac <__errno> <== NOT EXECUTED 300094c8: e3a03016 mov r3, #22 <== NOT EXECUTED 300094cc: ea00000e b 3000950c <clock_gettime+0x58> <== NOT EXECUTED
if ( clock_id == CLOCK_REALTIME ) {
300094d0: e3530001 cmp r3, #1 <== NOT EXECUTED 300094d4: 1a000001 bne 300094e0 <clock_gettime+0x2c> <== NOT EXECUTED
_TOD_Get(tp);
300094d8: eb000736 bl 3000b1b8 <_TOD_Get> <== NOT EXECUTED 300094dc: ea000004 b 300094f4 <clock_gettime+0x40> <== NOT EXECUTED
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
300094e0: e3530004 cmp r3, #4 <== NOT EXECUTED 300094e4: 0a000001 beq 300094f0 <clock_gettime+0x3c> <== NOT EXECUTED
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
300094e8: e3530002 cmp r3, #2 <== NOT EXECUTED 300094ec: 1a000002 bne 300094fc <clock_gettime+0x48> <== NOT EXECUTED
_TOD_Get_uptime_as_timespec( tp );
300094f0: eb000747 bl 3000b214 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED
return 0;
300094f4: e3a00000 mov r0, #0 <== NOT EXECUTED
300094f8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
300094fc: e3530003 cmp r3, #3 <== NOT EXECUTED 30009500: 1a000004 bne 30009518 <clock_gettime+0x64> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009504: eb002368 bl 300122ac <__errno> <== NOT EXECUTED
30009508: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED
3000950c: e5803000 str r3, [r0] <== NOT EXECUTED
30009510: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009514: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
30009518: eb002363 bl 300122ac <__errno> <== NOT EXECUTED 3000951c: e3a03016 mov r3, #22 <== NOT EXECUTED 30009520: e5803000 str r3, [r0] <== NOT EXECUTED 30009524: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0;
}
30009528: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300092fc <clock_setenable_attr>:
int clock_setenable_attr(
clockid_t clock_id,
int attr
)
{
300092fc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009300: eb0021b4 bl 300119d8 <__errno> <== NOT EXECUTED 30009304: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009308: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000930c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009310: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000952c <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
3000952c: e1a03000 mov r3, r0 <== NOT EXECUTED
if ( !tp )
30009530: e2510000 subs r0, r1, #0 <== NOT EXECUTED
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
30009534: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !tp )
30009538: 0a000005 beq 30009554 <clock_settime+0x28> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
3000953c: e3530001 cmp r3, #1 <== NOT EXECUTED 30009540: 1a00000e bne 30009580 <clock_settime+0x54> <== NOT EXECUTED
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
30009544: e5902000 ldr r2, [r0] <== NOT EXECUTED 30009548: e59f3068 ldr r3, [pc, #104] ; 300095b8 <clock_settime+0x8c><== NOT EXECUTED 3000954c: e1520003 cmp r2, r3 <== NOT EXECUTED 30009550: 8a000002 bhi 30009560 <clock_settime+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009554: eb002354 bl 300122ac <__errno> <== NOT EXECUTED 30009558: e3a03016 mov r3, #22 <== NOT EXECUTED 3000955c: ea00000d b 30009598 <clock_settime+0x6c> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009560: e59f3054 ldr r3, [pc, #84] ; 300095bc <clock_settime+0x90> <== NOT EXECUTED 30009564: e5932000 ldr r2, [r3] <== NOT EXECUTED 30009568: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000956c: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Set( tp );
30009570: eb00073d bl 3000b26c <_TOD_Set> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009574: eb000ca8 bl 3000c81c <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
30009578: e3a00000 mov r0, #0 <== NOT EXECUTED
3000957c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
30009580: e3530002 cmp r3, #2 <== NOT EXECUTED 30009584: 0a000001 beq 30009590 <clock_settime+0x64> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
30009588: e3530003 cmp r3, #3 <== NOT EXECUTED 3000958c: 1a000004 bne 300095a4 <clock_settime+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009590: eb002345 bl 300122ac <__errno> <== NOT EXECUTED
30009594: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED
30009598: e5803000 str r3, [r0] <== NOT EXECUTED
3000959c: e3e00000 mvn r0, #0 <== NOT EXECUTED
300095a0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
300095a4: eb002340 bl 300122ac <__errno> <== NOT EXECUTED 300095a8: e3a03016 mov r3, #22 <== NOT EXECUTED 300095ac: e5803000 str r3, [r0] <== NOT EXECUTED 300095b0: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0;
}
300095b4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== 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: eb002575 bl 3000f280 <__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
3000e730 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3000e730: 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 ) )
3000e734: e3d27007 bics r7, r2, #7
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3000e738: e1a09000 mov r9, r0 3000e73c: e1a04001 mov r4, r1 3000e740: 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 ) )
3000e744: 0a000002 beq 3000e754 <devFS_evaluate_path+0x24>
rtems_set_errno_and_return_minus_one( EPERM );
3000e748: eb000956 bl 30010ca8 <__errno> <== NOT EXECUTED 3000e74c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000e750: ea000005 b 3000e76c <devFS_evaluate_path+0x3c> <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
3000e754: e5936000 ldr r6, [r3]
if (!device_name_table)
3000e758: e3560000 cmp r6, #0
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
3000e75c: 159fa094 ldrne sl, [pc, #148] ; 3000e7f8 <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)
3000e760: 1a00001c bne 3000e7d8 <devFS_evaluate_path+0xa8>
rtems_set_errno_and_return_minus_one( EFAULT );
3000e764: eb00094f bl 30010ca8 <__errno> <== NOT EXECUTED
3000e768: e3a0300e mov r3, #14 <== NOT EXECUTED
3000e76c: e5803000 str r3, [r0] <== NOT EXECUTED
3000e770: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000e774: 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)
3000e778: e5968000 ldr r8, [r6] 3000e77c: e3580000 cmp r8, #0
3000e780: 0a000012 beq 3000e7d0 <devFS_evaluate_path+0xa0>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
3000e784: e1a00009 mov r0, r9 3000e788: e1a01008 mov r1, r8 3000e78c: e1a02004 mov r2, r4 3000e790: eb000ea3 bl 30012224 <strncmp> 3000e794: e3500000 cmp r0, #0
3000e798: 1a00000c bne 3000e7d0 <devFS_evaluate_path+0xa0>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
3000e79c: e7d80004 ldrb r0, [r8, r4] 3000e7a0: e3500000 cmp r0, #0
3000e7a4: 1a000009 bne 3000e7d0 <devFS_evaluate_path+0xa0>
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
3000e7a8: e59f304c ldr r3, [pc, #76] ; 3000e7fc <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];
3000e7ac: e5856000 str r6, [r5]
pathloc->handlers = &devFS_file_handlers;
3000e7b0: e5853008 str r3, [r5, #8]
pathloc->ops = &devFS_ops;
3000e7b4: e59f3044 ldr r3, [pc, #68] ; 3000e800 <devFS_evaluate_path+0xd0> 3000e7b8: e585300c str r3, [r5, #12]
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000e7bc: e59f3040 ldr r3, [pc, #64] ; 3000e804 <devFS_evaluate_path+0xd4> 3000e7c0: e5933000 ldr r3, [r3] 3000e7c4: e5933028 ldr r3, [r3, #40] ; 0x28 3000e7c8: e5853010 str r3, [r5, #16]
return 0;
3000e7cc: 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++) {
3000e7d0: e2877001 add r7, r7, #1 3000e7d4: e2866014 add r6, r6, #20 3000e7d8: e59a3000 ldr r3, [sl] 3000e7dc: e1570003 cmp r7, r3
3000e7e0: 3affffe4 bcc 3000e778 <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 );
3000e7e4: eb00092f bl 30010ca8 <__errno> 3000e7e8: e3a03002 mov r3, #2 3000e7ec: e5803000 str r3, [r0] 3000e7f0: e3e00000 mvn r0, #0
}
3000e7f4: 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: eb001ae8 bl 3000e138 <_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: eb0025c1 bl 30010ca8 <__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: eb0029f6 bl 30011d9c <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: eb002598 bl 30010ca8 <__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: eb00258e bl 30010ca8 <__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: eb002a40 bl 30011f94 <strcmp> 30007690: e3500000 cmp r0, #0
30007694: 1a000003 bne 300076a8 <devFS_mknod+0xc4>
rtems_set_errno_and_return_minus_one( EEXIST );
30007698: eb002582 bl 30010ca8 <__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: eb002577 bl 30010ca8 <__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: eb002ab2 bl 300121c4 <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: eb000f34 bl 3000b490 <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: 1b001c12 blne 3000e814 <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
3001046c <device_ftruncate>:
rtems_libio_t *iop,
rtems_off64_t length
)
{
return 0;
}
3001046c: e3a00000 mov r0, #0 <== NOT EXECUTED 30010470: e12fff1e bx lr <== NOT EXECUTED
30010460 <device_lseek>:
rtems_off64_t offset,
int whence
)
{
return offset;
}
30010460: e1a00001 mov r0, r1 <== NOT EXECUTED 30010464: e1a01002 mov r1, r2 <== NOT EXECUTED 30010468: e12fff1e bx lr <== NOT EXECUTED
30010388 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
30010388: 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;
3001038c: e280c00c add ip, r0, #12 <== NOT EXECUTED
30010390: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
args.buffer = buffer; args.count = count;
30010394: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags;
30010398: 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;
3001039c: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
300103a0: e58d2014 str r2, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
300103a4: e3a02000 mov r2, #0 <== NOT EXECUTED
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
300103a8: e58d0000 str r0, [sp] <== NOT EXECUTED
args.offset = iop->offset; args.buffer = buffer;
300103ac: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
300103b0: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
status = rtems_io_read(
300103b4: e5930050 ldr r0, [r3, #80] ; 0x50 <== NOT EXECUTED 300103b8: e5931054 ldr r1, [r3, #84] ; 0x54 <== NOT EXECUTED 300103bc: e1a0200d mov r2, sp <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
300103c0: 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(
300103c4: eb0002a0 bl 30010e4c <rtems_io_read> <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
300103c8: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
300103cc: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
300103d0: 1b000310 blne 30011018 <rtems_deviceio_errno> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
300103d4: e28dd01c add sp, sp, #28 <== NOT EXECUTED
300103d8: 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: 1b000a65 blne 30009b0c <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: ea002b88 b 300120f4 <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: ea002bdc b 300120f4 <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: eb002c5b bl 300121d0 <__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: eb002c56 bl 300121d0 <__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: eb002c4b bl 300121d0 <__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: eb002c0d bl 300121d0 <__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: eb002c08 bl 300121d0 <__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: eb002bec bl 300121d0 <__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: eb002be7 bl 300121d0 <__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: eb002d17 bl 30012048 <__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: eb002cd1 bl 30012048 <__errno> 30006d00: e3a03086 mov r3, #134 ; 0x86 30006d04: ea000001 b 30006d10 <fcntl+0x16c>
ret = -1;
break;
default:
errno = EINVAL;
30006d08: eb002cce bl 30012048 <__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: eb002cc1 bl 30012048 <__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: eb002ca6 bl 30012048 <__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: eb002ca1 bl 30012048 <__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
3000fac0 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000fac0: e92d45f7 push {r0, r1, r2, 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) {
3000fac4: e59f53bc ldr r5, [pc, #956] ; 3000fe88 <fifo_open+0x3c8>
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000fac8: e1a08000 mov r8, r0
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
3000facc: e5954000 ldr r4, [r5]
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000fad0: e1a07001 mov r7, r1
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
3000fad4: e3540000 cmp r4, #0
3000fad8: 1a000012 bne 3000fb28 <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 );
3000fadc: e59f33a8 ldr r3, [pc, #936] ; 3000fe8c <fifo_open+0x3cc> 3000fae0: e1a01004 mov r1, r4 3000fae4: e5930000 ldr r0, [r3] 3000fae8: e1a02004 mov r2, r4 3000faec: ebffee77 bl 3000b4d0 <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
3000faf0: e5953000 ldr r3, [r5] 3000faf4: e3530000 cmp r3, #0
3000faf8: 1a000005 bne 3000fb14 <fifo_open+0x54>
sc = rtems_semaphore_create(
3000fafc: e59f038c ldr r0, [pc, #908] ; 3000fe90 <fifo_open+0x3d0> 3000fb00: e3a01001 mov r1, #1 3000fb04: e3a02054 mov r2, #84 ; 0x54 3000fb08: e58d5000 str r5, [sp] 3000fb0c: ebffeddd bl 3000b288 <rtems_semaphore_create> 3000fb10: e1a04000 mov r4, r0
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3000fb14: e59f3370 ldr r3, [pc, #880] ; 3000fe8c <fifo_open+0x3cc> 3000fb18: e5930000 ldr r0, [r3] 3000fb1c: ebffeeb1 bl 3000b5e8 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
3000fb20: e3540000 cmp r4, #0
3000fb24: 1a000006 bne 3000fb44 <fifo_open+0x84>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3000fb28: e59f3358 ldr r3, [pc, #856] ; 3000fe88 <fifo_open+0x3c8> 3000fb2c: e3a01000 mov r1, #0 3000fb30: e5930000 ldr r0, [r3] 3000fb34: e1a02001 mov r2, r1 3000fb38: ebffee64 bl 3000b4d0 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
3000fb3c: e2505000 subs r5, r0, #0
3000fb40: 0a000000 beq 3000fb48 <fifo_open+0x88>
return 0;
} else {
return -ENOMEM;
3000fb44: e3e0500b mvn r5, #11 <== NOT EXECUTED
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
if (err)
3000fb48: e2556000 subs r6, r5, #0
3000fb4c: 1a0000cb bne 3000fe80 <fifo_open+0x3c0>
return err;
pipe = *pipep;
3000fb50: e5984000 ldr r4, [r8]
if (pipe == NULL) {
3000fb54: e3540000 cmp r4, #0
3000fb58: 1a00004d bne 3000fc94 <fifo_open+0x1d4>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
3000fb5c: e3a00034 mov r0, #52 ; 0x34 3000fb60: ebffe26e bl 30008520 <malloc>
if (pipe == NULL)
3000fb64: e250a000 subs sl, r0, #0
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
3000fb68: e1a04000 mov r4, r0
if (pipe == NULL)
3000fb6c: 0a000046 beq 3000fc8c <fifo_open+0x1cc>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
3000fb70: e1a01005 mov r1, r5 3000fb74: e3a02034 mov r2, #52 ; 0x34 3000fb78: eb00123c bl 30014470 <memset>
pipe->Size = PIPE_BUF;
3000fb7c: e3a00c02 mov r0, #512 ; 0x200 3000fb80: e5840004 str r0, [r4, #4]
pipe->Buffer = malloc(pipe->Size);
3000fb84: ebffe265 bl 30008520 <malloc>
if (! pipe->Buffer)
3000fb88: 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);
3000fb8c: e5840000 str r0, [r4]
if (! pipe->Buffer)
3000fb90: 0a00003b beq 3000fc84 <fifo_open+0x1c4>
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
3000fb94: e59f62f8 ldr r6, [pc, #760] ; 3000fe94 <fifo_open+0x3d4>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
3000fb98: e59f02f8 ldr r0, [pc, #760] ; 3000fe98 <fifo_open+0x3d8>
rtems_build_name ('P', 'I', 'r', c),
3000fb9c: e5d63000 ldrb r3, [r6]
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
3000fba0: e1a01005 mov r1, r5 3000fba4: e1830000 orr r0, r3, r0 3000fba8: e1a02005 mov r2, r5 3000fbac: e284302c add r3, r4, #44 ; 0x2c 3000fbb0: eb00061e bl 30011430 <rtems_barrier_create> 3000fbb4: e3500000 cmp r0, #0
3000fbb8: 1a00002f bne 3000fc7c <fifo_open+0x1bc>
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),
3000fbbc: 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(
3000fbc0: e59f02d4 ldr r0, [pc, #724] ; 3000fe9c <fifo_open+0x3dc> 3000fbc4: e1a01005 mov r1, r5 3000fbc8: e1830000 orr r0, r3, r0 3000fbcc: e1a02005 mov r2, r5 3000fbd0: e2843030 add r3, r4, #48 ; 0x30 3000fbd4: eb000615 bl 30011430 <rtems_barrier_create> 3000fbd8: e3500000 cmp r0, #0
3000fbdc: 1a000024 bne 3000fc74 <fifo_open+0x1b4>
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,
3000fbe0: 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(
3000fbe4: e59f02b4 ldr r0, [pc, #692] ; 3000fea0 <fifo_open+0x3e0> 3000fbe8: e2842028 add r2, r4, #40 ; 0x28 3000fbec: e58d2000 str r2, [sp] 3000fbf0: e1830000 orr r0, r3, r0 3000fbf4: e3a01001 mov r1, #1 3000fbf8: e3a02010 mov r2, #16 3000fbfc: e1a03005 mov r3, r5 3000fc00: ebffeda0 bl 3000b288 <rtems_semaphore_create> 3000fc04: e3500000 cmp r0, #0
3000fc08: 1a000017 bne 3000fc6c <fifo_open+0x1ac>
/* Set barriers to be interruptible by signals. */
static void pipe_interruptible(pipe_control_t *pipe)
{
Objects_Locations location;
_Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state
3000fc0c: e28d5004 add r5, sp, #4
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
3000fc10: e594102c ldr r1, [r4, #44] ; 0x2c 3000fc14: e1a02005 mov r2, r5 3000fc18: e59f0284 ldr r0, [pc, #644] ; 3000fea4 <fifo_open+0x3e4> 3000fc1c: ebfff3d9 bl 3000cb88 <_Objects_Get>
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
3000fc20: e590304c ldr r3, [r0, #76] ; 0x4c 3000fc24: e3833201 orr r3, r3, #268435456 ; 0x10000000 3000fc28: e580304c str r3, [r0, #76] ; 0x4c
_Thread_Enable_dispatch();
3000fc2c: ebfff6e7 bl 3000d7d0 <_Thread_Enable_dispatch> 3000fc30: e1a02005 mov r2, r5 3000fc34: e5941030 ldr r1, [r4, #48] ; 0x30 3000fc38: e59f0264 ldr r0, [pc, #612] ; 3000fea4 <fifo_open+0x3e4> 3000fc3c: ebfff3d1 bl 3000cb88 <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
3000fc40: e590304c ldr r3, [r0, #76] ; 0x4c 3000fc44: e3833201 orr r3, r3, #268435456 ; 0x10000000 3000fc48: e580304c str r3, [r0, #76] ; 0x4c
_Thread_Enable_dispatch();
3000fc4c: ebfff6df bl 3000d7d0 <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
3000fc50: e5d63000 ldrb r3, [r6] 3000fc54: e353007a cmp r3, #122 ; 0x7a 3000fc58: e2832001 add r2, r3, #1
c = 'a';
3000fc5c: 03a03061 moveq r3, #97 ; 0x61
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
3000fc60: e5c62000 strb r2, [r6]
c = 'a';
3000fc64: 05c63000 strbeq r3, [r6] 3000fc68: ea000009 b 3000fc94 <fifo_open+0x1d4>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
3000fc6c: e59a0030 ldr r0, [sl, #48] ; 0x30 <== NOT EXECUTED 3000fc70: eb00061e bl 300114f0 <rtems_barrier_delete> <== NOT EXECUTED
err_wbar: rtems_barrier_delete(pipe->readBarrier);
3000fc74: e59a002c ldr r0, [sl, #44] ; 0x2c <== NOT EXECUTED 3000fc78: eb00061c bl 300114f0 <rtems_barrier_delete> <== NOT EXECUTED
err_rbar: free(pipe->Buffer);
3000fc7c: e59a0000 ldr r0, [sl] <== NOT EXECUTED 3000fc80: ebffe049 bl 30007dac <free> <== NOT EXECUTED
err_buf: free(pipe);
3000fc84: e1a0000a mov r0, sl <== NOT EXECUTED 3000fc88: ebffe047 bl 30007dac <free> <== NOT EXECUTED
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
3000fc8c: e3e0600b mvn r6, #11 <== NOT EXECUTED 3000fc90: ea00000d b 3000fccc <fifo_open+0x20c> <== NOT EXECUTED
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
3000fc94: e3a01000 mov r1, #0 3000fc98: e5940028 ldr r0, [r4, #40] ; 0x28 3000fc9c: e1a02001 mov r2, r1 3000fca0: ebffee0a bl 3000b4d0 <rtems_semaphore_obtain>
err = -EINTR;
if (*pipep == NULL) {
3000fca4: e5983000 ldr r3, [r8]
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
3000fca8: e3500000 cmp r0, #0 3000fcac: 03a06000 moveq r6, #0 3000fcb0: 13e06003 mvnne r6, #3
if (*pipep == NULL) {
3000fcb4: e3530000 cmp r3, #0
3000fcb8: 1a000003 bne 3000fccc <fifo_open+0x20c>
if (err)
3000fcbc: e3560000 cmp r6, #0
pipe_free(pipe);
else
*pipep = pipe;
3000fcc0: 05884000 streq r4, [r8]
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
pipe_free(pipe);
3000fcc4: 11a00004 movne r0, r4 3000fcc8: 1bffff43 blne 3000f9dc <pipe_free>
else
*pipep = pipe;
}
out:
pipe_unlock();
3000fccc: ebffff3e bl 3000f9cc <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
3000fcd0: e3560000 cmp r6, #0
3000fcd4: 1a000069 bne 3000fe80 <fifo_open+0x3c0>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
3000fcd8: e5973014 ldr r3, [r7, #20]
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
3000fcdc: e5984000 ldr r4, [r8]
switch (LIBIO_ACCMODE(iop)) {
3000fce0: e2033006 and r3, r3, #6 3000fce4: e3530004 cmp r3, #4
3000fce8: 0a000024 beq 3000fd80 <fifo_open+0x2c0>
3000fcec: e3530006 cmp r3, #6
3000fcf0: 0a000047 beq 3000fe14 <fifo_open+0x354>
3000fcf4: e3530002 cmp r3, #2
3000fcf8: 1a000059 bne 3000fe64 <fifo_open+0x3a4>
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
3000fcfc: e5943020 ldr r3, [r4, #32] 3000fd00: e2833001 add r3, r3, #1 3000fd04: e5843020 str r3, [r4, #32]
if (pipe->Readers ++ == 0)
3000fd08: e5943010 ldr r3, [r4, #16] 3000fd0c: e2832001 add r2, r3, #1 3000fd10: e3530000 cmp r3, #0 3000fd14: e5842010 str r2, [r4, #16]
PIPE_WAKEUPWRITERS(pipe);
3000fd18: 05940030 ldreq r0, [r4, #48] ; 0x30 3000fd1c: 028d1008 addeq r1, sp, #8 3000fd20: 0b00061a bleq 30011590 <rtems_barrier_release>
if (pipe->Writers == 0) {
3000fd24: e5943014 ldr r3, [r4, #20] 3000fd28: e3530000 cmp r3, #0
3000fd2c: 1a00004c bne 3000fe64 <fifo_open+0x3a4>
/* Not an error */
if (LIBIO_NODELAY(iop))
3000fd30: e5973014 ldr r3, [r7, #20] 3000fd34: e3130001 tst r3, #1
3000fd38: 1a000049 bne 3000fe64 <fifo_open+0x3a4>
break;
prevCounter = pipe->writerCounter;
3000fd3c: e5945024 ldr r5, [r4, #36] ; 0x24 <== NOT EXECUTED
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
3000fd40: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000fd44: ebffee27 bl 3000b5e8 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
3000fd48: e3a01000 mov r1, #0 <== NOT EXECUTED 3000fd4c: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED 3000fd50: eb000624 bl 300115e8 <rtems_barrier_wait> <== NOT EXECUTED 3000fd54: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000fd58: 1a000044 bne 3000fe70 <fifo_open+0x3b0> <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
3000fd5c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000fd60: e1a02001 mov r2, r1 <== NOT EXECUTED 3000fd64: ebffedd9 bl 3000b4d0 <rtems_semaphore_obtain> <== NOT EXECUTED 3000fd68: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fd6c: 1a00003f bne 3000fe70 <fifo_open+0x3b0> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
3000fd70: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3000fd74: e1550003 cmp r5, r3 <== NOT EXECUTED 3000fd78: 0afffff0 beq 3000fd40 <fifo_open+0x280> <== NOT EXECUTED 3000fd7c: ea000038 b 3000fe64 <fifo_open+0x3a4> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
3000fd80: e5943024 ldr r3, [r4, #36] ; 0x24 3000fd84: e2833001 add r3, r3, #1 3000fd88: e5843024 str r3, [r4, #36] ; 0x24
if (pipe->Writers ++ == 0)
3000fd8c: e5943014 ldr r3, [r4, #20] 3000fd90: e2832001 add r2, r3, #1 3000fd94: e3530000 cmp r3, #0 3000fd98: e5842014 str r2, [r4, #20]
PIPE_WAKEUPREADERS(pipe);
3000fd9c: 0594002c ldreq r0, [r4, #44] ; 0x2c 3000fda0: 028d1008 addeq r1, sp, #8 3000fda4: 0b0005f9 bleq 30011590 <rtems_barrier_release>
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
3000fda8: e5943010 ldr r3, [r4, #16] 3000fdac: e3530000 cmp r3, #0
3000fdb0: 1a00002b bne 3000fe64 <fifo_open+0x3a4>
3000fdb4: e5973014 ldr r3, [r7, #20] <== NOT EXECUTED 3000fdb8: e3130001 tst r3, #1 <== NOT EXECUTED
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
3000fdbc: 05945020 ldreq r5, [r4, #32] <== NOT EXECUTED
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
3000fdc0: 0a000003 beq 3000fdd4 <fifo_open+0x314> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
3000fdc4: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000fdc8: ebffee06 bl 3000b5e8 <rtems_semaphore_release> <== NOT EXECUTED
err = -ENXIO;
3000fdcc: e3e06005 mvn r6, #5 <== NOT EXECUTED
goto out_error;
3000fdd0: ea000027 b 3000fe74 <fifo_open+0x3b4> <== NOT EXECUTED
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
3000fdd4: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000fdd8: ebffee02 bl 3000b5e8 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
3000fddc: e3a01000 mov r1, #0 <== NOT EXECUTED 3000fde0: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 3000fde4: eb0005ff bl 300115e8 <rtems_barrier_wait> <== NOT EXECUTED 3000fde8: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000fdec: 1a00001f bne 3000fe70 <fifo_open+0x3b0> <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
3000fdf0: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3000fdf4: e1a02001 mov r2, r1 <== NOT EXECUTED 3000fdf8: ebffedb4 bl 3000b4d0 <rtems_semaphore_obtain> <== NOT EXECUTED 3000fdfc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fe00: 1a00001a bne 3000fe70 <fifo_open+0x3b0> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
3000fe04: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000fe08: e1550003 cmp r5, r3 <== NOT EXECUTED 3000fe0c: 0afffff0 beq 3000fdd4 <fifo_open+0x314> <== NOT EXECUTED 3000fe10: ea000013 b 3000fe64 <fifo_open+0x3a4> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
3000fe14: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000fe18: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000fe1c: e5843020 str r3, [r4, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
3000fe20: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 3000fe24: e2832001 add r2, r3, #1 <== NOT EXECUTED 3000fe28: e3530000 cmp r3, #0 <== NOT EXECUTED 3000fe2c: e5842010 str r2, [r4, #16] <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
3000fe30: 05940030 ldreq r0, [r4, #48] ; 0x30 <== NOT EXECUTED 3000fe34: 028d1008 addeq r1, sp, #8 <== NOT EXECUTED 3000fe38: 0b0005d4 bleq 30011590 <rtems_barrier_release> <== NOT EXECUTED
pipe->writerCounter ++;
3000fe3c: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3000fe40: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000fe44: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
3000fe48: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000fe4c: e2832001 add r2, r3, #1 <== NOT EXECUTED 3000fe50: e3530000 cmp r3, #0 <== NOT EXECUTED 3000fe54: e5842014 str r2, [r4, #20] <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
3000fe58: 0594002c ldreq r0, [r4, #44] ; 0x2c <== NOT EXECUTED 3000fe5c: 028d1008 addeq r1, sp, #8 <== NOT EXECUTED 3000fe60: 0b0005ca bleq 30011590 <rtems_barrier_release> <== NOT EXECUTED
break;
}
PIPE_UNLOCK(pipe);
3000fe64: e5940028 ldr r0, [r4, #40] ; 0x28 3000fe68: ebffedde bl 3000b5e8 <rtems_semaphore_release>
return 0;
3000fe6c: ea000003 b 3000fe80 <fifo_open+0x3c0>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
3000fe70: e3e06003 mvn r6, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
3000fe74: e1a00008 mov r0, r8 <== NOT EXECUTED 3000fe78: e1a01007 mov r1, r7 <== NOT EXECUTED 3000fe7c: ebfffee3 bl 3000fa10 <pipe_release> <== NOT EXECUTED
return err; }
3000fe80: e1a00006 mov r0, r6
3000fe84: e8bd85fe pop {r1, 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
30009314 <fork>:
#include <sys/types.h>
#include <errno.h>
#include <rtems/seterr.h>
int fork( void )
{
30009314: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009318: eb0021ae bl 300119d8 <__errno> <== NOT EXECUTED 3000931c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009320: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009324: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009328: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== 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: eb002c8a bl 30012048 <__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: eb002c85 bl 30012048 <__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: eb002c58 bl 30012048 <__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: eb0012e4 bl 3000aea4 <_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
300167ec <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
300167ec: e92d4030 push {r4, r5, lr}
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
300167f0: e2515000 subs r5, r1, #0
300167f4: 1a000002 bne 30016804 <fstat+0x18>
rtems_set_errno_and_return_minus_one( EFAULT );
300167f8: ebffea31 bl 300110c4 <__errno> <== NOT EXECUTED 300167fc: e3a0300e mov r3, #14 <== NOT EXECUTED 30016800: ea00000c b 30016838 <fstat+0x4c> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
30016804: e59f3060 ldr r3, [pc, #96] ; 3001686c <fstat+0x80> 30016808: e5933000 ldr r3, [r3] 3001680c: e1500003 cmp r0, r3
30016810: 2a000006 bcs 30016830 <fstat+0x44>
30016814: e59f3054 ldr r3, [pc, #84] ; 30016870 <fstat+0x84> 30016818: e3a04038 mov r4, #56 ; 0x38 3001681c: e5933000 ldr r3, [r3] 30016820: e0243490 mla r4, r0, r4, r3
rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop);
30016824: e5943014 ldr r3, [r4, #20] 30016828: e3130c01 tst r3, #256 ; 0x100
3001682c: 1a000004 bne 30016844 <fstat+0x58>
30016830: ebffea23 bl 300110c4 <__errno> <== NOT EXECUTED
30016834: e3a03009 mov r3, #9 <== NOT EXECUTED
30016838: e5803000 str r3, [r0] <== NOT EXECUTED
3001683c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30016840: 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) );
30016844: e1a00005 mov r0, r5 30016848: e3a01000 mov r1, #0 3001684c: e3a02048 mov r2, #72 ; 0x48 30016850: ebffec80 bl 30011a58 <memset>
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
30016854: e5943020 ldr r3, [r4, #32] 30016858: e2840018 add r0, r4, #24 3001685c: e1a01005 mov r1, r5 30016860: e1a0e00f mov lr, pc 30016864: e593f018 ldr pc, [r3, #24]
}
30016868: 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: eb002bf2 bl 30012048 <__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: eb002bed bl 30012048 <__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
3000db60 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
3000db60: e92d4070 push {r4, r5, r6, lr}
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000db64: e59f30b8 ldr r3, [pc, #184] ; 3000dc24 <ftruncate+0xc4>
int ftruncate(
int fd,
off_t length
)
{
3000db68: e24dd014 sub sp, sp, #20
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000db6c: e5933000 ldr r3, [r3]
int ftruncate(
int fd,
off_t length
)
{
3000db70: e1a05001 mov r5, r1
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000db74: e1500003 cmp r0, r3
int ftruncate(
int fd,
off_t length
)
{
3000db78: e1a06002 mov r6, r2
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000db7c: 2a000006 bcs 3000db9c <ftruncate+0x3c>
iop = rtems_libio_iop( fd );
3000db80: e59f30a0 ldr r3, [pc, #160] ; 3000dc28 <ftruncate+0xc8> 3000db84: e3a04038 mov r4, #56 ; 0x38 3000db88: e5933000 ldr r3, [r3] 3000db8c: e0243490 mla r4, r0, r4, r3
rtems_libio_check_is_open(iop);
3000db90: e5943014 ldr r3, [r4, #20] 3000db94: e3130c01 tst r3, #256 ; 0x100
3000db98: 1a000002 bne 3000dba8 <ftruncate+0x48>
3000db9c: eb000d48 bl 300110c4 <__errno> <== NOT EXECUTED 3000dba0: e3a03009 mov r3, #9 <== NOT EXECUTED 3000dba4: ea000013 b 3000dbf8 <ftruncate+0x98> <== NOT EXECUTED
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
3000dba8: e1a0c00d mov ip, sp
3000dbac: e284e018 add lr, r4, #24
3000dbb0: e8be000f ldm lr!, {r0, r1, r2, r3}
3000dbb4: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000dbb8: e59e3000 ldr r3, [lr]
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
3000dbbc: e1a0000d mov r0, sp
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
3000dbc0: e58c3000 str r3, [ip]
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
3000dbc4: e59d300c ldr r3, [sp, #12] 3000dbc8: e1a0e00f mov lr, pc 3000dbcc: e593f010 ldr pc, [r3, #16] 3000dbd0: e3500001 cmp r0, #1
3000dbd4: 1a000002 bne 3000dbe4 <ftruncate+0x84>
rtems_set_errno_and_return_minus_one( EISDIR );
3000dbd8: eb000d39 bl 300110c4 <__errno> <== NOT EXECUTED 3000dbdc: e3a03015 mov r3, #21 <== NOT EXECUTED 3000dbe0: ea000004 b 3000dbf8 <ftruncate+0x98> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000dbe4: e5943014 ldr r3, [r4, #20] 3000dbe8: e3130004 tst r3, #4
3000dbec: 1a000004 bne 3000dc04 <ftruncate+0xa4>
3000dbf0: eb000d33 bl 300110c4 <__errno> <== NOT EXECUTED 3000dbf4: e3a03016 mov r3, #22 <== NOT EXECUTED 3000dbf8: e5803000 str r3, [r0] <== NOT EXECUTED 3000dbfc: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000dc00: ea000005 b 3000dc1c <ftruncate+0xbc> <== NOT EXECUTED
return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
3000dc04: e5943020 ldr r3, [r4, #32] 3000dc08: e1a00004 mov r0, r4 3000dc0c: e1a01005 mov r1, r5 3000dc10: e1a02006 mov r2, r6 3000dc14: e1a0e00f mov lr, pc 3000dc18: e593f020 ldr pc, [r3, #32]
}
3000dc1c: e28dd014 add sp, sp, #20
3000dc20: 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: eb002b29 bl 300110d0 <__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
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: eb002e66 bl 30012850 <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: eb002c3e bl 30011fbc <__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: eb0033a4 bl 30013d94 <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: eb002c71 bl 300120f4 <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: eb002c6b bl 300120f4 <fclose> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30006f44: eb002c1c bl 30011fbc <__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
30009248 <getitimer>:
int getitimer(
int which,
struct itimerval *value
)
{
if ( !value )
30009248: e3510000 cmp r1, #0 <== NOT EXECUTED
int getitimer(
int which,
struct itimerval *value
)
{
3000924c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !value )
30009250: 1a000002 bne 30009260 <getitimer+0x18> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
30009254: eb00218e bl 30011894 <__errno> <== NOT EXECUTED 30009258: e3a0300e mov r3, #14 <== NOT EXECUTED 3000925c: ea000006 b 3000927c <getitimer+0x34> <== NOT EXECUTED
switch ( which ) {
30009260: e3500002 cmp r0, #2 <== NOT EXECUTED 30009264: 8a000002 bhi 30009274 <getitimer+0x2c> <== NOT EXECUTED
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
30009268: eb002189 bl 30011894 <__errno> <== NOT EXECUTED 3000926c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009270: ea000001 b 3000927c <getitimer+0x34> <== NOT EXECUTED
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
30009274: eb002186 bl 30011894 <__errno> <== NOT EXECUTED 30009278: e3a03016 mov r3, #22 <== NOT EXECUTED 3000927c: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009280: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009284: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== 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: eb00360a bl 30014164 <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
300064f0 <getpagesize>:
* return a reasonable value.
*/
int getpagesize(void)
{
return PAGE_SIZE;
}
300064f0: e3a00a01 mov r0, #4096 ; 0x1000 <== NOT EXECUTED 300064f4: e12fff1e bx lr <== 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: eb002e31 bl 30012850 <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: eb002c09 bl 30011fbc <__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: eb00336f bl 30013d94 <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: eb002c3c bl 300120f4 <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: eb002c36 bl 300120f4 <fclose> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30007018: eb002be7 bl 30011fbc <__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: eb002b4e bl 30011340 <__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: eb003923 bl 30014ab8 <__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: eb002b3c bl 30011340 <__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: eb002b37 bl 30011340 <__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: eb002b5a bl 300110c4 <__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: eb000f9f bl 3000a1fc <_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: eb003954 bl 300148e8 <__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
30010474 <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 )
30010474: e5903018 ldr r3, [r0, #24]
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
30010478: 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 )
3001047c: e593304c ldr r3, [r3, #76] ; 0x4c 30010480: e3530001 cmp r3, #1
30010484: 1a000005 bne 300104a0 <imfs_dir_open+0x2c>
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
30010488: e3a03000 mov r3, #0 3001048c: e3a04000 mov r4, #0 30010490: e580300c str r3, [r0, #12] 30010494: e5804010 str r4, [r0, #16]
return 0;
30010498: e3a00000 mov r0, #0
3001049c: 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 */
300104a0: e3e00000 mvn r0, #0 <== NOT EXECUTED
iop->offset = 0;
return 0;
}
300104a4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300106d0 <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
300106d0: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
300106d4: e5914000 ldr r4, [r1]
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
300106d8: 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 );
300106dc: e2843054 add r3, r4, #84 ; 0x54 300106e0: e1520003 cmp r2, r3
300106e4: 0a000002 beq 300106f4 <imfs_dir_rmnod+0x24>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
300106e8: eb000275 bl 300110c4 <__errno> <== NOT EXECUTED 300106ec: e3a0305a mov r3, #90 ; 0x5a <== NOT EXECUTED 300106f0: ea000008 b 30010718 <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 )
300106f4: e5913010 ldr r3, [r1, #16] 300106f8: e593301c ldr r3, [r3, #28] 300106fc: e1530004 cmp r3, r4
30010700: 0a000002 beq 30010710 <imfs_dir_rmnod+0x40>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
30010704: e594505c ldr r5, [r4, #92] ; 0x5c 30010708: e3550000 cmp r5, #0
3001070c: 0a000004 beq 30010724 <imfs_dir_rmnod+0x54>
rtems_set_errno_and_return_minus_one( EBUSY );
30010710: eb00026b bl 300110c4 <__errno> <== NOT EXECUTED
30010714: e3a03010 mov r3, #16 <== NOT EXECUTED
30010718: e5803000 str r3, [r0] <== NOT EXECUTED
3001071c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30010720: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
IMFS_create_orphan( the_jnode );
30010724: e1a00004 mov r0, r4 30010728: ebfff481 bl 3000d934 <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
3001072c: e1a00004 mov r0, r4 30010730: ebfff490 bl 3000d978 <IMFS_check_node_remove>
return 0;
30010734: e1a00005 mov r0, r5
}
30010738: 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: eb002e95 bl 30012850 <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: eb002e90 bl 30012850 <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: eb002eb4 bl 300128f4 <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: eb002cb2 bl 300120f4 <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: eb002e86 bl 30012850 <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: eb002e81 bl 30012850 <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: eb002ea5 bl 300128f4 <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: ea002ca2 b 300120f4 <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
300257e4 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
300257e4: e92d47f7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, lr}
300257e8: e1a05000 mov r5, r0
300257ec: e1a04001 mov r4, r1
300257f0: e1a06002 mov r6, r2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
300257f4: ebffff4f bl 30025538 <getpid> 300257f8: e1550000 cmp r5, r0
300257fc: 0a000002 beq 3002580c <killinfo+0x28>
rtems_set_errno_and_return_minus_one( ESRCH );
30025800: ebffc27d bl 300161fc <__errno> <== NOT EXECUTED 30025804: e3a03003 mov r3, #3 <== NOT EXECUTED 30025808: ea00007c b 30025a00 <killinfo+0x21c> <== NOT EXECUTED
/*
* Validate the signal passed.
*/
if ( !sig )
3002580c: e3540000 cmp r4, #0
30025810: 0a000002 beq 30025820 <killinfo+0x3c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
30025814: e2445001 sub r5, r4, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
30025818: e355001f cmp r5, #31
3002581c: 9a000002 bls 3002582c <killinfo+0x48>
rtems_set_errno_and_return_minus_one( EINVAL );
30025820: ebffc275 bl 300161fc <__errno> <== NOT EXECUTED 30025824: e3a03016 mov r3, #22 <== NOT EXECUTED 30025828: ea000074 b 30025a00 <killinfo+0x21c> <== NOT EXECUTED
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
3002582c: e59f3204 ldr r3, [pc, #516] ; 30025a38 <killinfo+0x254> 30025830: e3a0200c mov r2, #12 30025834: e0233492 mla r3, r2, r4, r3 30025838: e5933008 ldr r3, [r3, #8] 3002583c: e3530001 cmp r3, #1
30025840: 0a00007a beq 30025a30 <killinfo+0x24c> /* * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
30025844: e3540008 cmp r4, #8 30025848: 13540004 cmpne r4, #4
3002584c: 0a000001 beq 30025858 <killinfo+0x74>
30025850: e354000b cmp r4, #11
30025854: 1a000003 bne 30025868 <killinfo+0x84>
return pthread_kill( pthread_self(), sig );
30025858: eb0000ff bl 30025c5c <pthread_self> <== NOT EXECUTED 3002585c: e1a01004 mov r1, r4 <== NOT EXECUTED 30025860: eb0000cc bl 30025b98 <pthread_kill> <== NOT EXECUTED 30025864: ea000072 b 30025a34 <killinfo+0x250> <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
30025868: e3a03001 mov r3, #1
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
3002586c: e3560000 cmp r6, #0
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
30025870: e58d3004 str r3, [sp, #4]
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
30025874: e58d4000 str r4, [sp] 30025878: e1a05513 lsl r5, r3, r5
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
3002587c: 15963000 ldrne r3, [r6]
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
30025880: 058d6008 streq r6, [sp, #8]
} else {
siginfo->si_value = *value;
30025884: 158d3008 strne r3, [sp, #8] 30025888: e59f31ac ldr r3, [pc, #428] ; 30025a3c <killinfo+0x258> 3002588c: e5932000 ldr r2, [r3] 30025890: e2822001 add r2, r2, #1 30025894: e5832000 str r2, [r3]
/*
* Is the currently executing thread interested? If so then it will
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Thread_Executing;
30025898: e59f31a0 ldr r3, [pc, #416] ; 30025a40 <killinfo+0x25c> 3002589c: e5930004 ldr r0, [r3, #4]
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
300258a0: e59030fc ldr r3, [r0, #252] ; 0xfc 300258a4: e59330d0 ldr r3, [r3, #208] ; 0xd0 300258a8: e1d53003 bics r3, r5, r3
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
300258ac: 059f2190 ldreq r2, [pc, #400] ; 30025a44 <killinfo+0x260> 300258b0: 04923004 ldreq r3, [r2], #4
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Thread_Executing;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
300258b4: 0a000009 beq 300258e0 <killinfo+0xfc>
300258b8: ea00003c b 300259b0 <killinfo+0x1cc> <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
300258bc: e593c030 ldr ip, [r3, #48] ; 0x30 <== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
300258c0: e1a00003 mov r0, r3 <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
300258c4: e115000c tst r5, ip <== NOT EXECUTED
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
300258c8: e59310fc ldr r1, [r3, #252] ; 0xfc <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
300258cc: 1a000037 bne 300259b0 <killinfo+0x1cc> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
300258d0: e59110d0 ldr r1, [r1, #208] ; 0xd0 <== NOT EXECUTED 300258d4: e1d51001 bics r1, r5, r1 <== NOT EXECUTED 300258d8: 1a000034 bne 300259b0 <killinfo+0x1cc> <== NOT EXECUTED
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
300258dc: e5933000 ldr r3, [r3] <== NOT EXECUTED
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
300258e0: e1530002 cmp r3, r2
300258e4: 1afffff4 bne 300258bc <killinfo+0xd8> * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
300258e8: e59f3158 ldr r3, [pc, #344] ; 30025a48 <killinfo+0x264> 300258ec: e59fc158 ldr ip, [pc, #344] ; 30025a4c <killinfo+0x268> 300258f0: e5d32000 ldrb r2, [r3]
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
300258f4: e28ca008 add sl, ip, #8
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
300258f8: e2822001 add r2, r2, #1
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
300258fc: e3a00000 mov r0, #0
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
30025900: e5bc3004 ldr r3, [ip, #4]! 30025904: e3530000 cmp r3, #0
30025908: 0a000024 beq 300259a0 <killinfo+0x1bc>
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
3002590c: e5933004 ldr r3, [r3, #4]
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
30025910: e3a0e001 mov lr, #1
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
30025914: e1d391b0 ldrh r9, [r3, #16] 30025918: e593601c ldr r6, [r3, #28]
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
3002591c: ea00001d b 30025998 <killinfo+0x1b4>
the_thread = (Thread_Control *) object_table[ index ];
30025920: e5b63004 ldr r3, [r6, #4]!
if ( !the_thread )
30025924: e3530000 cmp r3, #0
30025928: 0a000019 beq 30025994 <killinfo+0x1b0>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
3002592c: e5931014 ldr r1, [r3, #20] 30025930: e1510002 cmp r1, r2
30025934: 8a000016 bhi 30025994 <killinfo+0x1b0>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
30025938: e59370fc ldr r7, [r3, #252] ; 0xfc 3002593c: e59770d0 ldr r7, [r7, #208] ; 0xd0 30025940: e1d57007 bics r7, r5, r7
30025944: 0a000012 beq 30025994 <killinfo+0x1b0>
*
* NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
* so we never have to worry about deferencing a NULL
* interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
30025948: e1510002 cmp r1, r2 <== NOT EXECUTED 3002594c: 3a00000e bcc 3002598c <killinfo+0x1a8> <== NOT EXECUTED
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
30025950: e3500000 cmp r0, #0 <== NOT EXECUTED 30025954: 0a00000e beq 30025994 <killinfo+0x1b0> <== NOT EXECUTED 30025958: e5908010 ldr r8, [r0, #16] <== NOT EXECUTED 3002595c: e3580000 cmp r8, #0 <== NOT EXECUTED 30025960: 0a00000b beq 30025994 <killinfo+0x1b0> <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
30025964: e5937010 ldr r7, [r3, #16] <== NOT EXECUTED 30025968: e3570000 cmp r7, #0 <== NOT EXECUTED 3002596c: 0a000006 beq 3002598c <killinfo+0x1a8> <== NOT EXECUTED
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
30025970: e3180201 tst r8, #268435456 ; 0x10000000 <== NOT EXECUTED 30025974: 1a000006 bne 30025994 <killinfo+0x1b0> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
30025978: e2077201 and r7, r7, #268435456 ; 0x10000000 <== NOT EXECUTED
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
3002597c: e3570000 cmp r7, #0 <== NOT EXECUTED 30025980: 11a02001 movne r2, r1 <== NOT EXECUTED 30025984: 11a00003 movne r0, r3 <== NOT EXECUTED 30025988: ea000001 b 30025994 <killinfo+0x1b0> <== NOT EXECUTED
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
3002598c: e1a02001 mov r2, r1 <== NOT EXECUTED 30025990: e1a00003 mov r0, r3 <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
30025994: e28ee001 add lr, lr, #1 30025998: e15e0009 cmp lr, r9
3002599c: 9affffdf bls 30025920 <killinfo+0x13c>
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
300259a0: e15c000a cmp ip, sl
300259a4: 1affffd5 bne 30025900 <killinfo+0x11c>
}
}
}
}
if ( interested ) {
300259a8: e3500000 cmp r0, #0
300259ac: 0a000004 beq 300259c4 <killinfo+0x1e0>
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
300259b0: e1a01004 mov r1, r4 <== NOT EXECUTED 300259b4: e1a0200d mov r2, sp <== NOT EXECUTED 300259b8: eb000030 bl 30025a80 <_POSIX_signals_Unblock_thread> <== NOT EXECUTED 300259bc: e3500000 cmp r0, #0 <== NOT EXECUTED 300259c0: 1a000019 bne 30025a2c <killinfo+0x248> <== NOT EXECUTED
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
300259c4: e1a00005 mov r0, r5 300259c8: eb000022 bl 30025a58 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
300259cc: e3a0300c mov r3, #12 300259d0: e0040493 mul r4, r3, r4 300259d4: e59f305c ldr r3, [pc, #92] ; 30025a38 <killinfo+0x254> 300259d8: e7933004 ldr r3, [r3, r4] 300259dc: e3530002 cmp r3, #2
300259e0: 1a000011 bne 30025a2c <killinfo+0x248>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
300259e4: e59f0064 ldr r0, [pc, #100] ; 30025a50 <killinfo+0x26c> <== NOT EXECUTED 300259e8: ebffa50f bl 3000ee2c <_Chain_Get> <== NOT EXECUTED
if ( !psiginfo ) {
300259ec: e250c000 subs ip, r0, #0 <== NOT EXECUTED 300259f0: 1a000005 bne 30025a0c <killinfo+0x228> <== NOT EXECUTED
_Thread_Enable_dispatch();
300259f4: ebffaba0 bl 3001087c <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
300259f8: ebffc1ff bl 300161fc <__errno> <== NOT EXECUTED 300259fc: e3a0300b mov r3, #11 <== NOT EXECUTED 30025a00: e5803000 str r3, [r0] <== NOT EXECUTED 30025a04: e3e00000 mvn r0, #0 <== NOT EXECUTED 30025a08: ea000009 b 30025a34 <killinfo+0x250> <== NOT EXECUTED
}
psiginfo->Info = *siginfo;
30025a0c: e28c3008 add r3, ip, #8 <== NOT EXECUTED
30025a10: e1a0200d mov r2, sp <== NOT EXECUTED
30025a14: e8920007 ldm r2, {r0, r1, r2} <== NOT EXECUTED
30025a18: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
30025a1c: e59f0030 ldr r0, [pc, #48] ; 30025a54 <killinfo+0x270> <== NOT EXECUTED 30025a20: e1a0100c mov r1, ip <== NOT EXECUTED 30025a24: e0800004 add r0, r0, r4 <== NOT EXECUTED 30025a28: ebffa4ec bl 3000ede0 <_Chain_Append> <== NOT EXECUTED
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
30025a2c: ebffab92 bl 3001087c <_Thread_Enable_dispatch>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
return 0;
30025a30: e3a00000 mov r0, #0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
30025a34: e8bd87fe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, pc}
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: eb0039f1 bl 30017fd8 <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: eb002d02 bl 30014cac <__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}
3000932c <lio_listio>:
int mode __attribute__((unused)),
struct aiocb * const list[] __attribute__((unused)),
int nent __attribute__((unused)),
struct sigevent *sig __attribute__((unused))
)
{
3000932c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009330: eb0021a8 bl 300119d8 <__errno> <== NOT EXECUTED 30009334: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009338: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000933c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009340: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30016888 <lseek>:
{
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
30016888: e59fc0d4 ldr ip, [pc, #212] ; 30016964 <lseek+0xdc>
off_t lseek(
int fd,
off_t offset,
int whence
)
{
3001688c: e92d4870 push {r4, r5, r6, fp, lr}
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
30016890: e59cc000 ldr ip, [ip] 30016894: e150000c cmp r0, ip
30016898: 2a000006 bcs 300168b8 <lseek+0x30> iop = rtems_libio_iop( fd );
3001689c: e59fc0c4 ldr ip, [pc, #196] ; 30016968 <lseek+0xe0> 300168a0: e3a04038 mov r4, #56 ; 0x38 300168a4: e59cc000 ldr ip, [ip] 300168a8: e024c490 mla r4, r0, r4, ip
rtems_libio_check_is_open(iop);
300168ac: e5940014 ldr r0, [r4, #20] 300168b0: e3100c01 tst r0, #256 ; 0x100
300168b4: 1a000002 bne 300168c4 <lseek+0x3c>
300168b8: ebffea01 bl 300110c4 <__errno> <== NOT EXECUTED 300168bc: e3a03009 mov r3, #9 <== NOT EXECUTED 300168c0: ea000015 b 3001691c <lseek+0x94> <== NOT EXECUTED
/*
* Now process the lseek().
*/
old_offset = iop->offset;
switch ( whence ) {
300168c4: e3530001 cmp r3, #1
/*
* Now process the lseek().
*/
old_offset = iop->offset;
300168c8: e284600c add r6, r4, #12
300168cc: e8960060 ldm r6, {r5, r6}
switch ( whence ) {
300168d0: 0a000006 beq 300168f0 <lseek+0x68>
300168d4: e3530002 cmp r3, #2
300168d8: 0a000007 beq 300168fc <lseek+0x74>
300168dc: e3530000 cmp r3, #0
300168e0: 1a00000b bne 30016914 <lseek+0x8c>
case SEEK_SET:
iop->offset = offset;
300168e4: e584100c str r1, [r4, #12] 300168e8: e5842010 str r2, [r4, #16]
break;
300168ec: ea00000e b 3001692c <lseek+0xa4>
case SEEK_CUR:
iop->offset += offset;
300168f0: e091b005 adds fp, r1, r5 300168f4: e0a2c006 adc ip, r2, r6 300168f8: ea000002 b 30016908 <lseek+0x80>
break;
case SEEK_END:
iop->offset = iop->size + offset;
300168fc: e9941800 ldmib r4, {fp, ip}
30016900: e09bb001 adds fp, fp, r1
30016904: e0acc002 adc ip, ip, r2
30016908: e584b00c str fp, [r4, #12]
3001690c: e584c010 str ip, [r4, #16]
break;
30016910: ea000005 b 3001692c <lseek+0xa4>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30016914: ebffe9ea bl 300110c4 <__errno> 30016918: e3a03016 mov r3, #22 3001691c: e5803000 str r3, [r0] 30016920: e3e02000 mvn r2, #0 30016924: e3e03000 mvn r3, #0 30016928: ea00000a b 30016958 <lseek+0xd0>
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
3001692c: e594c020 ldr ip, [r4, #32] 30016930: e1a00004 mov r0, r4 30016934: e1a0e00f mov lr, pc 30016938: e59cf014 ldr pc, [ip, #20]
if ( status == (off_t) -1 )
3001693c: 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 );
30016940: e1a02000 mov r2, r0 30016944: e1a03001 mov r3, r1
if ( status == (off_t) -1 ) 30016948: 1a000002 bne 30016958 <lseek+0xd0>
3001694c: e3710001 cmn r1, #1
iop->offset = old_offset;
30016950: 0584500c streq r5, [r4, #12] 30016954: 05846010 streq r6, [r4, #16]
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
30016958: e1a00002 mov r0, r2
3001695c: e1a01003 mov r1, r3
30016960: e8bd8870 pop {r4, r5, r6, fp, pc}
30008300 <lstat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
30008300: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
30008304: e2515000 subs r5, r1, #0 <== NOT EXECUTED
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
30008308: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 3000830c: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
30008310: 1a000003 bne 30008324 <lstat+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
30008314: eb002bd9 bl 30013280 <__errno> <== NOT EXECUTED 30008318: e3a0300e mov r3, #14 <== NOT EXECUTED 3000831c: e5803000 str r3, [r0] <== NOT EXECUTED 30008320: ea000015 b 3000837c <lstat+0x7c> <== NOT EXECUTED
status = rtems_filesystem_evaluate_path( path, strlen( path ),
30008324: eb003265 bl 30014cc0 <strlen> <== NOT EXECUTED 30008328: e28d4004 add r4, sp, #4 <== NOT EXECUTED 3000832c: e1a01000 mov r1, r0 <== NOT EXECUTED 30008330: e3a02000 mov r2, #0 <== NOT EXECUTED 30008334: e1a00006 mov r0, r6 <== NOT EXECUTED 30008338: e1a03004 mov r3, r4 <== NOT EXECUTED 3000833c: e58d2000 str r2, [sp] <== NOT EXECUTED 30008340: ebfffe64 bl 30007cd8 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
30008344: e2501000 subs r1, r0, #0 <== NOT EXECUTED 30008348: 1a00000b bne 3000837c <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) );
3000834c: e3a02048 mov r2, #72 ; 0x48 <== NOT EXECUTED 30008350: e1a00005 mov r0, r5 <== NOT EXECUTED 30008354: eb003045 bl 30014470 <memset> <== NOT EXECUTED
status = (*loc.handlers->fstat_h)( &loc, buf );
30008358: e1a01005 mov r1, r5 <== NOT EXECUTED 3000835c: e1a00004 mov r0, r4 <== NOT EXECUTED 30008360: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30008364: e1a0e00f mov lr, pc <== NOT EXECUTED 30008368: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED 3000836c: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30008370: e1a00004 mov r0, r4 <== NOT EXECUTED 30008374: ebfffe87 bl 30007d98 <rtems_filesystem_freenode> <== NOT EXECUTED
return status;
30008378: ea000000 b 30008380 <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;
3000837c: e3e05000 mvn r5, #0 <== NOT EXECUTED
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
30008380: e1a00005 mov r0, r5 <== NOT EXECUTED
30008384: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30008388: 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: eb001206 bl 3000ae58 <_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: eb002a95 bl 300110c4 <__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: ea000e42 b 30009e04 <_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: eb000e5c bl 30009e50 <_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: eb000e13 bl 30009d9c <_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: eb000e22 bl 30009e00 <_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: eb001780 bl 3000ff9c <_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: eb005993 bl 30020a3c <__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: eb0038db bl 30014d24 <__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: eb0011e5 bl 3000b174 <_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: eb002b34 bl 300116c4 <__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: ea0011bf b 3000b128 <_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: 0b000cff bleq 30009e64 <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: ea0016b3 b 30010048 <_Protected_heap_Walk> <== NOT EXECUTED
3000fc50 <memfile_free_block>:
* Free a block from an in-memory file.
*/
void memfile_free_block(
void *memory
)
{
3000fc50: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
free(memory);
3000fc54: ebffd992 bl 300062a4 <free> <== NOT EXECUTED
memfile_blocks_allocated--;
3000fc58: e59f300c ldr r3, [pc, #12] ; 3000fc6c <memfile_free_block+0x1c><== NOT EXECUTED 3000fc5c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000fc60: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000fc64: e5832000 str r2, [r3] <== NOT EXECUTED
}
3000fc68: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000fc70 <memfile_free_blocks_in_table>:
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
3000fc70: 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++ ) {
3000fc74: e3a05000 mov r5, #0 <== NOT EXECUTED
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
3000fc78: e1a04000 mov r4, r0 <== NOT EXECUTED 3000fc7c: 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++ ) {
3000fc80: e5906000 ldr r6, [r0] <== NOT EXECUTED
if ( b[i] ) {
memfile_free_block( b[i] );
b[i] = 0;
3000fc84: 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++ ) {
3000fc88: ea000005 b 3000fca4 <memfile_free_blocks_in_table+0x34> <== NOT EXECUTED
if ( b[i] ) {
3000fc8c: e4960004 ldr r0, [r6], #4 <== NOT EXECUTED 3000fc90: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fc94: 0a000001 beq 3000fca0 <memfile_free_blocks_in_table+0x30> <== NOT EXECUTED
memfile_free_block( b[i] );
3000fc98: ebffffec bl 3000fc50 <memfile_free_block> <== NOT EXECUTED
b[i] = 0;
3000fc9c: 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++ ) {
3000fca0: e2855001 add r5, r5, #1 <== NOT EXECUTED 3000fca4: e1550008 cmp r5, r8 <== NOT EXECUTED 3000fca8: bafffff7 blt 3000fc8c <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 );
3000fcac: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000fcb0: ebffffe6 bl 3000fc50 <memfile_free_block> <== NOT EXECUTED
*block_table = 0;
3000fcb4: e3a03000 mov r3, #0 <== NOT EXECUTED 3000fcb8: e5843000 str r3, [r4] <== NOT EXECUTED
}
3000fcbc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3001018c <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
3001018c: e92d4013 push {r0, r1, r4, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
30010190: 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 )
30010194: e5943054 ldr r3, [r4, #84] ; 0x54 30010198: e1530002 cmp r3, r2
3001019c: ba000003 blt 300101b0 <memfile_ftruncate+0x24> 300101a0: 1a000005 bne 300101bc <memfile_ftruncate+0x30>
300101a4: e5943050 ldr r3, [r4, #80] ; 0x50 300101a8: e1530001 cmp r3, r1
300101ac: 2a000002 bcs 300101bc <memfile_ftruncate+0x30>
return IMFS_memfile_extend( the_jnode, length );
300101b0: e1a00004 mov r0, r4 <== NOT EXECUTED 300101b4: ebffff0e bl 3000fdf4 <IMFS_memfile_extend> <== NOT EXECUTED 300101b8: ea000008 b 300101e0 <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;
300101bc: e5841050 str r1, [r4, #80] ; 0x50 300101c0: e5842054 str r2, [r4, #84] ; 0x54
iop->size = the_jnode->info.file.size;
300101c4: e9800006 stmib r0, {r1, r2}
IMFS_update_atime( the_jnode );
300101c8: e3a01000 mov r1, #0 300101cc: e1a0000d mov r0, sp 300101d0: ebffd85c bl 30006348 <gettimeofday> 300101d4: e59d3000 ldr r3, [sp]
return 0;
300101d8: 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 );
300101dc: e5843040 str r3, [r4, #64] ; 0x40
return 0;
}
300101e0: e8bd801c pop {r2, r3, r4, pc}
3000f7ec <memfile_ioctl>:
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
return 0;
}
3000f7ec: e3a00000 mov r0, #0 <== NOT EXECUTED 3000f7f0: e12fff1e bx lr <== NOT EXECUTED
300101e4 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
300101e4: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
300101e8: e5905018 ldr r5, [r0, #24]
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
300101ec: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
300101f0: e595304c ldr r3, [r5, #76] ; 0x4c 300101f4: e3530006 cmp r3, #6
300101f8: 1a00000b bne 3001022c <memfile_lseek+0x48>
if (iop->offset > the_jnode->info.linearfile.size)
300101fc: e5953054 ldr r3, [r5, #84] ; 0x54 30010200: e5901010 ldr r1, [r0, #16] 30010204: e5952050 ldr r2, [r5, #80] ; 0x50 30010208: e1510003 cmp r1, r3
3001020c: ca000003 bgt 30010220 <memfile_lseek+0x3c> 30010210: 1a000014 bne 30010268 <memfile_lseek+0x84>
30010214: e590100c ldr r1, [r0, #12] 30010218: e1510002 cmp r1, r2
3001021c: 9a000011 bls 30010268 <memfile_lseek+0x84>
iop->offset = the_jnode->info.linearfile.size;
30010220: e584200c str r2, [r4, #12] <== NOT EXECUTED 30010224: e5843010 str r3, [r4, #16] <== NOT EXECUTED 30010228: ea00000e b 30010268 <memfile_lseek+0x84> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
3001022c: e1a00005 mov r0, r5
30010230: e284200c add r2, r4, #12
30010234: e8920006 ldm r2, {r1, r2}
30010238: ebfffeed bl 3000fdf4 <IMFS_memfile_extend>
3001023c: e3500000 cmp r0, #0
30010240: 0a000005 beq 3001025c <memfile_lseek+0x78>
rtems_set_errno_and_return_minus_one( ENOSPC );
30010244: eb00039e bl 300110c4 <__errno> <== NOT EXECUTED 30010248: e3a0301c mov r3, #28 <== NOT EXECUTED 3001024c: e5803000 str r3, [r0] <== NOT EXECUTED 30010250: e3e04000 mvn r4, #0 <== NOT EXECUTED 30010254: e3e03000 mvn r3, #0 <== NOT EXECUTED 30010258: ea000004 b 30010270 <memfile_lseek+0x8c> <== NOT EXECUTED
iop->size = the_jnode->info.file.size;
3001025c: e2853050 add r3, r5, #80 ; 0x50
30010260: e893000c ldm r3, {r2, r3}
30010264: e984000c stmib r4, {r2, r3}
} return iop->offset;
30010268: e284400c add r4, r4, #12
3001026c: e8940018 ldm r4, {r3, r4}
}
30010270: e1a00003 mov r0, r3
30010274: e1a01004 mov r1, r4
30010278: e8bd8030 pop {r4, r5, pc}
300100f0 <memfile_open>:
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
300100f0: e5903014 ldr r3, [r0, #20]
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
300100f4: 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))
300100f8: e3130f81 tst r3, #516 ; 0x204
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
300100fc: e1a05000 mov r5, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
30010100: e5904018 ldr r4, [r0, #24]
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
30010104: 0a000015 beq 30010160 <memfile_open+0x70>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
30010108: e594304c ldr r3, [r4, #76] ; 0x4c 3001010c: e3530006 cmp r3, #6
30010110: 1a000012 bne 30010160 <memfile_open+0x70>
uint32_t count = the_jnode->info.linearfile.size;
30010114: 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;
30010118: 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;
3001011c: e3a02005 mov r2, #5 <== NOT EXECUTED 30010120: e584204c str r2, [r4, #76] ; 0x4c <== NOT EXECUTED
the_jnode->info.file.size = 0;
30010124: e3a01000 mov r1, #0 <== NOT EXECUTED 30010128: 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)
3001012c: 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;
30010130: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
30010134: e5841050 str r1, [r4, #80] ; 0x50 <== NOT EXECUTED 30010138: e5842054 str r2, [r4, #84] ; 0x54 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
3001013c: e5840058 str r0, [r4, #88] ; 0x58 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
30010140: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
30010144: e5840060 str r0, [r4, #96] ; 0x60 <== NOT EXECUTED
if ((count != 0)
30010148: 0a000004 beq 30010160 <memfile_open+0x70> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
3001014c: e1a00004 mov r0, r4 <== NOT EXECUTED 30010150: e58dc000 str ip, [sp] <== NOT EXECUTED 30010154: ebffff6d bl 3000ff10 <IMFS_memfile_write> <== NOT EXECUTED 30010158: e3700001 cmn r0, #1 <== NOT EXECUTED 3001015c: 0a000009 beq 30010188 <memfile_open+0x98> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
30010160: e5953014 ldr r3, [r5, #20] 30010164: e3130c02 tst r3, #512 ; 0x200
iop->offset = the_jnode->info.file.size;
30010168: 12843050 addne r3, r4, #80 ; 0x50
3001016c: 1893000c ldmne r3, {r2, r3}
30010170: 1585200c strne r2, [r5, #12]
30010174: 15853010 strne r3, [r5, #16]
iop->size = the_jnode->info.file.size;
30010178: e2844050 add r4, r4, #80 ; 0x50
3001017c: e8940018 ldm r4, {r3, r4}
30010180: e9850018 stmib r5, {r3, r4}
return 0;
30010184: e3a00000 mov r0, #0
}
30010188: 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: eb002a65 bl 300110c4 <__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: eb001dcc bl 3000dfa0 <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: eb002a11 bl 300110c4 <__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: eb002df1 bl 3001206c <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: eb002deb bl 3001206c <strlen> 300068bc: e2807001 add r7, r0, #1
size_t target_size = strlen( target ) + 1;
300068c0: e59d0004 ldr r0, [sp, #4] 300068c4: eb002de8 bl 3001206c <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: eb002c1d bl 3001197c <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: eb002c17 bl 3001197c <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: eb002c12 bl 3001197c <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: eb0029d4 bl 300110c4 <__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: eb0029c0 bl 300110c4 <__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: eb0029b8 bl 300110c4 <__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: eb0029a0 bl 300110c4 <__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: eb000cdc bl 30009e04 <_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}
30009344 <mprotect>:
const void *addr __attribute__((unused)),
size_t len __attribute__((unused)),
int prot __attribute__((unused)) )
{
return 0;
}
30009344: e3a00000 mov r0, #0 <== NOT EXECUTED 30009348: e12fff1e bx lr <== NOT EXECUTED
3000e634 <mq_close>:
*/
int mq_close(
mqd_t mqdes
)
{
3000e634: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3000e638: e1a01000 mov r1, r0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
3000e63c: e1a0200d mov r2, sp <== NOT EXECUTED 3000e640: e59f005c ldr r0, [pc, #92] ; 3000e6a4 <mq_close+0x70> <== NOT EXECUTED 3000e644: eb000c9c bl 300118bc <_Objects_Get> <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
if ( location == OBJECTS_LOCAL ) {
3000e648: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000e64c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000e650: e3550000 cmp r5, #0 <== NOT EXECUTED 3000e654: 1a00000d bne 3000e690 <mq_close+0x5c> <== NOT EXECUTED
* First update the actual message queue to reflect this descriptor
* being disassociated. This may result in the queue being really
* deleted.
*/
the_mq = the_mq_fd->Queue;
3000e658: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
the_mq->open_count -= 1;
3000e65c: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED 3000e660: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000e664: e5803018 str r3, [r0, #24] <== NOT EXECUTED
_POSIX_Message_queue_Delete( the_mq );
3000e668: eb00000e bl 3000e6a8 <_POSIX_Message_queue_Delete> <== NOT EXECUTED
/*
* Now close this file descriptor.
*/
_Objects_Close(
3000e66c: e59f0030 ldr r0, [pc, #48] ; 3000e6a4 <mq_close+0x70> <== NOT EXECUTED 3000e670: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e674: eb000b96 bl 300114d4 <_Objects_Close> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
3000e678: e59f0024 ldr r0, [pc, #36] ; 3000e6a4 <mq_close+0x70> <== NOT EXECUTED 3000e67c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e680: eb000c38 bl 30011768 <_Objects_Free> <== NOT EXECUTED
&_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000e684: eb000fb2 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000e688: e1a00005 mov r0, r5 <== NOT EXECUTED 3000e68c: ea000003 b 3000e6a0 <mq_close+0x6c> <== NOT EXECUTED
/*
* OBJECTS_REMOTE:
* OBJECTS_ERROR:
*/
rtems_set_errno_and_return_minus_one( EBADF );
3000e690: eb0027ee bl 30018650 <__errno> <== NOT EXECUTED 3000e694: e3a03009 mov r3, #9 <== NOT EXECUTED 3000e698: e5803000 str r3, [r0] <== NOT EXECUTED 3000e69c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000e6a0: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000e6f8 <mq_getattr>:
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
3000e6f8: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
CORE_message_queue_Attributes *the_mq_attr;
if ( !mqstat )
3000e6fc: e2514000 subs r4, r1, #0 <== NOT EXECUTED
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
3000e700: e1a03000 mov r3, r0 <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
CORE_message_queue_Attributes *the_mq_attr;
if ( !mqstat )
3000e704: 1a000002 bne 3000e714 <mq_getattr+0x1c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000e708: eb0027d0 bl 30018650 <__errno> <== NOT EXECUTED 3000e70c: e3a03016 mov r3, #22 <== NOT EXECUTED 3000e710: ea000014 b 3000e768 <mq_getattr+0x70> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
3000e714: e59f0058 ldr r0, [pc, #88] ; 3000e774 <mq_getattr+0x7c> <== NOT EXECUTED 3000e718: e1a01003 mov r1, r3 <== NOT EXECUTED 3000e71c: e1a0200d mov r2, sp <== NOT EXECUTED 3000e720: eb000c65 bl 300118bc <_Objects_Get> <== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000e724: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000e728: e3550000 cmp r5, #0 <== NOT EXECUTED 3000e72c: 1a00000b bne 3000e760 <mq_getattr+0x68> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
3000e730: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
* Return the old values.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
mqstat->mq_flags = the_mq_fd->oflag;
3000e734: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED 3000e738: e5842000 str r2, [r4] <== NOT EXECUTED
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
3000e73c: e5932068 ldr r2, [r3, #104] ; 0x68 <== NOT EXECUTED 3000e740: e5842008 str r2, [r4, #8] <== NOT EXECUTED
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
3000e744: e5932060 ldr r2, [r3, #96] ; 0x60 <== NOT EXECUTED
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
3000e748: e5933064 ldr r3, [r3, #100] ; 0x64 <== NOT EXECUTED
the_mq_attr = &the_mq->Message_queue.Attributes;
mqstat->mq_flags = the_mq_fd->oflag;
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
3000e74c: e5842004 str r2, [r4, #4] <== NOT EXECUTED
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
3000e750: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000e754: eb000f7e bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000e758: e1a00005 mov r0, r5 <== NOT EXECUTED 3000e75c: ea000003 b 3000e770 <mq_getattr+0x78> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000e760: eb0027ba bl 30018650 <__errno> <== NOT EXECUTED 3000e764: e3a03009 mov r3, #9 <== NOT EXECUTED 3000e768: e5803000 str r3, [r0] <== NOT EXECUTED 3000e76c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000e770: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000e79c <mq_notify>:
int mq_notify(
mqd_t mqdes,
const struct sigevent *notification
)
{
3000e79c: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3000e7a0: e1a03000 mov r3, r0 <== NOT EXECUTED
3000e7a4: e1a04001 mov r4, r1 <== NOT EXECUTED
3000e7a8: e59f008c ldr r0, [pc, #140] ; 3000e83c <mq_notify+0xa0> <== NOT EXECUTED
3000e7ac: e1a01003 mov r1, r3 <== NOT EXECUTED
3000e7b0: e1a0200d mov r2, sp <== NOT EXECUTED
3000e7b4: eb000c40 bl 300118bc <_Objects_Get> <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000e7b8: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000e7bc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e7c0: 1a000018 bne 3000e828 <mq_notify+0x8c> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
if ( notification ) {
3000e7c4: e3540000 cmp r4, #0 <== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
3000e7c8: e590c010 ldr ip, [r0, #16] <== NOT EXECUTED
if ( notification ) {
3000e7cc: 0a000010 beq 3000e814 <mq_notify+0x78> <== NOT EXECUTED
if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) {
3000e7d0: e59c307c ldr r3, [ip, #124] ; 0x7c <== NOT EXECUTED 3000e7d4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e7d8: 0a000003 beq 3000e7ec <mq_notify+0x50> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000e7dc: eb000f5c bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
3000e7e0: eb00279a bl 30018650 <__errno> <== NOT EXECUTED 3000e7e4: e3a03010 mov r3, #16 <== NOT EXECUTED 3000e7e8: ea000010 b 3000e830 <mq_notify+0x94> <== NOT EXECUTED 3000e7ec: e58c3080 str r3, [ip, #128] ; 0x80 <== NOT EXECUTED
}
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
the_mq->notification = *notification;
3000e7f0: e28ce090 add lr, ip, #144 ; 0x90 <== NOT EXECUTED
3000e7f4: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3000e7f8: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
3000e7fc: e5943000 ldr r3, [r4] <== NOT EXECUTED
3000e800: e58cc080 str ip, [ip, #128] ; 0x80 <== NOT EXECUTED
3000e804: e58e3000 str r3, [lr] <== NOT EXECUTED
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
3000e808: e59f3030 ldr r3, [pc, #48] ; 3000e840 <mq_notify+0xa4> <== NOT EXECUTED 3000e80c: e58c307c str r3, [ip, #124] ; 0x7c <== NOT EXECUTED 3000e810: ea000001 b 3000e81c <mq_notify+0x80> <== NOT EXECUTED 3000e814: e58c407c str r4, [ip, #124] ; 0x7c <== NOT EXECUTED
the_message_queue->notify_argument = the_argument;
3000e818: e58c4080 str r4, [ip, #128] ; 0x80 <== NOT EXECUTED
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
}
_Thread_Enable_dispatch();
3000e81c: eb000f4c bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000e820: e3a00000 mov r0, #0 <== NOT EXECUTED 3000e824: ea000003 b 3000e838 <mq_notify+0x9c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000e828: eb002788 bl 30018650 <__errno> <== NOT EXECUTED 3000e82c: e3a03009 mov r3, #9 <== NOT EXECUTED 3000e830: e5803000 str r3, [r0] <== NOT EXECUTED 3000e834: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000e838: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000e844 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
3000e844: e92d000e push {r1, r2, r3} <== NOT EXECUTED
3000e848: e92d47ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, lr}<== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000e84c: e59f3164 ldr r3, [pc, #356] ; 3000e9b8 <mq_open+0x174> <== NOT EXECUTED 3000e850: e59d7030 ldr r7, [sp, #48] ; 0x30 <== NOT EXECUTED 3000e854: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000e858: e1a0a000 mov sl, r0 <== NOT EXECUTED 3000e85c: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000e860: e5832000 str r2, [r3] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
_Objects_Allocate( &_POSIX_Message_queue_Information_fds );
3000e864: e59f5150 ldr r5, [pc, #336] ; 3000e9bc <mq_open+0x178> <== NOT EXECUTED
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
3000e868: e2179c02 ands r9, r7, #512 ; 0x200 <== NOT EXECUTED
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
3000e86c: 128d303c addne r3, sp, #60 ; 0x3c <== NOT EXECUTED 3000e870: e1a00005 mov r0, r5 <== NOT EXECUTED 3000e874: 158d300c strne r3, [sp, #12] <== NOT EXECUTED 3000e878: 159d8038 ldrne r8, [sp, #56] ; 0x38 <== NOT EXECUTED
/* struct mq_attr attr */
)
{
va_list arg;
mode_t mode;
struct mq_attr *attr = NULL;
3000e87c: 01a08009 moveq r8, r9 <== NOT EXECUTED 3000e880: eb000af1 bl 3001144c <_Objects_Allocate> <== NOT EXECUTED
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
3000e884: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000e888: 1a000003 bne 3000e89c <mq_open+0x58> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000e88c: eb000f30 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENFILE );
3000e890: eb00276e bl 30018650 <__errno> <== NOT EXECUTED 3000e894: e3a03017 mov r3, #23 <== NOT EXECUTED 3000e898: ea00001a b 3000e908 <mq_open+0xc4> <== NOT EXECUTED
} the_mq_fd->oflag = oflag;
3000e89c: e5847014 str r7, [r4, #20] <== NOT EXECUTED
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );
3000e8a0: e1a0000a mov r0, sl <== NOT EXECUTED 3000e8a4: e28d1008 add r1, sp, #8 <== NOT EXECUTED 3000e8a8: eb001a5e bl 30015228 <_POSIX_Message_queue_Name_to_id> <== NOT EXECUTED
* If the name to id translation worked, then the message queue exists
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "message queue does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
3000e8ac: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000e8b0: 0a00000b beq 3000e8e4 <mq_open+0xa0> <== NOT EXECUTED
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
3000e8b4: e3560002 cmp r6, #2 <== NOT EXECUTED 3000e8b8: 1a000001 bne 3000e8c4 <mq_open+0x80> <== NOT EXECUTED 3000e8bc: e3590000 cmp r9, #0 <== NOT EXECUTED 3000e8c0: 1a000021 bne 3000e94c <mq_open+0x108> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
3000e8c4: e59f00f0 ldr r0, [pc, #240] ; 3000e9bc <mq_open+0x178> <== NOT EXECUTED 3000e8c8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e8cc: eb000ba5 bl 30011768 <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000e8d0: eb000f1f bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
3000e8d4: eb00275d bl 30018650 <__errno> <== NOT EXECUTED 3000e8d8: e5806000 str r6, [r0] <== NOT EXECUTED 3000e8dc: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000e8e0: ea000030 b 3000e9a8 <mq_open+0x164> <== NOT EXECUTED
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
3000e8e4: e2077c0a and r7, r7, #2560 ; 0xa00 <== NOT EXECUTED 3000e8e8: e3570c0a cmp r7, #2560 ; 0xa00 <== NOT EXECUTED 3000e8ec: 1a000007 bne 3000e910 <mq_open+0xcc> <== NOT EXECUTED 3000e8f0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000e8f4: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e8f8: eb000b9a bl 30011768 <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000e8fc: eb000f14 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
3000e900: eb002752 bl 30018650 <__errno> <== NOT EXECUTED 3000e904: e3a03011 mov r3, #17 <== NOT EXECUTED 3000e908: e5803000 str r3, [r0] <== NOT EXECUTED 3000e90c: eafffff2 b 3000e8dc <mq_open+0x98> <== NOT EXECUTED
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
_Objects_Get( &_POSIX_Message_queue_Information, id, location );
3000e910: e1a0200d mov r2, sp <== NOT EXECUTED 3000e914: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3000e918: e59f00a0 ldr r0, [pc, #160] ; 3000e9c0 <mq_open+0x17c> <== NOT EXECUTED 3000e91c: eb000be6 bl 300118bc <_Objects_Get> <== NOT EXECUTED
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
the_mq->open_count += 1;
3000e920: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
3000e924: e1d420b8 ldrh r2, [r4, #8] <== NOT EXECUTED 3000e928: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000e92c: e5803018 str r3, [r0, #24] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000e930: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
3000e934: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
the_mq->open_count += 1;
the_mq_fd->Queue = the_mq;
3000e938: e5840010 str r0, [r4, #16] <== NOT EXECUTED 3000e93c: e7834102 str r4, [r3, r2, lsl #2] <== NOT EXECUTED
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
3000e940: e584600c str r6, [r4, #12] <== NOT EXECUTED
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
3000e944: eb000f02 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000e948: ea000014 b 3000e9a0 <mq_open+0x15c> <== NOT EXECUTED
/*
* At this point, the message queue does not exist and everything has been
* checked. We should go ahead and create a message queue.
*/
status = _POSIX_Message_queue_Create_support(
3000e94c: e1a0000a mov r0, sl <== NOT EXECUTED 3000e950: e3a01001 mov r1, #1 <== NOT EXECUTED 3000e954: e1a02008 mov r2, r8 <== NOT EXECUTED 3000e958: e28d3004 add r3, sp, #4 <== NOT EXECUTED 3000e95c: eb0019dc bl 300150d4 <_POSIX_Message_queue_Create_support> <== NOT EXECUTED
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
3000e960: e3700001 cmn r0, #1 <== NOT EXECUTED
/*
* At this point, the message queue does not exist and everything has been
* checked. We should go ahead and create a message queue.
*/
status = _POSIX_Message_queue_Create_support(
3000e964: e1a06000 mov r6, r0 <== NOT EXECUTED
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
3000e968: 1a000005 bne 3000e984 <mq_open+0x140> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
3000e96c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000e970: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e974: eb000b7b bl 30011768 <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000e978: eb000ef5 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
return (mqd_t) -1;
3000e97c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000e980: ea000008 b 3000e9a8 <mq_open+0x164> <== NOT EXECUTED
}
the_mq_fd->Queue = the_mq;
3000e984: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
3000e988: e1d420b8 ldrh r2, [r4, #8] <== NOT EXECUTED 3000e98c: e5843010 str r3, [r4, #16] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000e990: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3000e994: e7834102 str r4, [r3, r2, lsl #2] <== NOT EXECUTED
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
3000e998: e3a03000 mov r3, #0 <== NOT EXECUTED 3000e99c: e584300c str r3, [r4, #12] <== NOT EXECUTED
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
3000e9a0: eb000eeb bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
return (mqd_t) the_mq_fd->Object.id;
3000e9a4: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
}
3000e9a8: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000e9ac: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
3000e9b0: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000e9b4: e12fff1e bx lr <== NOT EXECUTED
3000e9c4 <mq_receive>:
mqd_t mqdes,
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio
)
{
3000e9c4: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
return _POSIX_Message_queue_Receive_support(
3000e9c8: e3a0c001 mov ip, #1 <== NOT EXECUTED 3000e9cc: e58dc000 str ip, [sp] <== NOT EXECUTED 3000e9d0: e3a0c000 mov ip, #0 <== NOT EXECUTED 3000e9d4: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3000e9d8: eb000000 bl 3000e9e0 <_POSIX_Message_queue_Receive_support><== NOT EXECUTED
msg_len,
msg_prio,
true,
THREAD_QUEUE_WAIT_FOREVER
);
}
3000e9dc: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
3000eaf0 <mq_send>:
mqd_t mqdes,
const char *msg_ptr,
size_t msg_len,
unsigned int msg_prio
)
{
3000eaf0: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
return _POSIX_Message_queue_Send_support(
3000eaf4: e3a0c001 mov ip, #1 <== NOT EXECUTED 3000eaf8: e58dc000 str ip, [sp] <== NOT EXECUTED 3000eafc: e3a0c000 mov ip, #0 <== NOT EXECUTED 3000eb00: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3000eb04: eb000000 bl 3000eb0c <_POSIX_Message_queue_Send_support> <== NOT EXECUTED
msg_len,
msg_prio,
true,
THREAD_QUEUE_WAIT_FOREVER
);
}
3000eb08: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
3000ec0c <mq_setattr>:
int mq_setattr(
mqd_t mqdes,
const struct mq_attr *mqstat,
struct mq_attr *omqstat
)
{
3000ec0c: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
POSIX_Message_queue_Control_fd *the_mq_fd;
CORE_message_queue_Control *the_core_mq;
Objects_Locations location;
if ( !mqstat )
3000ec10: e2515000 subs r5, r1, #0 <== NOT EXECUTED
int mq_setattr(
mqd_t mqdes,
const struct mq_attr *mqstat,
struct mq_attr *omqstat
)
{
3000ec14: e1a03000 mov r3, r0 <== NOT EXECUTED 3000ec18: e1a04002 mov r4, r2 <== NOT EXECUTED
POSIX_Message_queue_Control_fd *the_mq_fd;
CORE_message_queue_Control *the_core_mq;
Objects_Locations location;
if ( !mqstat )
3000ec1c: 1a000002 bne 3000ec2c <mq_setattr+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000ec20: eb00268a bl 30018650 <__errno> <== NOT EXECUTED 3000ec24: e3a03016 mov r3, #22 <== NOT EXECUTED 3000ec28: ea000018 b 3000ec90 <mq_setattr+0x84> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
3000ec2c: e1a01003 mov r1, r3 <== NOT EXECUTED 3000ec30: e59f0064 ldr r0, [pc, #100] ; 3000ec9c <mq_setattr+0x90> <== NOT EXECUTED 3000ec34: e1a0200d mov r2, sp <== NOT EXECUTED 3000ec38: eb000b1f bl 300118bc <_Objects_Get> <== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000ec3c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000ec40: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ec44: 1a00000f bne 3000ec88 <mq_setattr+0x7c> <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
3000ec48: e3540000 cmp r4, #0 <== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_core_mq = &the_mq_fd->Queue->Message_queue;
3000ec4c: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
3000ec50: 0a000007 beq 3000ec74 <mq_setattr+0x68> <== NOT EXECUTED
omqstat->mq_flags = the_mq_fd->oflag;
3000ec54: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED 3000ec58: e5842000 str r2, [r4] <== NOT EXECUTED
omqstat->mq_msgsize = the_core_mq->maximum_message_size;
3000ec5c: e5932068 ldr r2, [r3, #104] ; 0x68 <== NOT EXECUTED 3000ec60: e5842008 str r2, [r4, #8] <== NOT EXECUTED
omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages;
3000ec64: e5932060 ldr r2, [r3, #96] ; 0x60 <== NOT EXECUTED
omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages;
3000ec68: e5933064 ldr r3, [r3, #100] ; 0x64 <== NOT EXECUTED
*/
if ( omqstat ) {
omqstat->mq_flags = the_mq_fd->oflag;
omqstat->mq_msgsize = the_core_mq->maximum_message_size;
omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages;
3000ec6c: e5842004 str r2, [r4, #4] <== NOT EXECUTED
omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages;
3000ec70: e584300c str r3, [r4, #12] <== NOT EXECUTED
}
the_mq_fd->oflag = mqstat->mq_flags;
3000ec74: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000ec78: e5803014 str r3, [r0, #20] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000ec7c: eb000e34 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000ec80: e3a00000 mov r0, #0 <== NOT EXECUTED 3000ec84: ea000003 b 3000ec98 <mq_setattr+0x8c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000ec88: eb002670 bl 30018650 <__errno> <== NOT EXECUTED 3000ec8c: e3a03009 mov r3, #9 <== NOT EXECUTED 3000ec90: e5803000 str r3, [r0] <== NOT EXECUTED 3000ec94: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000ec98: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000eca0 <mq_timedreceive>:
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio,
const struct timespec *abstime
)
{
3000eca0: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr} <== NOT EXECUTED
3000eca4: e1a05000 mov r5, r0 <== NOT EXECUTED
3000eca8: e1a04001 mov r4, r1 <== NOT EXECUTED
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000ecac: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED 3000ecb0: e28d1008 add r1, sp, #8 <== NOT EXECUTED
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio,
const struct timespec *abstime
)
{
3000ecb4: e1a06003 mov r6, r3 <== NOT EXECUTED 3000ecb8: e1a07002 mov r7, r2 <== NOT EXECUTED
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000ecbc: eb00003d bl 3000edb8 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
return _POSIX_Message_queue_Receive_support(
3000ecc0: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
3000ecc4: e3500003 cmp r0, #3 <== NOT EXECUTED
3000ecc8: 13a00000 movne r0, #0 <== NOT EXECUTED
3000eccc: 03a00001 moveq r0, #1 <== NOT EXECUTED
3000ecd0: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED
3000ecd4: e1a00005 mov r0, r5 <== NOT EXECUTED
3000ecd8: e1a01004 mov r1, r4 <== NOT EXECUTED
3000ecdc: e1a02007 mov r2, r7 <== NOT EXECUTED
3000ece0: e1a03006 mov r3, r6 <== NOT EXECUTED
3000ece4: ebffff3d bl 3000e9e0 <_POSIX_Message_queue_Receive_support><== NOT EXECUTED
msg_len,
msg_prio,
do_wait,
ticks
);
}
3000ece8: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000ecec <mq_timedsend>:
const char *msg_ptr,
size_t msg_len,
unsigned int msg_prio,
const struct timespec *abstime
)
{
3000ecec: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr} <== NOT EXECUTED
3000ecf0: e1a05000 mov r5, r0 <== NOT EXECUTED
3000ecf4: e1a04001 mov r4, r1 <== NOT EXECUTED
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000ecf8: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED 3000ecfc: e28d1008 add r1, sp, #8 <== NOT EXECUTED
const char *msg_ptr,
size_t msg_len,
unsigned int msg_prio,
const struct timespec *abstime
)
{
3000ed00: e1a06003 mov r6, r3 <== NOT EXECUTED 3000ed04: e1a07002 mov r7, r2 <== NOT EXECUTED
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000ed08: eb00002a bl 3000edb8 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
return _POSIX_Message_queue_Send_support(
3000ed0c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
3000ed10: e3500003 cmp r0, #3 <== NOT EXECUTED
3000ed14: 13a00000 movne r0, #0 <== NOT EXECUTED
3000ed18: 03a00001 moveq r0, #1 <== NOT EXECUTED
3000ed1c: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED
3000ed20: e1a00005 mov r0, r5 <== NOT EXECUTED
3000ed24: e1a01004 mov r1, r4 <== NOT EXECUTED
3000ed28: e1a02007 mov r2, r7 <== NOT EXECUTED
3000ed2c: e1a03006 mov r3, r6 <== NOT EXECUTED
3000ed30: ebffff75 bl 3000eb0c <_POSIX_Message_queue_Send_support> <== NOT EXECUTED
msg_len,
msg_prio,
do_wait,
ticks
);
}
3000ed34: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000ed48 <mq_unlink>:
3000ed48: e59f3060 ldr r3, [pc, #96] ; 3000edb0 <mq_unlink+0x68> <== NOT EXECUTED
*/
int mq_unlink(
const char *name
)
{
3000ed4c: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3000ed50: e5932000 ldr r2, [r3] <== NOT EXECUTED
3000ed54: e2822001 add r2, r2, #1 <== NOT EXECUTED
3000ed58: e5832000 str r2, [r3] <== NOT EXECUTED
register POSIX_Message_queue_Control *the_mq;
Objects_Id the_mq_id;
_Thread_Disable_dispatch();
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );
3000ed5c: e1a0100d mov r1, sp <== NOT EXECUTED 3000ed60: eb001930 bl 30015228 <_POSIX_Message_queue_Name_to_id> <== NOT EXECUTED
if ( status != 0 ) {
3000ed64: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000ed68: 0a000004 beq 3000ed80 <mq_unlink+0x38> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000ed6c: eb000df8 bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( status );
3000ed70: eb002636 bl 30018650 <__errno> <== NOT EXECUTED 3000ed74: e5804000 str r4, [r0] <== NOT EXECUTED 3000ed78: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000ed7c: ea00000a b 3000edac <mq_unlink+0x64> <== NOT EXECUTED
_POSIX_Message_queue_Namespace_remove( the_mq );
_POSIX_Message_queue_Delete( the_mq );
_Thread_Enable_dispatch();
return 0;
}
3000ed80: e59f002c ldr r0, [pc, #44] ; 3000edb4 <mq_unlink+0x6c> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
3000ed84: e1dd20b0 ldrh r2, [sp] <== NOT EXECUTED 3000ed88: e590301c ldr r3, [r0, #28] <== NOT EXECUTED
if ( status != 0 ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( status );
}
the_mq = (POSIX_Message_queue_Control *) _Objects_Get_local_object(
3000ed8c: e7935102 ldr r5, [r3, r2, lsl #2] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Namespace_remove (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Namespace_remove(
3000ed90: e1a01005 mov r1, r5 <== NOT EXECUTED
&_POSIX_Message_queue_Information,
_Objects_Get_index( the_mq_id )
);
the_mq->linked = false;
3000ed94: e5c54015 strb r4, [r5, #21] <== NOT EXECUTED 3000ed98: eb000b17 bl 300119fc <_Objects_Namespace_remove> <== NOT EXECUTED
_POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq );
3000ed9c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000eda0: ebfffe40 bl 3000e6a8 <_POSIX_Message_queue_Delete> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000eda4: eb000dea bl 30012554 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000eda8: e1a00004 mov r0, r4 <== NOT EXECUTED
}
3000edac: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30021978 <nanosleep>:
int nanosleep(
const struct timespec *rqtp,
struct timespec *rmtp
)
{
30021978: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3002197c: e1a05000 mov r5, r0 <== NOT EXECUTED
30021980: e1a04001 mov r4, r1 <== NOT EXECUTED
* Return EINVAL if the delay interval is negative. * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( !_Timespec_Is_valid( rqtp ) )
30021984: eb00005c bl 30021afc <_Timespec_Is_valid> <== NOT EXECUTED 30021988: e3500000 cmp r0, #0 <== NOT EXECUTED 3002198c: 1a000002 bne 3002199c <nanosleep+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30021990: ebffc445 bl 30012aac <__errno> <== NOT EXECUTED 30021994: e3a03016 mov r3, #22 <== NOT EXECUTED 30021998: ea00002d b 30021a54 <nanosleep+0xdc> <== NOT EXECUTED
ticks = _Timespec_To_ticks( rqtp );
3002199c: e1a00005 mov r0, r5 <== NOT EXECUTED 300219a0: ebffbc93 bl 30010bf4 <_Timespec_To_ticks> <== NOT EXECUTED
* A nanosleep for zero time is implemented as a yield.
* This behavior is also beyond the POSIX specification but is
* consistent with the RTEMS API and yields desirable behavior.
*/
if ( !ticks ) {
300219a4: e2505000 subs r5, r0, #0 <== NOT EXECUTED 300219a8: 1a000009 bne 300219d4 <nanosleep+0x5c> <== NOT EXECUTED
_Thread_Disable_dispatch();
300219ac: ebffffeb bl 30021960 <_Thread_Disable_dispatch> <== NOT EXECUTED
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
300219b0: e59f30b4 ldr r3, [pc, #180] ; 30021a6c <nanosleep+0xf4> <== NOT EXECUTED 300219b4: e1a0e00f mov lr, pc <== NOT EXECUTED 300219b8: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
_Scheduler_Yield();
_Thread_Enable_dispatch();
300219bc: ebffaa48 bl 3000c2e4 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( rmtp ) {
300219c0: e3540000 cmp r4, #0 <== NOT EXECUTED
rmtp->tv_sec = 0;
300219c4: 15845000 strne r5, [r4] <== NOT EXECUTED
rmtp->tv_nsec = 0;
300219c8: 15845004 strne r5, [r4, #4] <== NOT EXECUTED
if ( !ticks ) {
_Thread_Disable_dispatch();
_Scheduler_Yield();
_Thread_Enable_dispatch();
if ( rmtp ) {
300219cc: 1a000024 bne 30021a64 <nanosleep+0xec> <== NOT EXECUTED 300219d0: ea000022 b 30021a60 <nanosleep+0xe8> <== NOT EXECUTED
/*
* Block for the desired amount of time
*/
_Thread_Disable_dispatch();
_Thread_Set_state(
300219d4: e59f6094 ldr r6, [pc, #148] ; 30021a70 <nanosleep+0xf8> <== NOT EXECUTED
}
/*
* Block for the desired amount of time
*/
_Thread_Disable_dispatch();
300219d8: ebffffe0 bl 30021960 <_Thread_Disable_dispatch> <== NOT EXECUTED
_Thread_Set_state(
300219dc: e5960004 ldr r0, [r6, #4] <== NOT EXECUTED 300219e0: e3a01281 mov r1, #268435464 ; 0x10000008 <== NOT EXECUTED 300219e4: ebffac4d bl 3000cb20 <_Thread_Set_state> <== NOT EXECUTED
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
&_Thread_Executing->Timer,
300219e8: e5961004 ldr r1, [r6, #4] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
300219ec: e59f0080 ldr r0, [pc, #128] ; 30021a74 <nanosleep+0xfc> <== NOT EXECUTED
_Thread_Disable_dispatch();
_Thread_Set_state(
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
300219f0: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
300219f4: e3a03000 mov r3, #0 <== NOT EXECUTED 300219f8: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED
the_watchdog->routine = routine;
300219fc: e5810064 str r0, [r1, #100] ; 0x64 <== NOT EXECUTED
the_watchdog->id = id;
30021a00: e5812068 str r2, [r1, #104] ; 0x68 <== NOT EXECUTED
the_watchdog->user_data = user_data;
30021a04: e581306c str r3, [r1, #108] ; 0x6c <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30021a08: e5815054 str r5, [r1, #84] ; 0x54 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30021a0c: e59f0064 ldr r0, [pc, #100] ; 30021a78 <nanosleep+0x100> <== NOT EXECUTED 30021a10: e2811048 add r1, r1, #72 ; 0x48 <== NOT EXECUTED 30021a14: ebffad9f bl 3000d098 <_Watchdog_Insert> <== NOT EXECUTED
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
_Thread_Enable_dispatch();
30021a18: ebffaa31 bl 3000c2e4 <_Thread_Enable_dispatch> <== NOT EXECUTED
/* calculate time remaining */
if ( rmtp ) {
30021a1c: e3540000 cmp r4, #0 <== NOT EXECUTED 30021a20: 0a00000e beq 30021a60 <nanosleep+0xe8> <== NOT EXECUTED
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
30021a24: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED
_Timespec_From_ticks( ticks, rmtp );
30021a28: e1a01004 mov r1, r4 <== NOT EXECUTED
/* calculate time remaining */
if ( rmtp ) {
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
30021a2c: e593205c ldr r2, [r3, #92] ; 0x5c <== NOT EXECUTED 30021a30: e5933060 ldr r3, [r3, #96] ; 0x60 <== NOT EXECUTED 30021a34: e0633002 rsb r3, r3, r2 <== NOT EXECUTED
_Thread_Enable_dispatch();
/* calculate time remaining */
if ( rmtp ) {
ticks -=
30021a38: e0835005 add r5, r3, r5 <== NOT EXECUTED
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
_Timespec_From_ticks( ticks, rmtp );
30021a3c: e1a00005 mov r0, r5 <== NOT EXECUTED 30021a40: eb00001b bl 30021ab4 <_Timespec_From_ticks> <== NOT EXECUTED
*/
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
30021a44: e3550000 cmp r5, #0 <== NOT EXECUTED 30021a48: 0a000005 beq 30021a64 <nanosleep+0xec> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINTR );
30021a4c: ebffc416 bl 30012aac <__errno> <== NOT EXECUTED 30021a50: e3a03004 mov r3, #4 <== NOT EXECUTED 30021a54: e5803000 str r3, [r0] <== NOT EXECUTED 30021a58: e3e05000 mvn r5, #0 <== NOT EXECUTED 30021a5c: ea000000 b 30021a64 <nanosleep+0xec> <== NOT EXECUTED
#endif
}
return 0;
30021a60: e1a05004 mov r5, r4 <== NOT EXECUTED
}
30021a64: e1a00005 mov r0, r5 <== NOT EXECUTED
30021a68: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30006b04 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
30006b04: e92d4010 push {r4, lr}
30006b08: e1a04000 mov r4, r0
switch ( fileno(fp) ) {
30006b0c: eb002a6f bl 300114d0 <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: eb0029aa bl 300111fc <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: eb001bb5 bl 3000dcf8 <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: eb002c8e bl 3001206c <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: eb002899 bl 300110c4 <__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: eb00288a bl 300110c4 <__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: eb002c6f bl 3001206c <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: eb001b62 bl 3000dc7c <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: eb002862 bl 300110c4 <__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: eb001afb bl 3000db60 <ftruncate>
if ( rc ) {
30006f70: e2505000 subs r5, r0, #0
30006f74: 0a00001f beq 30006ff8 <open+0x210>
if(errno) rc = errno;
30006f78: eb002851 bl 300110c4 <__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: eb00284d bl 300110c4 <__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: eb001acb bl 3000dae0 <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: 1b001b6e blne 3000dd98 <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: eb002835 bl 300110c4 <__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
3000b394 <pause>:
/*
* 3.4.2 Suspend Process Execution, P1003.1b-1993, p. 81
*/
int pause( void )
{
3000b394: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
sigset_t all_signals;
int status;
(void) sigfillset( &all_signals );
3000b398: e1a0000d mov r0, sp <== NOT EXECUTED 3000b39c: eb000310 bl 3000bfe4 <sigfillset> <== NOT EXECUTED
status = sigtimedwait( &all_signals, NULL, NULL );
3000b3a0: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b3a4: e1a0000d mov r0, sp <== NOT EXECUTED 3000b3a8: e1a02001 mov r2, r1 <== NOT EXECUTED
int pause( void )
{
sigset_t all_signals;
int status;
(void) sigfillset( &all_signals );
3000b3ac: e1a0400d mov r4, sp <== NOT EXECUTED
status = sigtimedwait( &all_signals, NULL, NULL );
3000b3b0: eb000371 bl 3000c17c <sigtimedwait> <== NOT EXECUTED
return status;
}
3000b3b4: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
30008430 <pipe>:
int pipe(
int filsdes[2]
)
{
if (filsdes == NULL)
30008430: e3500000 cmp r0, #0 <== NOT EXECUTED
extern int pipe_create(int filsdes[2]);
int pipe(
int filsdes[2]
)
{
30008434: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if (filsdes == NULL)
30008438: 1a000004 bne 30008450 <pipe+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
3000843c: eb0029b4 bl 30012b14 <__errno> <== NOT EXECUTED 30008440: e3a0300e mov r3, #14 <== NOT EXECUTED 30008444: e5803000 str r3, [r0] <== NOT EXECUTED
return pipe_create(filsdes);
}
30008448: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000844c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30008450: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
)
{
if (filsdes == NULL)
rtems_set_errno_and_return_minus_one( EFAULT );
return pipe_create(filsdes);
30008454: ea001a22 b 3000ece4 <pipe_create> <== NOT EXECUTED
3000ece4 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
3000ece4: e92d407f push {r0, r1, r2, r3, r4, r5, r6, lr} <== NOT EXECUTED
3000ece8: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
3000ecec: e59f10f8 ldr r1, [pc, #248] ; 3000edec <pipe_create+0x108> <== NOT EXECUTED 3000ecf0: e59f00f8 ldr r0, [pc, #248] ; 3000edf0 <pipe_create+0x10c> <== NOT EXECUTED 3000ecf4: eb000547 bl 30010218 <rtems_mkdir> <== NOT EXECUTED 3000ecf8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ecfc: 1a000037 bne 3000ede0 <pipe_create+0xfc> <== NOT EXECUTED
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
3000ed00: e59f10ec ldr r1, [pc, #236] ; 3000edf4 <pipe_create+0x110> <== NOT EXECUTED 3000ed04: e3a0200a mov r2, #10 <== NOT EXECUTED 3000ed08: e1a0000d mov r0, sp <== NOT EXECUTED 3000ed0c: eb0011ae bl 300133cc <memcpy> <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
3000ed10: e59f30e0 ldr r3, [pc, #224] ; 3000edf8 <pipe_create+0x114> <== NOT EXECUTED 3000ed14: e28d000a add r0, sp, #10 <== NOT EXECUTED 3000ed18: 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);
3000ed1c: e1a0400d mov r4, sp <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
3000ed20: e2821001 add r1, r2, #1 <== NOT EXECUTED 3000ed24: e1c310b0 strh r1, [r3] <== NOT EXECUTED 3000ed28: e59f10cc ldr r1, [pc, #204] ; 3000edfc <pipe_create+0x118> <== NOT EXECUTED 3000ed2c: eb001237 bl 30013610 <sprintf> <== NOT EXECUTED
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
3000ed30: e1a0000d mov r0, sp <== NOT EXECUTED 3000ed34: e3a01d06 mov r1, #384 ; 0x180 <== NOT EXECUTED 3000ed38: eb0004a1 bl 3000ffc4 <mkfifo> <== NOT EXECUTED 3000ed3c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000ed40: 0a000001 beq 3000ed4c <pipe_create+0x68> <== NOT EXECUTED
if (errno != EEXIST){
3000ed44: eb000f72 bl 30012b14 <__errno> <== NOT EXECUTED 3000ed48: ea000024 b 3000ede0 <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);
3000ed4c: e1a0000d mov r0, sp <== NOT EXECUTED 3000ed50: e3a01901 mov r1, #16384 ; 0x4000 <== NOT EXECUTED 3000ed54: ebffe521 bl 300081e0 <open> <== NOT EXECUTED
if (filsdes[0] < 0) {
3000ed58: 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);
3000ed5c: e5850000 str r0, [r5] <== NOT EXECUTED
if (filsdes[0] < 0) {
3000ed60: aa000002 bge 3000ed70 <pipe_create+0x8c> <== NOT EXECUTED
err = errno;
3000ed64: eb000f6a bl 30012b14 <__errno> <== NOT EXECUTED 3000ed68: e5906000 ldr r6, [r0] <== NOT EXECUTED 3000ed6c: ea000014 b 3000edc4 <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]);
3000ed70: e59f3088 ldr r3, [pc, #136] ; 3000ee00 <pipe_create+0x11c> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
3000ed74: 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]);
3000ed78: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000ed7c: e1500003 cmp r0, r3 <== NOT EXECUTED 3000ed80: 359f307c ldrcc r3, [pc, #124] ; 3000ee04 <pipe_create+0x120><== NOT EXECUTED 3000ed84: 33a06038 movcc r6, #56 ; 0x38 <== NOT EXECUTED 3000ed88: 35933000 ldrcc r3, [r3] <== NOT EXECUTED 3000ed8c: 30263690 mlacc r6, r0, r6, r3 <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
3000ed90: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
filsdes[1] = open(fifopath, O_WRONLY);
3000ed94: 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;
3000ed98: e3c33001 bic r3, r3, #1 <== NOT EXECUTED 3000ed9c: e5863014 str r3, [r6, #20] <== NOT EXECUTED
filsdes[1] = open(fifopath, O_WRONLY);
3000eda0: ebffe50e bl 300081e0 <open> <== NOT EXECUTED
if (filsdes[1] < 0) {
3000eda4: 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);
3000eda8: e5850004 str r0, [r5, #4] <== NOT EXECUTED
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
3000edac: 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) {
3000edb0: aa000003 bge 3000edc4 <pipe_create+0xe0> <== NOT EXECUTED
err = errno;
3000edb4: eb000f56 bl 30012b14 <__errno> <== NOT EXECUTED 3000edb8: e5906000 ldr r6, [r0] <== NOT EXECUTED
close(filsdes[0]);
3000edbc: e5950000 ldr r0, [r5] <== NOT EXECUTED 3000edc0: ebffe11b bl 30007234 <close> <== NOT EXECUTED
}
unlink(fifopath);
3000edc4: e1a0000d mov r0, sp <== NOT EXECUTED 3000edc8: ebffec83 bl 30009fdc <unlink> <== NOT EXECUTED
} if(err != 0)
3000edcc: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(err);
return 0;
3000edd0: 01a00006 moveq r0, r6 <== NOT EXECUTED
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
3000edd4: 0a000002 beq 3000ede4 <pipe_create+0x100> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(err);
3000edd8: eb000f4d bl 30012b14 <__errno> <== NOT EXECUTED 3000eddc: e5806000 str r6, [r0] <== NOT EXECUTED 3000ede0: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0; }
3000ede4: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000ede8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300101d4 <pipe_ioctl>:
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
300101d4: e59f3058 ldr r3, [pc, #88] ; 30010234 <pipe_ioctl+0x60> <== NOT EXECUTED
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
300101d8: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if (cmd == FIONREAD) {
300101dc: e1510003 cmp r1, r3 <== NOT EXECUTED
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
300101e0: e1a04000 mov r4, r0 <== NOT EXECUTED 300101e4: e1a05002 mov r5, r2 <== NOT EXECUTED
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
300101e8: 13e00015 mvnne r0, #21 <== NOT EXECUTED
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
300101ec: 18bd8070 popne {r4, r5, r6, pc} <== NOT EXECUTED
if (buffer == NULL)
300101f0: e3520000 cmp r2, #0 <== NOT EXECUTED
return -EFAULT;
300101f4: 03e0000d mvneq r0, #13 <== NOT EXECUTED
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
300101f8: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return -EFAULT;
if (! PIPE_LOCK(pipe))
300101fc: e3a01000 mov r1, #0 <== NOT EXECUTED 30010200: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 30010204: e1a02001 mov r2, r1 <== NOT EXECUTED 30010208: ebffecb0 bl 3000b4d0 <rtems_semaphore_obtain> <== NOT EXECUTED 3001020c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30010210: 1a000005 bne 3001022c <pipe_ioctl+0x58> <== NOT EXECUTED
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
30010214: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010218: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
3001021c: e5853000 str r3, [r5] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010220: ebffecf0 bl 3000b5e8 <rtems_semaphore_release> <== NOT EXECUTED
return 0;
30010224: e1a00006 mov r0, r6 <== NOT EXECUTED
30010228: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
return -EINTR;
3001022c: e3e00003 mvn r0, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
30010230: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30010238 <pipe_lseek>:
rtems_libio_t *iop
)
{
/* Seek on pipe is not supported */
return -ESPIPE;
}
30010238: e3e0001c mvn r0, #28 <== NOT EXECUTED 3001023c: e12fff1e bx lr <== NOT EXECUTED
3000fea8 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000fea8: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000feac: e1a09001 mov r9, r1
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000feb0: e3a01000 mov r1, #0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000feb4: e1a04000 mov r4, r0 3000feb8: e1a05002 mov r5, r2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000febc: e5900028 ldr r0, [r0, #40] ; 0x28 3000fec0: e1a02001 mov r2, r1
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3000fec4: e1a0a003 mov sl, r3
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000fec8: ebffed80 bl 3000b4d0 <rtems_semaphore_obtain> 3000fecc: e2506000 subs r6, r0, #0
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
3000fed0: 01a0b00d moveq fp, sp
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
3000fed4: 0a000043 beq 3000ffe8 <pipe_read+0x140>
3000fed8: ea00004f b 3001001c <pipe_read+0x174> <== NOT EXECUTED
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
3000fedc: e5947014 ldr r7, [r4, #20] 3000fee0: e3570000 cmp r7, #0
3000fee4: 0a000044 beq 3000fffc <pipe_read+0x154>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
3000fee8: e59a8014 ldr r8, [sl, #20] 3000feec: e2188001 ands r8, r8, #1
3000fef0: 1a000040 bne 3000fff8 <pipe_read+0x150>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
3000fef4: e5943018 ldr r3, [r4, #24]
PIPE_UNLOCK(pipe);
3000fef8: e5940028 ldr r0, [r4, #40] ; 0x28
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
3000fefc: e2833001 add r3, r3, #1 3000ff00: e5843018 str r3, [r4, #24]
PIPE_UNLOCK(pipe);
3000ff04: ebffedb7 bl 3000b5e8 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
3000ff08: e1a01008 mov r1, r8 3000ff0c: e594002c ldr r0, [r4, #44] ; 0x2c 3000ff10: eb0005b4 bl 300115e8 <rtems_barrier_wait> 3000ff14: e3500000 cmp r0, #0 3000ff18: 01a07000 moveq r7, r0 3000ff1c: 13e07003 mvnne r7, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
3000ff20: e1a01008 mov r1, r8 3000ff24: e5940028 ldr r0, [r4, #40] ; 0x28 3000ff28: e1a02008 mov r2, r8 3000ff2c: ebffed67 bl 3000b4d0 <rtems_semaphore_obtain> 3000ff30: e3500000 cmp r0, #0
3000ff34: 1a000033 bne 30010008 <pipe_read+0x160>
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
3000ff38: e5943018 ldr r3, [r4, #24]
if (ret != 0)
3000ff3c: e3570000 cmp r7, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
3000ff40: e2433001 sub r3, r3, #1 3000ff44: e5843018 str r3, [r4, #24]
if (ret != 0)
3000ff48: 1a00002b bne 3000fffc <pipe_read+0x154>
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
3000ff4c: e594300c ldr r3, [r4, #12] 3000ff50: e3530000 cmp r3, #0
3000ff54: 0affffe0 beq 3000fedc <pipe_read+0x34>
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
3000ff58: e0667005 rsb r7, r6, r5 3000ff5c: e1530007 cmp r3, r7 3000ff60: 31a07003 movcc r7, r3
chunk1 = pipe->Size - pipe->Start;
3000ff64: e5948004 ldr r8, [r4, #4] 3000ff68: e5943008 ldr r3, [r4, #8] 3000ff6c: e5941000 ldr r1, [r4] 3000ff70: e0638008 rsb r8, r3, r8
if (chunk > chunk1) {
3000ff74: e1570008 cmp r7, r8 3000ff78: 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);
3000ff7c: d0811003 addle r1, r1, r3 3000ff80: d1a02007 movle r2, r7
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
3000ff84: da000006 ble 3000ffa4 <pipe_read+0xfc>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
3000ff88: e0811003 add r1, r1, r3 3000ff8c: e1a02008 mov r2, r8 3000ff90: eb0010ba bl 30014280 <memcpy>
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
3000ff94: e0860008 add r0, r6, r8 3000ff98: e5941000 ldr r1, [r4] 3000ff9c: e0890000 add r0, r9, r0 3000ffa0: e0682007 rsb r2, r8, r7
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
3000ffa4: eb0010b5 bl 30014280 <memcpy>
pipe->Start += chunk;
3000ffa8: e5940008 ldr r0, [r4, #8]
pipe->Start %= pipe->Size;
3000ffac: e5941004 ldr r1, [r4, #4] 3000ffb0: e0870000 add r0, r7, r0 3000ffb4: eb004012 bl 30020004 <__umodsi3>
pipe->Length -= chunk;
3000ffb8: e594300c ldr r3, [r4, #12]
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
3000ffbc: e5840008 str r0, [r4, #8]
pipe->Length -= chunk;
3000ffc0: e0673003 rsb r3, r7, r3
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
3000ffc4: e3530000 cmp r3, #0
pipe->Start = 0;
3000ffc8: 05843008 streq r3, [r4, #8]
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
pipe->Length -= chunk;
3000ffcc: e584300c str r3, [r4, #12]
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
3000ffd0: e594301c ldr r3, [r4, #28] 3000ffd4: e3530000 cmp r3, #0
PIPE_WAKEUPWRITERS(pipe);
3000ffd8: 15940030 ldrne r0, [r4, #48] ; 0x30 3000ffdc: 11a0100d movne r1, sp 3000ffe0: 1b00056a blne 30011590 <rtems_barrier_release>
read += chunk;
3000ffe4: e0866007 add r6, r6, r7
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
3000ffe8: e1560005 cmp r6, r5
3000ffec: 3affffd6 bcc 3000ff4c <pipe_read+0xa4>
3000fff0: e3a07000 mov r7, #0 3000fff4: ea000000 b 3000fffc <pipe_read+0x154>
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
3000fff8: e3e0700a mvn r7, #10
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
3000fffc: e5940028 ldr r0, [r4, #40] ; 0x28 30010000: ebffed78 bl 3000b5e8 <rtems_semaphore_release> 30010004: ea000000 b 3001000c <pipe_read+0x164>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
30010008: e3e07003 mvn r7, #3 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
3001000c: e3560000 cmp r6, #0 30010010: c1a00006 movgt r0, r6 30010014: d1a00007 movle r0, r7 30010018: ea000000 b 30010020 <pipe_read+0x178>
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
3001001c: e3e00003 mvn r0, #3 <== NOT EXECUTED
out_nolock:
if (read > 0)
return read;
return ret;
}
30010020: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000fa10 <pipe_release>:
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
3000fa10: e5913014 ldr r3, [r1, #20]
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000fa14: e92d40f1 push {r0, r4, r5, r6, r7, lr}
pipe_control_t *pipe = *pipep;
3000fa18: e5904000 ldr r4, [r0]
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
3000fa1c: e3130002 tst r3, #2
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
3000fa20: e2036006 and r6, r3, #6
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
3000fa24: 15943010 ldrne r3, [r4, #16]
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3000fa28: e1a05000 mov r5, r0
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
3000fa2c: 12433001 subne r3, r3, #1 3000fa30: 15843010 strne r3, [r4, #16]
if (mode & LIBIO_FLAGS_WRITE)
3000fa34: e3160004 tst r6, #4
pipe->Writers --;
3000fa38: 15943014 ldrne r3, [r4, #20]
PIPE_UNLOCK(pipe);
3000fa3c: e5940028 ldr r0, [r4, #40] ; 0x28
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
3000fa40: 12433001 subne r3, r3, #1 3000fa44: 15843014 strne r3, [r4, #20]
PIPE_UNLOCK(pipe);
3000fa48: ebffeee6 bl 3000b5e8 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
3000fa4c: e5943010 ldr r3, [r4, #16] 3000fa50: e3530000 cmp r3, #0
3000fa54: 1a000006 bne 3000fa74 <pipe_release+0x64>
3000fa58: e5947014 ldr r7, [r4, #20] 3000fa5c: e3570000 cmp r7, #0
3000fa60: 1a000003 bne 3000fa74 <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);
3000fa64: e1a00004 mov r0, r4 3000fa68: ebffffdb bl 3000f9dc <pipe_free>
*pipep = NULL;
3000fa6c: e5857000 str r7, [r5] 3000fa70: ea000010 b 3000fab8 <pipe_release+0xa8>
} else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
3000fa74: e2562004 subs r2, r6, #4 3000fa78: 13a02001 movne r2, #1 3000fa7c: e3530000 cmp r3, #0 3000fa80: 13a02000 movne r2, #0 3000fa84: e3520000 cmp r2, #0
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
3000fa88: 15940030 ldrne r0, [r4, #48] ; 0x30
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
3000fa8c: 1a000007 bne 3000fab0 <pipe_release+0xa0>
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
3000fa90: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000fa94: e2566002 subs r6, r6, #2 <== NOT EXECUTED 3000fa98: 13a06001 movne r6, #1 <== NOT EXECUTED 3000fa9c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000faa0: 13a06000 movne r6, #0 <== NOT EXECUTED 3000faa4: e3560000 cmp r6, #0 <== NOT EXECUTED 3000faa8: 0a000002 beq 3000fab8 <pipe_release+0xa8> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
3000faac: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
3000fab0: e1a0100d mov r1, sp 3000fab4: eb0006b5 bl 30011590 <rtems_barrier_release>
pipe_unlock();
3000fab8: ebffffc3 bl 3000f9cc <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
3000fabc: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
30010024 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010024: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
30010028: e2527000 subs r7, r2, #0
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
3001002c: e1a04000 mov r4, r0 30010030: e1a0b001 mov fp, r1 30010034: e1a08003 mov r8, r3
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
30010038: 01a00007 moveq r0, r7
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
3001003c: 0a000063 beq 300101d0 <pipe_write+0x1ac>
return 0;
if (! PIPE_LOCK(pipe))
30010040: e3a01000 mov r1, #0 30010044: e5940028 ldr r0, [r4, #40] ; 0x28 30010048: e1a02001 mov r2, r1 3001004c: ebffed1f bl 3000b4d0 <rtems_semaphore_obtain> 30010050: e3500000 cmp r0, #0
return -EINTR;
30010054: 13e00003 mvnne r0, #3
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
30010058: 1a00005c bne 300101d0 <pipe_write+0x1ac>
return -EINTR;
if (pipe->Readers == 0) {
3001005c: e5945010 ldr r5, [r4, #16] 30010060: e3550000 cmp r5, #0
30010064: 0a00004c beq 3001019c <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;
30010068: 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;
3001006c: 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;
30010070: e1570009 cmp r7, r9 30010074: 91a09007 movls r9, r7 30010078: 83a09001 movhi r9, #1 3001007c: ea000040 b 30010184 <pipe_write+0x160>
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
30010080: e598a014 ldr sl, [r8, #20] 30010084: e21aa001 ands sl, sl, #1
30010088: 1a000041 bne 30010194 <pipe_write+0x170>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
3001008c: e594301c ldr r3, [r4, #28]
PIPE_UNLOCK(pipe);
30010090: e5940028 ldr r0, [r4, #40] ; 0x28
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
30010094: e2833001 add r3, r3, #1 30010098: e584301c str r3, [r4, #28]
PIPE_UNLOCK(pipe);
3001009c: ebffed51 bl 3000b5e8 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
300100a0: e1a0100a mov r1, sl 300100a4: e5940030 ldr r0, [r4, #48] ; 0x30 300100a8: eb00054e bl 300115e8 <rtems_barrier_wait> 300100ac: e3500000 cmp r0, #0 300100b0: 01a06000 moveq r6, r0 300100b4: 13e06003 mvnne r6, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
300100b8: e1a0100a mov r1, sl 300100bc: e5940028 ldr r0, [r4, #40] ; 0x28 300100c0: e1a0200a mov r2, sl 300100c4: ebffed01 bl 3000b4d0 <rtems_semaphore_obtain> 300100c8: e3500000 cmp r0, #0
300100cc: 1a00003b bne 300101c0 <pipe_write+0x19c>
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
300100d0: e594301c ldr r3, [r4, #28]
if (ret != 0)
300100d4: e3560000 cmp r6, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
300100d8: e2433001 sub r3, r3, #1 300100dc: e584301c str r3, [r4, #28]
if (ret != 0)
300100e0: 1a00002e bne 300101a0 <pipe_write+0x17c>
goto out_locked;
if (pipe->Readers == 0) {
300100e4: e5943010 ldr r3, [r4, #16] 300100e8: e3530000 cmp r3, #0
300100ec: 0a00002a beq 3001019c <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) {
300100f0: e594a004 ldr sl, [r4, #4] 300100f4: e594300c ldr r3, [r4, #12] 300100f8: e063200a rsb r2, r3, sl 300100fc: e1520009 cmp r2, r9
30010100: 3affffde bcc 30010080 <pipe_write+0x5c>
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
30010104: e5940008 ldr r0, [r4, #8] 30010108: e1a0100a mov r1, sl 3001010c: e0830000 add r0, r3, r0
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
30010110: e0656007 rsb r6, r5, r7 30010114: e1520006 cmp r2, r6 30010118: 31a06002 movcc r6, r2
chunk1 = pipe->Size - PIPE_WSTART(pipe);
3001011c: eb003fb8 bl 30020004 <__umodsi3> 30010120: e5943000 ldr r3, [r4] 30010124: e060a00a rsb sl, r0, sl
if (chunk > chunk1) {
30010128: e156000a cmp r6, sl 3001012c: 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);
30010130: d0830000 addle r0, r3, r0 30010134: d1a02006 movle r2, r6
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
30010138: da000006 ble 30010158 <pipe_write+0x134>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
3001013c: e1a0200a mov r2, sl 30010140: e0830000 add r0, r3, r0 30010144: eb00104d bl 30014280 <memcpy>
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
30010148: e08a1005 add r1, sl, r5 3001014c: e5940000 ldr r0, [r4] 30010150: e08b1001 add r1, fp, r1 30010154: e06a2006 rsb r2, sl, r6
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
30010158: eb001048 bl 30014280 <memcpy>
pipe->Length += chunk;
3001015c: e594300c ldr r3, [r4, #12] 30010160: e0833006 add r3, r3, r6 30010164: e584300c str r3, [r4, #12]
if (pipe->waitingReaders > 0)
30010168: e5943018 ldr r3, [r4, #24] 3001016c: e3530000 cmp r3, #0
PIPE_WAKEUPREADERS(pipe);
30010170: 1594002c ldrne r0, [r4, #44] ; 0x2c 30010174: 11a0100d movne r1, sp 30010178: 1b000504 blne 30011590 <rtems_barrier_release>
written += chunk;
3001017c: e0855006 add r5, r5, r6
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
30010180: e3a09001 mov r9, #1
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
30010184: e1550007 cmp r5, r7
30010188: 3affffd8 bcc 300100f0 <pipe_write+0xcc>
3001018c: e3a06000 mov r6, #0 30010190: ea000002 b 300101a0 <pipe_write+0x17c>
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
30010194: e3e0600a mvn r6, #10 30010198: ea000000 b 300101a0 <pipe_write+0x17c>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
3001019c: e3e0601f mvn r6, #31
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
300101a0: e5940028 ldr r0, [r4, #40] ; 0x28 300101a4: ebffed0f bl 3000b5e8 <rtems_semaphore_release>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
300101a8: e3760020 cmn r6, #32
300101ac: 1a000004 bne 300101c4 <pipe_write+0x1a0>
kill(getpid(), SIGPIPE);
300101b0: eb0001f1 bl 3001097c <getpid> 300101b4: e3a0100d mov r1, #13 300101b8: eb0002a4 bl 30010c50 <kill> 300101bc: ea000000 b 300101c4 <pipe_write+0x1a0>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
300101c0: e3e06003 mvn r6, #3 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
300101c4: e3550000 cmp r5, #0 300101c8: c1a00005 movgt r0, r5 300101cc: d1a00006 movle r0, r6
return written;
return ret;
}
300101d0: 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
30008404 <printk_plugin>:
int printk_plugin(
void *ignored __attribute__((unused)),
const char *format,
...
)
{
30008404: e92d000e push {r1, r2, r3} <== NOT EXECUTED
30008408: e92d4001 push {r0, lr} <== NOT EXECUTED
va_list arg_pointer;
va_start (arg_pointer, format);
vprintk( format, arg_pointer );
3000840c: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
...
)
{
va_list arg_pointer;
va_start (arg_pointer, format);
30008410: e28d100c add r1, sp, #12 <== NOT EXECUTED 30008414: e58d1000 str r1, [sp] <== NOT EXECUTED
vprintk( format, arg_pointer );
30008418: eb0006c8 bl 30009f40 <vprintk> <== NOT EXECUTED
va_end(arg_pointer); /* clean up when done */
return 0;
}
3000841c: e3a00000 mov r0, #0 <== NOT EXECUTED
30008420: e8bd4008 pop {r3, lr} <== NOT EXECUTED
30008424: e28dd00c add sp, sp, #12 <== NOT EXECUTED
30008428: e12fff1e bx lr <== NOT EXECUTED
3000934c <pthread_atfork>:
int pthread_atfork(
void (*prepare)(void) __attribute__((unused)),
void (*parent)(void) __attribute__((unused)),
void (*child)(void) __attribute__((unused))
)
{
3000934c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009350: eb0021a0 bl 300119d8 <__errno> <== NOT EXECUTED 30009354: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009358: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000935c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009360: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000e4ec <pthread_attr_destroy>:
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000e4ec: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e4f0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000e4f4: 012fff1e bxeq lr <== NOT EXECUTED 3000e4f8: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000e4fc: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000e500: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e504: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e508: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000e50c: e12fff1e bx lr <== NOT EXECUTED
3000ec28 <pthread_attr_getcputime>:
int pthread_attr_getcputime(
pthread_attr_t *attr,
int *clock_allowed
)
{
if ( !attr || !attr->is_initialized || !clock_allowed )
3000ec28: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000ec2c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getcputime(
pthread_attr_t *attr,
int *clock_allowed
)
{
if ( !attr || !attr->is_initialized || !clock_allowed )
3000ec30: 012fff1e bxeq lr <== NOT EXECUTED 3000ec34: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000ec38: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ec3c: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*clock_allowed = attr->cputime_clock_allowed;
3000ec40: 15933038 ldrne r3, [r3, #56] ; 0x38 <== NOT EXECUTED
int pthread_attr_getcputime(
pthread_attr_t *attr,
int *clock_allowed
)
{
if ( !attr || !attr->is_initialized || !clock_allowed )
3000ec44: 13a00000 movne r0, #0 <== NOT EXECUTED 3000ec48: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*clock_allowed = attr->cputime_clock_allowed;
3000ec4c: 15813000 strne r3, [r1] <== NOT EXECUTED
pthread_attr_t *attr,
int *clock_allowed
)
{
if ( !attr || !attr->is_initialized || !clock_allowed )
return EINVAL;
3000ec50: 03a00016 moveq r0, #22 <== NOT EXECUTED
*clock_allowed = attr->cputime_clock_allowed;
return 0;
}
3000ec54: e12fff1e bx lr <== NOT EXECUTED
3000e510 <pthread_attr_getdetachstate>:
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000e510: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e514: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000e518: 012fff1e bxeq lr <== NOT EXECUTED 3000e51c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e520: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e524: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*detachstate = attr->detachstate;
3000e528: 1593303c ldrne r3, [r3, #60] ; 0x3c <== NOT EXECUTED
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000e52c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e530: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*detachstate = attr->detachstate;
3000e534: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
return EINVAL;
3000e538: 03a00016 moveq r0, #22 <== NOT EXECUTED
*detachstate = attr->detachstate;
return 0;
}
3000e53c: e12fff1e bx lr <== NOT EXECUTED
3000e540 <pthread_attr_getguardsize>:
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000e540: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e544: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000e548: 012fff1e bxeq lr <== NOT EXECUTED 3000e54c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e550: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e554: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*guardsize = attr->guardsize;
3000e558: 15933034 ldrne r3, [r3, #52] ; 0x34 <== NOT EXECUTED
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000e55c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e560: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*guardsize = attr->guardsize;
3000e564: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
return EINVAL;
3000e568: 03a00016 moveq r0, #22 <== NOT EXECUTED
*guardsize = attr->guardsize;
return 0;
}
3000e56c: e12fff1e bx lr <== NOT EXECUTED
3000e570 <pthread_attr_getinheritsched>:
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000e570: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e574: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000e578: 012fff1e bxeq lr <== NOT EXECUTED 3000e57c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e580: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e584: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*inheritsched = attr->inheritsched;
3000e588: 15933010 ldrne r3, [r3, #16] <== NOT EXECUTED
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000e58c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e590: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*inheritsched = attr->inheritsched;
3000e594: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
3000e598: 03a00016 moveq r0, #22 <== NOT EXECUTED
*inheritsched = attr->inheritsched;
return 0;
}
3000e59c: e12fff1e bx lr <== NOT EXECUTED
3000e5a0 <pthread_attr_getschedparam>:
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000e5a0: e3500000 cmp r0, #0 <== NOT EXECUTED
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
3000e5a4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
3000e5a8: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
3000e5ac: e1a04001 mov r4, r1 <== NOT EXECUTED
if ( !attr || !attr->is_initialized || !param )
3000e5b0: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
3000e5b4: e5905000 ldr r5, [r0] <== NOT EXECUTED
3000e5b8: e3550000 cmp r5, #0 <== NOT EXECUTED
3000e5bc: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*param = attr->schedparam;
3000e5c0: 1280c018 addne ip, r0, #24 <== NOT EXECUTED
3000e5c4: 18bc000f ldmne ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000e5c8: 18a4000f stmiane r4!, {r0, r1, r2, r3} <== NOT EXECUTED
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000e5cc: 13a05000 movne r5, #0 <== NOT EXECUTED 3000e5d0: 03a05001 moveq r5, #1 <== NOT EXECUTED
return EINVAL;
*param = attr->schedparam;
3000e5d4: 11a03004 movne r3, r4 <== NOT EXECUTED
3000e5d8: 189c0007 ldmne ip, {r0, r1, r2} <== NOT EXECUTED
const pthread_attr_t *attr,
struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
3000e5dc: 03a00016 moveq r0, #22 <== NOT EXECUTED
*param = attr->schedparam;
3000e5e0: 18830007 stmne r3, {r0, r1, r2} <== NOT EXECUTED
return 0;
3000e5e4: 11a00005 movne r0, r5 <== NOT EXECUTED
}
3000e5e8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000e5ec <pthread_attr_getschedpolicy>:
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000e5ec: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e5f0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000e5f4: 012fff1e bxeq lr <== NOT EXECUTED 3000e5f8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e5fc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e600: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*policy = attr->schedpolicy;
3000e604: 15933014 ldrne r3, [r3, #20] <== NOT EXECUTED
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000e608: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e60c: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*policy = attr->schedpolicy;
3000e610: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
return EINVAL;
3000e614: 03a00016 moveq r0, #22 <== NOT EXECUTED
*policy = attr->schedpolicy;
return 0;
}
3000e618: e12fff1e bx lr <== NOT EXECUTED
3000e61c <pthread_attr_getscope>:
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000e61c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e620: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000e624: 012fff1e bxeq lr <== NOT EXECUTED 3000e628: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e62c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e630: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*contentionscope = attr->contentionscope;
3000e634: 1593300c ldrne r3, [r3, #12] <== NOT EXECUTED
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000e638: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e63c: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*contentionscope = attr->contentionscope;
3000e640: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
return EINVAL;
3000e644: 03a00016 moveq r0, #22 <== NOT EXECUTED
*contentionscope = attr->contentionscope;
return 0;
}
3000e648: e12fff1e bx lr <== NOT EXECUTED
3000e67c <pthread_attr_getstack>:
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
3000e67c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000e680: 0a00000c beq 3000e6b8 <pthread_attr_getstack+0x3c> <== NOT EXECUTED 3000e684: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e688: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e68c: 13510000 cmpne r1, #0 <== NOT EXECUTED 3000e690: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e694: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000e698: 0a000006 beq 3000e6b8 <pthread_attr_getstack+0x3c> <== NOT EXECUTED 3000e69c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000e6a0: 0a000006 beq 3000e6c0 <pthread_attr_getstack+0x44> <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
3000e6a4: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED
*stacksize = attr->stacksize;
3000e6a8: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
*stackaddr = attr->stackaddr;
3000e6ac: e581c000 str ip, [r1] <== NOT EXECUTED
*stacksize = attr->stacksize;
3000e6b0: e5823000 str r3, [r2] <== NOT EXECUTED
return 0;
3000e6b4: e12fff1e bx lr <== NOT EXECUTED
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
3000e6b8: e3a00016 mov r0, #22 <== NOT EXECUTED 3000e6bc: e12fff1e bx lr <== NOT EXECUTED 3000e6c0: e3a00016 mov r0, #22 <== NOT EXECUTED
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
return 0;
}
3000e6c4: e12fff1e bx lr <== NOT EXECUTED
3000e64c <pthread_attr_getstackaddr>:
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000e64c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e650: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000e654: 012fff1e bxeq lr <== NOT EXECUTED 3000e658: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e65c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e660: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
3000e664: 15933004 ldrne r3, [r3, #4] <== NOT EXECUTED
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000e668: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e66c: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
3000e670: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
return EINVAL;
3000e674: 03a00016 moveq r0, #22 <== NOT EXECUTED
*stackaddr = attr->stackaddr;
return 0;
}
3000e678: e12fff1e bx lr <== NOT EXECUTED
3000e6c8 <pthread_attr_getstacksize>:
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000e6c8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000e6cc: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000e6d0: 012fff1e bxeq lr <== NOT EXECUTED 3000e6d4: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000e6d8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e6dc: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*stacksize = attr->stacksize;
3000e6e0: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000e6e4: 13a00000 movne r0, #0 <== NOT EXECUTED 3000e6e8: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*stacksize = attr->stacksize;
3000e6ec: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
return EINVAL;
3000e6f0: 03a00016 moveq r0, #22 <== NOT EXECUTED
*stacksize = attr->stacksize;
return 0;
}
3000e6f4: e12fff1e bx lr <== NOT EXECUTED
3000fa1c <pthread_attr_init>:
#include <rtems/posix/pthread.h>
int pthread_attr_init(
pthread_attr_t *attr
)
{
3000fa1c: e92d4030 push {r4, r5, lr}
if ( !attr )
3000fa20: e2505000 subs r5, r0, #0
3000fa24: 0a00000b beq 3000fa58 <pthread_attr_init+0x3c>
return EINVAL;
*attr = _POSIX_Threads_Default_attributes;
3000fa28: e59f4030 ldr r4, [pc, #48] ; 3000fa60 <pthread_attr_init+0x44>
3000fa2c: e1a0c005 mov ip, r5
3000fa30: e8b4000f ldm r4!, {r0, r1, r2, r3}
3000fa34: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000fa38: e8b4000f ldm r4!, {r0, r1, r2, r3}
3000fa3c: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000fa40: e8b4000f ldm r4!, {r0, r1, r2, r3}
3000fa44: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000fa48: e894000f ldm r4, {r0, r1, r2, r3}
3000fa4c: e88c000f stm ip, {r0, r1, r2, r3}
return 0;
3000fa50: e3a00000 mov r0, #0
3000fa54: e8bd8030 pop {r4, r5, pc}
int pthread_attr_init(
pthread_attr_t *attr
)
{
if ( !attr )
return EINVAL;
3000fa58: e3a00016 mov r0, #22 <== NOT EXECUTED
*attr = _POSIX_Threads_Default_attributes;
return 0;
}
3000fa5c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000f0d8 <pthread_attr_setcputime>:
int pthread_attr_setcputime(
pthread_attr_t *attr,
int clock_allowed
)
{
if ( !attr || !attr->is_initialized )
3000f0d8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f0dc: 0a000007 beq 3000f100 <pthread_attr_setcputime+0x28> <== NOT EXECUTED 3000f0e0: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000f0e4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f0e8: 0a000004 beq 3000f100 <pthread_attr_setcputime+0x28> <== NOT EXECUTED
return EINVAL;
switch ( clock_allowed ) {
3000f0ec: e3510001 cmp r1, #1 <== NOT EXECUTED
case CLOCK_ENABLED:
case CLOCK_DISABLED:
attr->cputime_clock_allowed = clock_allowed;
3000f0f0: 95801038 strls r1, [r0, #56] ; 0x38 <== NOT EXECUTED
return 0;
3000f0f4: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( clock_allowed ) {
3000f0f8: 912fff1e bxls lr <== NOT EXECUTED 3000f0fc: ea000001 b 3000f108 <pthread_attr_setcputime+0x30> <== NOT EXECUTED
pthread_attr_t *attr,
int clock_allowed
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000f100: e3a00016 mov r0, #22 <== NOT EXECUTED 3000f104: e12fff1e bx lr <== NOT EXECUTED
case CLOCK_DISABLED:
attr->cputime_clock_allowed = clock_allowed;
return 0;
default:
return EINVAL;
3000f108: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000f10c: e12fff1e bx lr <== NOT EXECUTED
3000e740 <pthread_attr_setdetachstate>:
int pthread_attr_setdetachstate(
pthread_attr_t *attr,
int detachstate
)
{
if ( !attr || !attr->is_initialized )
3000e740: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e744: 0a000007 beq 3000e768 <pthread_attr_setdetachstate+0x28> <== NOT EXECUTED 3000e748: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e74c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e750: 0a000004 beq 3000e768 <pthread_attr_setdetachstate+0x28> <== NOT EXECUTED
return EINVAL;
switch ( detachstate ) {
3000e754: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_CREATE_DETACHED:
case PTHREAD_CREATE_JOINABLE:
attr->detachstate = detachstate;
3000e758: 9580103c strls r1, [r0, #60] ; 0x3c <== NOT EXECUTED
return 0;
3000e75c: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( detachstate ) {
3000e760: 912fff1e bxls lr <== NOT EXECUTED 3000e764: ea000001 b 3000e770 <pthread_attr_setdetachstate+0x30> <== NOT EXECUTED
pthread_attr_t *attr,
int detachstate
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e768: e3a00016 mov r0, #22 <== NOT EXECUTED 3000e76c: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_CREATE_JOINABLE:
attr->detachstate = detachstate;
return 0;
default:
return EINVAL;
3000e770: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000e774: e12fff1e bx lr <== NOT EXECUTED
3000e778 <pthread_attr_setguardsize>:
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
3000e778: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000e77c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
3000e780: 012fff1e bxeq lr <== NOT EXECUTED 3000e784: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e788: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
attr->guardsize = guardsize;
3000e78c: 15801034 strne r1, [r0, #52] ; 0x34 <== NOT EXECUTED
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e790: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->guardsize = guardsize;
return 0;
3000e794: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000e798: e12fff1e bx lr <== NOT EXECUTED
3000fa64 <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
3000fa64: e3500000 cmp r0, #0
3000fa68: 0a000008 beq 3000fa90 <pthread_attr_setinheritsched+0x2c>
3000fa6c: e5903000 ldr r3, [r0] 3000fa70: e3530000 cmp r3, #0
3000fa74: 0a000005 beq 3000fa90 <pthread_attr_setinheritsched+0x2c>
return EINVAL;
switch ( inheritsched ) {
3000fa78: e2413001 sub r3, r1, #1 3000fa7c: e3530001 cmp r3, #1
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
3000fa80: 95801010 strls r1, [r0, #16]
return 0;
3000fa84: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( inheritsched ) {
3000fa88: 912fff1e bxls lr
3000fa8c: ea000001 b 3000fa98 <pthread_attr_setinheritsched+0x34> <== NOT EXECUTED
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000fa90: e3a00016 mov r0, #22 <== NOT EXECUTED 3000fa94: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
return 0;
default:
return ENOTSUP;
3000fa98: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
3000fa9c: e12fff1e bx lr <== NOT EXECUTED
3000e7d8 <pthread_attr_setschedparam>:
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000e7d8: e3500000 cmp r0, #0 <== NOT EXECUTED
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
3000e7dc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
3000e7e0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000e7e4: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
3000e7e8: e5905000 ldr r5, [r0] <== NOT EXECUTED
3000e7ec: e3550000 cmp r5, #0 <== NOT EXECUTED
3000e7f0: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
attr->schedparam = *param;
3000e7f4: 1280c018 addne ip, r0, #24 <== NOT EXECUTED
3000e7f8: 11a04001 movne r4, r1 <== NOT EXECUTED
3000e7fc: 18b4000f ldmne r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3000e800: 18ac000f stmiane ip!, {r0, r1, r2, r3} <== NOT EXECUTED
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000e804: 13a05000 movne r5, #0 <== NOT EXECUTED 3000e808: 03a05001 moveq r5, #1 <== NOT EXECUTED
return EINVAL;
attr->schedparam = *param;
3000e80c: 18940007 ldmne r4, {r0, r1, r2} <== NOT EXECUTED
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
3000e810: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->schedparam = *param;
3000e814: 188c0007 stmne ip, {r0, r1, r2} <== NOT EXECUTED
return 0;
3000e818: 11a00005 movne r0, r5 <== NOT EXECUTED
}
3000e81c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000e820 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
3000e820: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e824: 0a00000b beq 3000e858 <pthread_attr_setschedpolicy+0x38> <== NOT EXECUTED 3000e828: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e82c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e830: 0a000008 beq 3000e858 <pthread_attr_setschedpolicy+0x38> <== NOT EXECUTED
return EINVAL;
switch ( policy ) {
3000e834: e3510004 cmp r1, #4 <== NOT EXECUTED 3000e838: 8a000008 bhi 3000e860 <pthread_attr_setschedpolicy+0x40> <== NOT EXECUTED 3000e83c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000e840: e1a03113 lsl r3, r3, r1 <== NOT EXECUTED 3000e844: e3130017 tst r3, #23 <== NOT EXECUTED
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
3000e848: 15801014 strne r1, [r0, #20] <== NOT EXECUTED
return 0;
3000e84c: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
3000e850: 112fff1e bxne lr <== NOT EXECUTED 3000e854: ea000001 b 3000e860 <pthread_attr_setschedpolicy+0x40> <== NOT EXECUTED
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e858: e3a00016 mov r0, #22 <== NOT EXECUTED 3000e85c: e12fff1e bx lr <== NOT EXECUTED
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
3000e860: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
3000e864: e12fff1e bx lr <== NOT EXECUTED
3000e868 <pthread_attr_setscope>:
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
3000e868: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000e86c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
3000e870: 012fff1e bxeq lr <== NOT EXECUTED 3000e874: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e878: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e87c: 0a000007 beq 3000e8a0 <pthread_attr_setscope+0x38> <== NOT EXECUTED
return EINVAL;
switch ( contentionscope ) {
3000e880: e3510000 cmp r1, #0 <== NOT EXECUTED
case PTHREAD_SCOPE_PROCESS:
attr->contentionscope = contentionscope;
3000e884: 0580100c streq r1, [r0, #12] <== NOT EXECUTED
return 0;
3000e888: 01a00001 moveq r0, r1 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( contentionscope ) {
3000e88c: 012fff1e bxeq lr <== NOT EXECUTED
case PTHREAD_SCOPE_SYSTEM:
return ENOTSUP;
default:
return EINVAL;
3000e890: e3510001 cmp r1, #1 <== NOT EXECUTED 3000e894: 03a00086 moveq r0, #134 ; 0x86 <== NOT EXECUTED 3000e898: 13a00016 movne r0, #22 <== NOT EXECUTED 3000e89c: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e8a0: e3a00016 mov r0, #22 <== NOT EXECUTED
return ENOTSUP;
default:
return EINVAL;
}
}
3000e8a4: e12fff1e bx lr <== NOT EXECUTED
3000e8cc <pthread_attr_setstack>:
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
3000e8cc: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000e8d0: 03a00016 moveq r0, #22 <== NOT EXECUTED
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
3000e8d4: 012fff1e bxeq lr <== NOT EXECUTED 3000e8d8: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e8dc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000e8e0: 0a000008 beq 3000e908 <pthread_attr_setstack+0x3c> <== NOT EXECUTED
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
3000e8e4: e59f3024 ldr r3, [pc, #36] ; 3000e910 <pthread_attr_setstack+0x44><== NOT EXECUTED
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
3000e8e8: e5801004 str r1, [r0, #4] <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
3000e8ec: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000e8f0: e1a03083 lsl r3, r3, #1 <== NOT EXECUTED
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
3000e8f4: e1530002 cmp r3, r2 <== NOT EXECUTED 3000e8f8: 25803008 strcs r3, [r0, #8] <== NOT EXECUTED 3000e8fc: 35802008 strcc r2, [r0, #8] <== NOT EXECUTED
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
3000e900: e3a00000 mov r0, #0 <== NOT EXECUTED 3000e904: e12fff1e bx lr <== NOT EXECUTED
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e908: e3a00016 mov r0, #22 <== NOT EXECUTED
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
}
3000e90c: e12fff1e bx lr <== NOT EXECUTED
3000e8a8 <pthread_attr_setstackaddr>:
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
3000e8a8: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000e8ac: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
3000e8b0: 012fff1e bxeq lr <== NOT EXECUTED 3000e8b4: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000e8b8: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
attr->stackaddr = stackaddr;
3000e8bc: 15801004 strne r1, [r0, #4] <== NOT EXECUTED
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000e8c0: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->stackaddr = stackaddr;
return 0;
3000e8c4: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000e8c8: e12fff1e bx lr <== NOT EXECUTED
3000faa0 <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
3000faa0: e3500000 cmp r0, #0
return EINVAL;
3000faa4: 03a00016 moveq r0, #22
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
3000faa8: 012fff1e bxeq lr 3000faac: e5903000 ldr r3, [r0] 3000fab0: e3530000 cmp r3, #0
3000fab4: 0a000007 beq 3000fad8 <pthread_attr_setstacksize+0x38>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
3000fab8: e59f3020 ldr r3, [pc, #32] ; 3000fae0 <pthread_attr_setstacksize+0x40> 3000fabc: e5933000 ldr r3, [r3] 3000fac0: e1a03083 lsl r3, r3, #1 3000fac4: e1510003 cmp r1, r3
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
3000fac8: 35803008 strcc r3, [r0, #8]
else
attr->stacksize = stacksize;
3000facc: 25801008 strcs r1, [r0, #8]
return 0;
3000fad0: e3a00000 mov r0, #0 3000fad4: e12fff1e bx lr
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000fad8: e3a00016 mov r0, #22 <== NOT EXECUTED
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
return 0;
}
3000fadc: e12fff1e bx lr <== NOT EXECUTED
30009aa8 <pthread_barrier_destroy>:
)
{
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
30009aa8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_barrier_destroy(
pthread_barrier_t *barrier
)
{
30009aac: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
30009ab0: 0a000016 beq 30009b10 <pthread_barrier_destroy+0x68> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
pthread_barrier_t *barrier,
Objects_Locations *location
)
{
return (POSIX_Barrier_Control *) _Objects_Get(
30009ab4: e5931000 ldr r1, [r3] <== NOT EXECUTED 30009ab8: e59f0058 ldr r0, [pc, #88] ; 30009b18 <pthread_barrier_destroy+0x70><== NOT EXECUTED 30009abc: e1a0200d mov r2, sp <== NOT EXECUTED 30009ac0: eb000910 bl 3000bf08 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
30009ac4: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30009ac8: e1a04000 mov r4, r0 <== NOT EXECUTED 30009acc: e3530000 cmp r3, #0 <== NOT EXECUTED 30009ad0: 1a00000e bne 30009b10 <pthread_barrier_destroy+0x68> <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) {
30009ad4: e5905058 ldr r5, [r0, #88] ; 0x58 <== NOT EXECUTED 30009ad8: e3550000 cmp r5, #0 <== NOT EXECUTED 30009adc: 0a000002 beq 30009aec <pthread_barrier_destroy+0x44> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009ae0: eb000c0c bl 3000cb18 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
30009ae4: e3a00010 mov r0, #16 <== NOT EXECUTED 30009ae8: ea000009 b 30009b14 <pthread_barrier_destroy+0x6c> <== NOT EXECUTED
}
_Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object );
30009aec: e59f0024 ldr r0, [pc, #36] ; 30009b18 <pthread_barrier_destroy+0x70><== NOT EXECUTED 30009af0: e1a01004 mov r1, r4 <== NOT EXECUTED 30009af4: eb000809 bl 3000bb20 <_Objects_Close> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _POSIX_Barrier_Free (
POSIX_Barrier_Control *the_barrier
)
{
_Objects_Free( &_POSIX_Barrier_Information, &the_barrier->Object );
30009af8: e59f0018 ldr r0, [pc, #24] ; 30009b18 <pthread_barrier_destroy+0x70><== NOT EXECUTED 30009afc: e1a01004 mov r1, r4 <== NOT EXECUTED 30009b00: eb0008ab bl 3000bdb4 <_Objects_Free> <== NOT EXECUTED
_POSIX_Barrier_Free( the_barrier );
_Thread_Enable_dispatch();
30009b04: eb000c03 bl 3000cb18 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009b08: e1a00005 mov r0, r5 <== NOT EXECUTED 30009b0c: ea000000 b 30009b14 <pthread_barrier_destroy+0x6c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
30009b10: e3a00016 mov r0, #22 <== NOT EXECUTED
}
30009b14: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30009b1c <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
30009b1c: e92d40ff push {r0, r1, r2, r3, r4, r5, r6, r7, lr} <== NOT EXECUTED
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
30009b20: e2507000 subs r7, r0, #0 <== NOT EXECUTED
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
30009b24: e1a04002 mov r4, r2 <== NOT EXECUTED
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
30009b28: 0a000027 beq 30009bcc <pthread_barrier_init+0xb0> <== NOT EXECUTED
return EINVAL;
if ( count == 0 )
30009b2c: e3520000 cmp r2, #0 <== NOT EXECUTED 30009b30: 0a000025 beq 30009bcc <pthread_barrier_init+0xb0> <== NOT EXECUTED
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
30009b34: e3510000 cmp r1, #0 <== NOT EXECUTED 30009b38: 1a000003 bne 30009b4c <pthread_barrier_init+0x30> <== NOT EXECUTED
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
30009b3c: e1a0000d mov r0, sp <== NOT EXECUTED 30009b40: ebffffc3 bl 30009a54 <pthread_barrierattr_init> <== NOT EXECUTED 30009b44: e1a0500d mov r5, sp <== NOT EXECUTED
the_attr = &my_attr;
30009b48: e1a0100d mov r1, sp <== NOT EXECUTED
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
30009b4c: e5913000 ldr r3, [r1] <== NOT EXECUTED 30009b50: e3530000 cmp r3, #0 <== NOT EXECUTED 30009b54: 0a00001c beq 30009bcc <pthread_barrier_init+0xb0> <== NOT EXECUTED
return EINVAL;
switch ( the_attr->process_shared ) {
30009b58: e5915004 ldr r5, [r1, #4] <== NOT EXECUTED 30009b5c: e3550000 cmp r5, #0 <== NOT EXECUTED 30009b60: 1a000019 bne 30009bcc <pthread_barrier_init+0xb0> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009b64: e59f306c ldr r3, [pc, #108] ; 30009bd8 <pthread_barrier_init+0xbc><== NOT EXECUTED
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
30009b68: e58d5008 str r5, [sp, #8] <== NOT EXECUTED 30009b6c: e5932000 ldr r2, [r3] <== NOT EXECUTED
the_attributes.maximum_count = count;
30009b70: e58d400c str r4, [sp, #12] <== NOT EXECUTED 30009b74: e2822001 add r2, r2, #1 <== NOT EXECUTED 30009b78: e5832000 str r2, [r3] <== NOT EXECUTED
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
_Objects_Allocate( &_POSIX_Barrier_Information );
30009b7c: e59f6058 ldr r6, [pc, #88] ; 30009bdc <pthread_barrier_init+0xc0><== NOT EXECUTED 30009b80: e1a00006 mov r0, r6 <== NOT EXECUTED 30009b84: eb0007c3 bl 3000ba98 <_Objects_Allocate> <== NOT EXECUTED
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
30009b88: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30009b8c: 1a000002 bne 30009b9c <pthread_barrier_init+0x80> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009b90: eb000be0 bl 3000cb18 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
30009b94: e3a0000b mov r0, #11 <== NOT EXECUTED 30009b98: ea00000c b 30009bd0 <pthread_barrier_init+0xb4> <== NOT EXECUTED
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
30009b9c: e2840010 add r0, r4, #16 <== NOT EXECUTED 30009ba0: e28d1008 add r1, sp, #8 <== NOT EXECUTED 30009ba4: eb000560 bl 3000b12c <_CORE_barrier_Initialize> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009ba8: e596201c ldr r2, [r6, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
30009bac: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30009bb0: e1d410b8 ldrh r1, [r4, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009bb4: e7824101 str r4, [r2, r1, lsl #2] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
30009bb8: e584500c str r5, [r4, #12] <== NOT EXECUTED
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
30009bbc: e5873000 str r3, [r7] <== NOT EXECUTED
_Thread_Enable_dispatch();
30009bc0: eb000bd4 bl 3000cb18 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009bc4: e1a00005 mov r0, r5 <== NOT EXECUTED 30009bc8: ea000000 b 30009bd0 <pthread_barrier_init+0xb4> <== NOT EXECUTED
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
30009bcc: e3a00016 mov r0, #22 <== NOT EXECUTED
* Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; }
30009bd0: e28dd010 add sp, sp, #16 <== NOT EXECUTED
30009bd4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30009be0 <pthread_barrier_wait>:
)
{
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
30009be0: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_barrier_wait(
pthread_barrier_t *barrier
)
{
30009be4: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
30009be8: 0a000012 beq 30009c38 <pthread_barrier_wait+0x58> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
pthread_barrier_t *barrier,
Objects_Locations *location
)
{
return (POSIX_Barrier_Control *) _Objects_Get(
30009bec: e5931000 ldr r1, [r3] <== NOT EXECUTED 30009bf0: e28d2004 add r2, sp, #4 <== NOT EXECUTED 30009bf4: e59f0044 ldr r0, [pc, #68] ; 30009c40 <pthread_barrier_wait+0x60><== NOT EXECUTED 30009bf8: eb0008c2 bl 3000bf08 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
30009bfc: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30009c00: e1a02000 mov r2, r0 <== NOT EXECUTED 30009c04: e3530000 cmp r3, #0 <== NOT EXECUTED 30009c08: 1a00000a bne 30009c38 <pthread_barrier_wait+0x58> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_barrier_Wait(
30009c0c: e58d3000 str r3, [sp] <== NOT EXECUTED 30009c10: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED 30009c14: e2800010 add r0, r0, #16 <== NOT EXECUTED 30009c18: e3a02001 mov r2, #1 <== NOT EXECUTED 30009c1c: eb00054a bl 3000b14c <_CORE_barrier_Wait> <== NOT EXECUTED
the_barrier->Object.id,
true,
0,
NULL
);
_Thread_Enable_dispatch();
30009c20: eb000bbc bl 3000cb18 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Barrier_Translate_core_barrier_return_code(
_Thread_Executing->Wait.return_code );
30009c24: e59f3018 ldr r3, [pc, #24] ; 30009c44 <pthread_barrier_wait+0x64><== NOT EXECUTED 30009c28: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
true,
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_Barrier_Translate_core_barrier_return_code(
30009c2c: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 30009c30: eb0016b9 bl 3000f71c <_POSIX_Barrier_Translate_core_barrier_return_code><== NOT EXECUTED 30009c34: ea000000 b 30009c3c <pthread_barrier_wait+0x5c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
30009c38: e3a00016 mov r0, #22 <== NOT EXECUTED
}
30009c3c: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
30009a08 <pthread_barrierattr_destroy>:
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
30009a08: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
30009a0c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
30009a10: 012fff1e bxeq lr <== NOT EXECUTED 30009a14: e5932000 ldr r2, [r3] <== NOT EXECUTED 30009a18: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
30009a1c: 13a00000 movne r0, #0 <== NOT EXECUTED 30009a20: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
30009a24: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
30009a28: e12fff1e bx lr <== NOT EXECUTED
30009a2c <pthread_barrierattr_getpshared>:
int pthread_barrierattr_getpshared(
const pthread_barrierattr_t *attr,
int *pshared
)
{
if ( !attr )
30009a2c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
30009a30: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_barrierattr_getpshared(
const pthread_barrierattr_t *attr,
int *pshared
)
{
if ( !attr )
30009a34: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
30009a38: e5903000 ldr r3, [r0] <== NOT EXECUTED 30009a3c: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
30009a40: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
30009a44: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
30009a48: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0;
30009a4c: 13a00000 movne r0, #0 <== NOT EXECUTED
}
30009a50: e12fff1e bx lr <== NOT EXECUTED
30009a54 <pthread_barrierattr_init>:
int pthread_barrierattr_init(
pthread_barrierattr_t *attr
)
{
if ( !attr )
30009a54: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = true;
30009a58: 13a02001 movne r2, #1 <== NOT EXECUTED
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
30009a5c: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr )
return EINVAL;
attr->is_initialized = true;
30009a60: 15832000 strne r2, [r3] <== NOT EXECUTED
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
30009a64: 15830004 strne r0, [r3, #4] <== NOT EXECUTED
int pthread_barrierattr_init(
pthread_barrierattr_t *attr
)
{
if ( !attr )
return EINVAL;
30009a68: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = true;
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
return 0;
}
30009a6c: e12fff1e bx lr <== NOT EXECUTED
30009a70 <pthread_barrierattr_setpshared>:
int pthread_barrierattr_setpshared(
pthread_barrierattr_t *attr,
int pshared
)
{
if ( !attr )
30009a70: e3500000 cmp r0, #0 <== NOT EXECUTED 30009a74: 0a000007 beq 30009a98 <pthread_barrierattr_setpshared+0x28><== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
30009a78: e5903000 ldr r3, [r0] <== NOT EXECUTED 30009a7c: e3530000 cmp r3, #0 <== NOT EXECUTED 30009a80: 0a000004 beq 30009a98 <pthread_barrierattr_setpshared+0x28><== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
30009a84: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
30009a88: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
30009a8c: 93a00000 movls r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
30009a90: 912fff1e bxls lr <== NOT EXECUTED 30009a94: ea000001 b 30009aa0 <pthread_barrierattr_setpshared+0x30> <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
30009a98: e3a00016 mov r0, #22 <== NOT EXECUTED 30009a9c: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
30009aa0: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
30009aa4: e12fff1e bx lr <== NOT EXECUTED
30009050 <pthread_cancel>:
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
30009050: e59f3044 ldr r3, [pc, #68] ; 3000909c <pthread_cancel+0x4c><== NOT EXECUTED
*/
int pthread_cancel(
pthread_t thread
)
{
30009054: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
30009058: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000905c: e3530000 cmp r3, #0 <== NOT EXECUTED
return EPROTO;
30009060: 13a00047 movne r0, #71 ; 0x47 <== NOT EXECUTED
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
30009064: 1a00000b bne 30009098 <pthread_cancel+0x48> <== NOT EXECUTED
return EPROTO;
the_thread = _Thread_Get( thread, &location );
30009068: e1a0100d mov r1, sp <== NOT EXECUTED 3000906c: eb000aee bl 3000bc2c <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30009070: e59d4000 ldr r4, [sp] <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
30009074: e1a03000 mov r3, r0 <== NOT EXECUTED
switch ( location ) {
30009078: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000907c: 13a00016 movne r0, #22 <== NOT EXECUTED
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
30009080: 1a000004 bne 30009098 <pthread_cancel+0x48> <== NOT EXECUTED
case OBJECTS_LOCAL:
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
thread_support->cancelation_requested = 1;
30009084: e59330fc ldr r3, [r3, #252] ; 0xfc <== NOT EXECUTED 30009088: e3a02001 mov r2, #1 <== NOT EXECUTED 3000908c: e58320e0 str r2, [r3, #224] ; 0xe0 <== NOT EXECUTED
/* This enables dispatch implicitly */
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( the_thread );
30009090: eb001518 bl 3000e4f8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
return 0;
30009094: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
30009098: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
30008e5c <pthread_cleanup_pop>:
*/
void pthread_cleanup_pop(
int execute
)
{
30008e5c: e92d4070 push {r4, r5, r6, lr}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30008e60: e59f207c ldr r2, [pc, #124] ; 30008ee4 <pthread_cleanup_pop+0x88>
POSIX_Cancel_Handler_control tmp_handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30008e64: e59f307c ldr r3, [pc, #124] ; 30008ee8 <pthread_cleanup_pop+0x8c> 30008e68: e5921000 ldr r1, [r2] 30008e6c: e5933004 ldr r3, [r3, #4] 30008e70: e2811001 add r1, r1, #1 30008e74: e59330fc ldr r3, [r3, #252] ; 0xfc 30008e78: e5821000 str r1, [r2]
*/
void pthread_cleanup_pop(
int execute
)
{
30008e7c: e1a06000 mov r6, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008e80: e10f4000 mrs r4, CPSR 30008e84: e3842080 orr r2, r4, #128 ; 0x80 30008e88: e129f002 msr CPSR_fc, r2
*/
_Thread_Disable_dispatch();
_ISR_Disable( level );
if ( _Chain_Is_empty( handler_stack ) ) {
30008e8c: e59310e4 ldr r1, [r3, #228] ; 0xe4
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30008e90: e28320e8 add r2, r3, #232 ; 0xe8 30008e94: e1510002 cmp r1, r2
30008e98: 1a000002 bne 30008ea8 <pthread_cleanup_pop+0x4c>
_Thread_Enable_dispatch();
30008e9c: eb000a73 bl 3000b870 <_Thread_Enable_dispatch> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30008ea0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
30008ea4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
_ISR_Enable( level );
return;
}
handler = (POSIX_Cancel_Handler_control *)
30008ea8: e59300ec ldr r0, [r3, #236] ; 0xec
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
30008eac: e890000c ldm r0, {r2, r3}
previous = the_node->previous; next->previous = previous;
30008eb0: e5823004 str r3, [r2, #4]
previous->next = next;
30008eb4: e5832000 str r2, [r3] 30008eb8: e129f004 msr CPSR_fc, r4 30008ebc: e5904008 ldr r4, [r0, #8] 30008ec0: e590500c ldr r5, [r0, #12]
_ISR_Enable( level );
tmp_handler = *handler;
_Workspace_Free( handler );
30008ec4: eb000e97 bl 3000c928 <_Workspace_Free>
_Thread_Enable_dispatch();
30008ec8: eb000a68 bl 3000b870 <_Thread_Enable_dispatch>
if ( execute )
30008ecc: e3560000 cmp r6, #0
30008ed0: 08bd8070 popeq {r4, r5, r6, pc}
(*tmp_handler.routine)( tmp_handler.arg );
30008ed4: e1a00005 mov r0, r5 <== NOT EXECUTED
30008ed8: e1a0e00f mov lr, pc <== NOT EXECUTED
30008edc: e12fff14 bx r4 <== NOT EXECUTED
30008ee0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000a2b4 <pthread_cond_destroy>:
*/
int pthread_cond_destroy(
pthread_cond_t *cond
)
{
3000a2b4: e92d4031 push {r0, r4, r5, lr}
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000a2b8: e1a0100d mov r1, sp 3000a2bc: eb000015 bl 3000a318 <_POSIX_Condition_variables_Get>
switch ( location ) {
3000a2c0: e59d3000 ldr r3, [sp]
)
{
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000a2c4: e1a04000 mov r4, r0
switch ( location ) {
3000a2c8: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a2cc: 13a00016 movne r0, #22
{
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
switch ( location ) {
3000a2d0: 1a00000e bne 3000a310 <pthread_cond_destroy+0x5c>
case OBJECTS_LOCAL:
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
3000a2d4: e2840018 add r0, r4, #24 3000a2d8: eb000f33 bl 3000dfac <_Thread_queue_First> 3000a2dc: e2505000 subs r5, r0, #0
3000a2e0: 0a000002 beq 3000a2f0 <pthread_cond_destroy+0x3c>
_Thread_Enable_dispatch();
3000a2e4: eb000d71 bl 3000d8b0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000a2e8: e3a00010 mov r0, #16 <== NOT EXECUTED 3000a2ec: ea000007 b 3000a310 <pthread_cond_destroy+0x5c> <== NOT EXECUTED
}
_Objects_Close(
3000a2f0: e59f001c ldr r0, [pc, #28] ; 3000a314 <pthread_cond_destroy+0x60> 3000a2f4: e1a01004 mov r1, r4 3000a2f8: eb00096e bl 3000c8b8 <_Objects_Close>
RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free (
POSIX_Condition_variables_Control *the_condition_variable
)
{
_Objects_Free(
3000a2fc: e59f0010 ldr r0, [pc, #16] ; 3000a314 <pthread_cond_destroy+0x60> 3000a300: e1a01004 mov r1, r4 3000a304: eb000a10 bl 3000cb4c <_Objects_Free>
&_POSIX_Condition_variables_Information,
&the_cond->Object
);
_POSIX_Condition_variables_Free( the_cond );
_Thread_Enable_dispatch();
3000a308: eb000d68 bl 3000d8b0 <_Thread_Enable_dispatch>
return 0;
3000a30c: e1a00005 mov r0, r5
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000a310: e8bd8038 pop {r3, r4, r5, pc}
3000a374 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
3000a374: e92d40f0 push {r4, r5, r6, r7, lr}
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Condition_variables_Default_attributes;
3000a378: e3510000 cmp r1, #0 3000a37c: e59f50a0 ldr r5, [pc, #160] ; 3000a424 <pthread_cond_init+0xb0> 3000a380: 11a05001 movne r5, r1
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000a384: e5953004 ldr r3, [r5, #4]
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
3000a388: e1a07000 mov r7, r0
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000a38c: e3530001 cmp r3, #1
return EINVAL;
3000a390: 03a00016 moveq r0, #22
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000a394: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return EINVAL;
if ( !the_attr->is_initialized )
3000a398: e5953000 ldr r3, [r5] 3000a39c: e3530000 cmp r3, #0
3000a3a0: 0a00001d beq 3000a41c <pthread_cond_init+0xa8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000a3a4: e59f307c ldr r3, [pc, #124] ; 3000a428 <pthread_cond_init+0xb4> 3000a3a8: e5932000 ldr r2, [r3] 3000a3ac: e2822001 add r2, r2, #1 3000a3b0: e5832000 str r2, [r3]
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
3000a3b4: e59f6070 ldr r6, [pc, #112] ; 3000a42c <pthread_cond_init+0xb8> 3000a3b8: e1a00006 mov r0, r6 3000a3bc: eb00091b bl 3000c830 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
3000a3c0: e2504000 subs r4, r0, #0
3000a3c4: 1a000002 bne 3000a3d4 <pthread_cond_init+0x60>
_Thread_Enable_dispatch();
3000a3c8: eb000d38 bl 3000d8b0 <_Thread_Enable_dispatch>
return ENOMEM;
3000a3cc: e3a0000c mov r0, #12
3000a3d0: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
the_cond->process_shared = the_attr->process_shared;
3000a3d4: e5953004 ldr r3, [r5, #4]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
3000a3d8: e3a05000 mov r5, #0
_Thread_queue_Initialize(
3000a3dc: e2840018 add r0, r4, #24
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
3000a3e0: e5843010 str r3, [r4, #16]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
3000a3e4: e1a01005 mov r1, r5 3000a3e8: e59f2040 ldr r2, [pc, #64] ; 3000a430 <pthread_cond_init+0xbc> 3000a3ec: e3a03074 mov r3, #116 ; 0x74
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
3000a3f0: e5845014 str r5, [r4, #20]
_Thread_queue_Initialize(
3000a3f4: eb000f13 bl 3000e048 <_Thread_queue_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a3f8: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000a3fc: e5943008 ldr r3, [r4, #8] 3000a400: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a404: e7824101 str r4, [r2, r1, lsl #2]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000a408: e584500c str r5, [r4, #12]
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
3000a40c: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
3000a410: eb000d26 bl 3000d8b0 <_Thread_Enable_dispatch>
return 0;
3000a414: e1a00005 mov r0, r5
3000a418: e8bd80f0 pop {r4, r5, r6, r7, pc}
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
if ( !the_attr->is_initialized )
return EINVAL;
3000a41c: e3a00016 mov r0, #22 <== NOT EXECUTED
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000a420: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000a434 <pthread_cond_signal>:
int pthread_cond_signal(
pthread_cond_t *cond
)
{
return _POSIX_Condition_variables_Signal_support( cond, false );
3000a434: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a438: eaffffff b 3000a43c <_POSIX_Condition_variables_Signal_support><== NOT EXECUTED
3000a490 <pthread_cond_timedwait>:
int pthread_cond_timedwait(
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
3000a490: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3000a494: e1a05000 mov r5, r0 <== NOT EXECUTED
3000a498: e1a04001 mov r4, r1 <== NOT EXECUTED
* is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ already_timedout = false; status = _POSIX_Absolute_timeout_to_ticks(abstime, &ticks);
3000a49c: e1a00002 mov r0, r2 <== NOT EXECUTED 3000a4a0: e1a0100d mov r1, sp <== NOT EXECUTED 3000a4a4: eb00011e bl 3000a924 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000a4a8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000a4ac: 03a00016 moveq r0, #22 <== NOT EXECUTED
* then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ already_timedout = false; status = _POSIX_Absolute_timeout_to_ticks(abstime, &ticks); if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000a4b0: 0a000007 beq 3000a4d4 <pthread_cond_timedwait+0x44> <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000a4b4: e2433001 sub r3, r3, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
already_timedout = true;
return _POSIX_Condition_variables_Wait_support(
3000a4b8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a4bc: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a4c0: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000a4c4: e3530001 cmp r3, #1 <== NOT EXECUTED 3000a4c8: 83a03000 movhi r3, #0 <== NOT EXECUTED 3000a4cc: 93a03001 movls r3, #1 <== NOT EXECUTED 3000a4d0: eb000003 bl 3000a4e4 <_POSIX_Condition_variables_Wait_support><== NOT EXECUTED
cond,
mutex,
ticks,
already_timedout
);
}
3000a4d4: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000a4d8 <pthread_cond_wait>:
int pthread_cond_wait(
pthread_cond_t *cond,
pthread_mutex_t *mutex
)
{
return _POSIX_Condition_variables_Wait_support(
3000a4d8: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a4dc: e1a03002 mov r3, r2 <== NOT EXECUTED 3000a4e0: eaffffff b 3000a4e4 <_POSIX_Condition_variables_Wait_support><== NOT EXECUTED
3000a224 <pthread_condattr_destroy>:
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000a224: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000a228: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000a22c: 012fff1e bxeq lr <== NOT EXECUTED 3000a230: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000a234: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000a238: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a23c: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000a240: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000a244: e12fff1e bx lr <== NOT EXECUTED
3000a248 <pthread_condattr_getpshared>:
int pthread_condattr_getpshared(
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
3000a248: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000a24c: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
return EINVAL;
3000a250: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
3000a254: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0;
3000a258: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000a25c: e12fff1e bx lr <== NOT EXECUTED
3000a260 <pthread_condattr_init>:
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
if ( !attr )
3000a260: e3500000 cmp r0, #0 <== NOT EXECUTED
*/
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
3000a264: e92d4010 push {r4, lr} <== NOT EXECUTED
if ( !attr )
3000a268: 0a000004 beq 3000a280 <pthread_condattr_init+0x20> <== NOT EXECUTED
return EINVAL;
*attr = _POSIX_Condition_variables_Default_attributes;
3000a26c: e59f3014 ldr r3, [pc, #20] ; 3000a288 <pthread_condattr_init+0x28><== NOT EXECUTED
3000a270: e8930018 ldm r3, {r3, r4} <== NOT EXECUTED
3000a274: e8800018 stm r0, {r3, r4} <== NOT EXECUTED
return 0;
3000a278: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a27c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
if ( !attr )
return EINVAL;
3000a280: e3a00016 mov r0, #22 <== NOT EXECUTED
*attr = _POSIX_Condition_variables_Default_attributes;
return 0;
}
3000a284: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a28c <pthread_condattr_setpshared>:
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
if ( !attr )
3000a28c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000a290: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
if ( !attr )
3000a294: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000a298: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000a29c: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
default:
return EINVAL;
3000a2a0: 83a00016 movhi r0, #22 <== NOT EXECUTED
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
3000a2a4: 93a00000 movls r0, #0 <== NOT EXECUTED
default:
return EINVAL;
}
}
3000a2a8: e12fff1e bx lr <== NOT EXECUTED
300097a4 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
300097a4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
300097a8: e3520000 cmp r2, #0
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
300097ac: e24dd04c sub sp, sp, #76 ; 0x4c 300097b0: e58d001c str r0, [sp, #28] 300097b4: e58d3024 str r3, [sp, #36] ; 0x24
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
300097b8: e58d2020 str r2, [sp, #32]
return EFAULT;
300097bc: 03a0500e moveq r5, #14
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
300097c0: 0a000081 beq 300099cc <pthread_create+0x228>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
300097c4: e59f420c ldr r4, [pc, #524] ; 300099d8 <pthread_create+0x234> 300097c8: e3510000 cmp r1, #0 300097cc: 11a04001 movne r4, r1
if ( !the_attr->is_initialized )
300097d0: e5943000 ldr r3, [r4] 300097d4: e3530000 cmp r3, #0
300097d8: 0a00007a beq 300099c8 <pthread_create+0x224> * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
300097dc: e5943004 ldr r3, [r4, #4] 300097e0: e3530000 cmp r3, #0
300097e4: 0a000004 beq 300097fc <pthread_create+0x58>
300097e8: e59f31ec ldr r3, [pc, #492] ; 300099dc <pthread_create+0x238><== NOT EXECUTED 300097ec: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 300097f0: e5933000 ldr r3, [r3] <== NOT EXECUTED 300097f4: e1520003 cmp r2, r3 <== NOT EXECUTED 300097f8: 3a000072 bcc 300099c8 <pthread_create+0x224> <== NOT EXECUTED
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
300097fc: e5943010 ldr r3, [r4, #16] 30009800: e3530001 cmp r3, #1
30009804: 0a000002 beq 30009814 <pthread_create+0x70>
30009808: e3530002 cmp r3, #2
3000980c: 1a00006d bne 300099c8 <pthread_create+0x224>
30009810: ea000006 b 30009830 <pthread_create+0x8c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30009814: e59f31c4 ldr r3, [pc, #452] ; 300099e0 <pthread_create+0x23c>
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
30009818: e28dc028 add ip, sp, #40 ; 0x28
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000981c: e5933004 ldr r3, [r3, #4] 30009820: e59350fc ldr r5, [r3, #252] ; 0xfc
schedpolicy = api->schedpolicy;
30009824: e595a084 ldr sl, [r5, #132] ; 0x84
schedparam = api->schedparam;
30009828: e2855088 add r5, r5, #136 ; 0x88 3000982c: ea000002 b 3000983c <pthread_create+0x98>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
30009830: e594a014 ldr sl, [r4, #20]
schedparam = the_attr->schedparam;
30009834: e28dc028 add ip, sp, #40 ; 0x28
30009838: e2845018 add r5, r4, #24
3000983c: e8b5000f ldm r5!, {r0, r1, r2, r3}
30009840: e8ac000f stmia ip!, {r0, r1, r2, r3}
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
30009844: e594300c ldr r3, [r4, #12]
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
30009848: e8950007 ldm r5, {r0, r1, r2}
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
3000984c: e3530000 cmp r3, #0
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
30009850: e88c0007 stm ip, {r0, r1, r2}
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
return ENOTSUP;
30009854: 13a05086 movne r5, #134 ; 0x86
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
30009858: 1a00005b bne 300099cc <pthread_create+0x228>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
3000985c: e59d0028 ldr r0, [sp, #40] ; 0x28 30009860: eb001828 bl 3000f908 <_POSIX_Priority_Is_valid> 30009864: e3500000 cmp r0, #0
30009868: 0a000056 beq 300099c8 <pthread_create+0x224>
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
3000986c: e28d804c add r8, sp, #76 ; 0x4c 30009870: e538b024 ldr fp, [r8, #-36]! ; 0x24
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
30009874: e59f3168 ldr r3, [pc, #360] ; 300099e4 <pthread_create+0x240>
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
30009878: e1a0000a mov r0, sl 3000987c: e5d39000 ldrb r9, [r3] 30009880: e1a01008 mov r1, r8 30009884: e28d2048 add r2, sp, #72 ; 0x48 30009888: e28d3044 add r3, sp, #68 ; 0x44 3000988c: eb001828 bl 3000f934 <_POSIX_Thread_Translate_sched_param>
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
30009890: e2505000 subs r5, r0, #0
30009894: 1a00004c bne 300099cc <pthread_create+0x228>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
30009898: e59f6148 ldr r6, [pc, #328] ; 300099e8 <pthread_create+0x244> 3000989c: e5960000 ldr r0, [r6] 300098a0: eb00059a bl 3000af10 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
300098a4: e59f0140 ldr r0, [pc, #320] ; 300099ec <pthread_create+0x248> 300098a8: eb00080f bl 3000b8ec <_Objects_Allocate>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
300098ac: e2507000 subs r7, r0, #0
300098b0: 0a000018 beq 30009918 <pthread_create+0x174>
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
300098b4: e59f3120 ldr r3, [pc, #288] ; 300099dc <pthread_create+0x238>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
300098b8: e59d1048 ldr r1, [sp, #72] ; 0x48
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
300098bc: e5933000 ldr r3, [r3]
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
300098c0: e9941004 ldmib r4, {r2, ip}
300098c4: e58d100c str r1, [sp, #12]
300098c8: e59d1044 ldr r1, [sp, #68] ; 0x44
300098cc: e06b9009 rsb r9, fp, r9
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
300098d0: e1a03083 lsl r3, r3, #1
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
300098d4: e58d9004 str r9, [sp, #4] 300098d8: e58d1010 str r1, [sp, #16] 300098dc: e153000c cmp r3, ip 300098e0: 31a0300c movcc r3, ip 300098e4: e3a09001 mov r9, #1 300098e8: e59f00fc ldr r0, [pc, #252] ; 300099ec <pthread_create+0x248> 300098ec: e1a01007 mov r1, r7 300098f0: e58d5000 str r5, [sp] 300098f4: e58d9008 str r9, [sp, #8] 300098f8: e58d5014 str r5, [sp, #20] 300098fc: e58d5018 str r5, [sp, #24] 30009900: eb000c47 bl 3000ca24 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
30009904: e3500000 cmp r0, #0
30009908: 1a000006 bne 30009928 <pthread_create+0x184>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
3000990c: e59f00d8 ldr r0, [pc, #216] ; 300099ec <pthread_create+0x248> 30009910: e1a01007 mov r1, r7 30009914: eb0008bb bl 3000bc08 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
30009918: e5960000 ldr r0, [r6] 3000991c: eb000594 bl 3000af74 <_API_Mutex_Unlock>
return EAGAIN;
30009920: e3a0500b mov r5, #11 30009924: ea000028 b 300099cc <pthread_create+0x228>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
30009928: e59760fc ldr r6, [r7, #252] ; 0xfc
api->Attributes = *the_attr;
3000992c: e1a0e004 mov lr, r4
30009930: e1a0c006 mov ip, r6
30009934: e8be000f ldm lr!, {r0, r1, r2, r3}
30009938: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000993c: e8be000f ldm lr!, {r0, r1, r2, r3}
30009940: e8ac000f stmia ip!, {r0, r1, r2, r3}
30009944: e8be000f ldm lr!, {r0, r1, r2, r3}
30009948: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000994c: e89e000f ldm lr, {r0, r1, r2, r3}
30009950: e88c000f stm ip, {r0, r1, r2, r3}
api->detachstate = the_attr->detachstate;
30009954: e594303c ldr r3, [r4, #60] ; 0x3c
api->schedpolicy = schedpolicy; api->schedparam = schedparam;
30009958: e286c088 add ip, r6, #136 ; 0x88
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
3000995c: e5863040 str r3, [r6, #64] ; 0x40
api->schedpolicy = schedpolicy; api->schedparam = schedparam;
30009960: e8b8000f ldm r8!, {r0, r1, r2, r3}
30009964: e8ac000f stmia ip!, {r0, r1, r2, r3}
30009968: e8980007 ldm r8, {r0, r1, r2}
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
3000996c: e586a084 str sl, [r6, #132] ; 0x84
api->schedparam = schedparam;
30009970: e88c0007 stm ip, {r0, r1, r2}
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
30009974: e59d3024 ldr r3, [sp, #36] ; 0x24 30009978: e1a00007 mov r0, r7 3000997c: e1a01009 mov r1, r9 30009980: e59d2020 ldr r2, [sp, #32] 30009984: e58d5000 str r5, [sp] 30009988: eb000e5b bl 3000d2fc <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
3000998c: e35a0004 cmp sl, #4
30009990: 1a000005 bne 300099ac <pthread_create+0x208>
_Watchdog_Insert_ticks(
30009994: e2860090 add r0, r6, #144 ; 0x90 <== NOT EXECUTED 30009998: eb000ecf bl 3000d4dc <_Timespec_To_ticks> <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000999c: e28610a8 add r1, r6, #168 ; 0xa8 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
300099a0: e58600b4 str r0, [r6, #180] ; 0xb4 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
300099a4: e59f0044 ldr r0, [pc, #68] ; 300099f0 <pthread_create+0x24c><== NOT EXECUTED 300099a8: eb000f91 bl 3000d7f4 <_Watchdog_Insert> <== NOT EXECUTED
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
300099ac: e5973008 ldr r3, [r7, #8] 300099b0: e59d201c ldr r2, [sp, #28] 300099b4: e5823000 str r3, [r2]
_RTEMS_Unlock_allocator();
300099b8: e59f3028 ldr r3, [pc, #40] ; 300099e8 <pthread_create+0x244> 300099bc: e5930000 ldr r0, [r3] 300099c0: eb00056b bl 3000af74 <_API_Mutex_Unlock>
return 0;
300099c4: ea000000 b 300099cc <pthread_create+0x228>
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
300099c8: e3a05016 mov r5, #22 <== NOT EXECUTED
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
300099cc: e1a00005 mov r0, r5
300099d0: e28dd04c add sp, sp, #76 ; 0x4c
300099d4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
30009774 <pthread_detach>:
#include <rtems/posix/pthread.h>
int pthread_detach(
pthread_t thread
)
{
30009774: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
the_thread = _Thread_Get( thread, &location );
30009778: e1a0100d mov r1, sp <== NOT EXECUTED 3000977c: eb000b75 bl 3000c558 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30009780: e59d4000 ldr r4, [sp] <== NOT EXECUTED 30009784: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
30009788: 13a00003 movne r0, #3 <== NOT EXECUTED
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000978c: 1a000003 bne 300097a0 <pthread_detach+0x2c> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->detachstate = PTHREAD_CREATE_DETACHED;
30009790: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED 30009794: e5834040 str r4, [r3, #64] ; 0x40 <== NOT EXECUTED
_Thread_Enable_dispatch();
30009798: eb000b65 bl 3000c534 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000979c: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
300097a0: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
300099f4 <pthread_equal>:
break;
}
return status;
#endif
}
300099f4: e1500001 cmp r0, r1 <== NOT EXECUTED 300099f8: 13a00000 movne r0, #0 <== NOT EXECUTED 300099fc: 03a00001 moveq r0, #1 <== NOT EXECUTED 30009a00: e12fff1e bx lr <== NOT EXECUTED
30009364 <pthread_getcpuclockid>:
int pthread_getcpuclockid(
pthread_t pid,
clockid_t *clock_id
)
{
30009364: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009368: eb00219a bl 300119d8 <__errno> <== NOT EXECUTED 3000936c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009370: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009374: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009378: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000be94 <pthread_getschedparam>:
{
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000be94: e3510000 cmp r1, #0 <== NOT EXECUTED 3000be98: 13520000 cmpne r2, #0 <== NOT EXECUTED
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
3000be9c: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000bea0: e1a04002 mov r4, r2 <== NOT EXECUTED 3000bea4: e1a06001 mov r6, r1 <== NOT EXECUTED
return EINVAL;
3000bea8: 03a00016 moveq r0, #22 <== NOT EXECUTED
{
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000beac: 0a000016 beq 3000bf0c <pthread_getschedparam+0x78> <== NOT EXECUTED
return EINVAL;
the_thread = _Thread_Get( thread, &location );
3000beb0: e1a0100d mov r1, sp <== NOT EXECUTED 3000beb4: eb000b91 bl 3000ed00 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000beb8: e59d5000 ldr r5, [sp] <== NOT EXECUTED
register Thread_Control *the_thread;
if ( !policy || !param )
return EINVAL;
the_thread = _Thread_Get( thread, &location );
3000bebc: e1a0c000 mov ip, r0 <== NOT EXECUTED
switch ( location ) {
3000bec0: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000bec4: 13a00003 movne r0, #3 <== NOT EXECUTED
if ( !policy || !param )
return EINVAL;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000bec8: 1a00000f bne 3000bf0c <pthread_getschedparam+0x78> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000becc: e59ce0fc ldr lr, [ip, #252] ; 0xfc <== NOT EXECUTED
if ( policy )
*policy = api->schedpolicy;
3000bed0: e59e3084 ldr r3, [lr, #132] ; 0x84 <== NOT EXECUTED
if ( param ) {
*param = api->schedparam;
3000bed4: e28ee088 add lr, lr, #136 ; 0x88 <== NOT EXECUTED
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( policy )
*policy = api->schedpolicy;
3000bed8: e5863000 str r3, [r6] <== NOT EXECUTED
if ( param ) {
*param = api->schedparam;
3000bedc: e1a06004 mov r6, r4 <== NOT EXECUTED
3000bee0: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
3000bee4: e8a6000f stmia r6!, {r0, r1, r2, r3} <== NOT EXECUTED
3000bee8: e89e0007 ldm lr, {r0, r1, r2} <== NOT EXECUTED
3000beec: e8860007 stm r6, {r0, r1, r2} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000bef0: e59f3018 ldr r3, [pc, #24] ; 3000bf10 <pthread_getschedparam+0x7c><== NOT EXECUTED 3000bef4: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 3000bef8: e59c3014 ldr r3, [ip, #20] <== NOT EXECUTED 3000befc: e0633002 rsb r3, r3, r2 <== NOT EXECUTED
param->sched_priority =
3000bf00: e5843000 str r3, [r4] <== NOT EXECUTED
_POSIX_Priority_From_core( the_thread->current_priority );
}
_Thread_Enable_dispatch();
3000bf04: eb000b74 bl 3000ecdc <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000bf08: e1a00005 mov r0, r5 <== NOT EXECUTED
break;
}
return ESRCH;
}
3000bf0c: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000968c <pthread_getspecific>:
*/
void *pthread_getspecific(
pthread_key_t key
)
{
3000968c: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
30009690: e1a01000 mov r1, r0 <== NOT EXECUTED
pthread_key_t id,
Objects_Locations *location
)
{
return (POSIX_Keys_Control *)
_Objects_Get( &_POSIX_Keys_Information, (Objects_Id) id, location );
30009694: e1a0200d mov r2, sp <== NOT EXECUTED 30009698: e59f0040 ldr r0, [pc, #64] ; 300096e0 <pthread_getspecific+0x54><== NOT EXECUTED 3000969c: eb0008f8 bl 3000ba84 <_Objects_Get> <== NOT EXECUTED
uint32_t index;
Objects_Locations location;
void *key_data;
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
300096a0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300096a4: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return NULL;
300096a8: 13a04000 movne r4, #0 <== NOT EXECUTED
uint32_t index;
Objects_Locations location;
void *key_data;
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
300096ac: 1a000009 bne 300096d8 <pthread_getspecific+0x4c> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = _Objects_Get_API( _Thread_Executing->Object.id );
300096b0: e59f302c ldr r3, [pc, #44] ; 300096e4 <pthread_getspecific+0x58><== NOT EXECUTED 300096b4: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 300096b8: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
300096bc: e1a02c23 lsr r2, r3, #24 <== NOT EXECUTED 300096c0: e2022007 and r2, r2, #7 <== NOT EXECUTED
index = _Objects_Get_index( _Thread_Executing->Object.id );
key_data = (void *) the_key->Values[ api ][ index ];
300096c4: e2822005 add r2, r2, #5 <== NOT EXECUTED 300096c8: e7902102 ldr r2, [r0, r2, lsl #2] <== NOT EXECUTED
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = _Objects_Get_API( _Thread_Executing->Object.id );
index = _Objects_Get_index( _Thread_Executing->Object.id );
300096cc: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED
key_data = (void *) the_key->Values[ api ][ index ];
300096d0: e7924723 ldr r4, [r2, r3, lsr #14] <== NOT EXECUTED
_Thread_Enable_dispatch();
300096d4: eb000bee bl 3000c694 <_Thread_Enable_dispatch> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return NULL;
}
300096d8: e1a00004 mov r0, r4 <== NOT EXECUTED
300096dc: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000ed68 <pthread_join>:
int pthread_join(
pthread_t thread,
void **value_ptr
)
{
3000ed68: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
3000ed6c: e1a04001 mov r4, r1 <== NOT EXECUTED
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
void *return_pointer;
the_thread = _Thread_Get( thread, &location );
3000ed70: e28d1004 add r1, sp, #4 <== NOT EXECUTED 3000ed74: eb000b94 bl 30011bcc <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000ed78: e59d5004 ldr r5, [sp, #4] <== NOT EXECUTED 3000ed7c: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000ed80: 13a00003 movne r0, #3 <== NOT EXECUTED
POSIX_API_Control *api;
Objects_Locations location;
void *return_pointer;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000ed84: 1a00001a bne 3000edf4 <pthread_join+0x8c> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000ed88: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
3000ed8c: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED 3000ed90: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ed94: 1a000002 bne 3000eda4 <pthread_join+0x3c> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000ed98: eb000b82 bl 30011ba8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EINVAL;
3000ed9c: e3a00016 mov r0, #22 <== NOT EXECUTED 3000eda0: ea000013 b 3000edf4 <pthread_join+0x8c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000eda4: e59f204c ldr r2, [pc, #76] ; 3000edf8 <pthread_join+0x90> <== NOT EXECUTED 3000eda8: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED
}
if ( _Thread_Is_executing( the_thread ) ) {
3000edac: e1500002 cmp r0, r2 <== NOT EXECUTED 3000edb0: 1a000002 bne 3000edc0 <pthread_join+0x58> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000edb4: eb000b7b bl 30011ba8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EDEADLK;
3000edb8: e3a0002d mov r0, #45 ; 0x2d <== NOT EXECUTED 3000edbc: ea00000c b 3000edf4 <pthread_join+0x8c> <== NOT EXECUTED
/*
* Put ourself on the threads join list
*/
_Thread_Executing->Wait.return_argument = &return_pointer;
3000edc0: e582d028 str sp, [r2, #40] ; 0x28 <== 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;
3000edc4: e3a02001 mov r2, #1 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &api->Join_List );
_Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT );
3000edc8: e2830044 add r0, r3, #68 ; 0x44 <== NOT EXECUTED 3000edcc: e5832074 str r2, [r3, #116] ; 0x74 <== NOT EXECUTED 3000edd0: e1a01005 mov r1, r5 <== NOT EXECUTED 3000edd4: e59f2020 ldr r2, [pc, #32] ; 3000edfc <pthread_join+0x94> <== NOT EXECUTED 3000edd8: eb000c97 bl 3001203c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000eddc: eb000b71 bl 30011ba8 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( value_ptr )
3000ede0: e3540000 cmp r4, #0 <== NOT EXECUTED
*value_ptr = return_pointer;
3000ede4: 159d3000 ldrne r3, [sp] <== NOT EXECUTED
return 0;
3000ede8: 11a00005 movne r0, r5 <== NOT EXECUTED
_Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT );
_Thread_Enable_dispatch();
if ( value_ptr )
*value_ptr = return_pointer;
3000edec: 15843000 strne r3, [r4] <== NOT EXECUTED
return 0;
3000edf0: 01a00004 moveq r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
3000edf4: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED
3000952c <pthread_key_create>:
3000952c: e59f30d0 ldr r3, [pc, #208] ; 30009604 <pthread_key_create+0xd8>
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
30009530: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
30009534: e5932000 ldr r2, [r3]
30009538: e1a0a000 mov sl, r0
3000953c: e2822001 add r2, r2, #1
30009540: e5832000 str r2, [r3]
30009544: e1a05001 mov r5, r1
* the inactive chain of free keys control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void )
{
return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information );
30009548: e59f00b8 ldr r0, [pc, #184] ; 30009608 <pthread_key_create+0xdc> 3000954c: eb000830 bl 3000b614 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
30009550: e2504000 subs r4, r0, #0
30009554: 1a000002 bne 30009564 <pthread_key_create+0x38>
_Thread_Enable_dispatch();
30009558: eb000c4d bl 3000c694 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000955c: e3a0000b mov r0, #11 <== NOT EXECUTED
30009560: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
}
the_key->destructor = destructor;
30009564: e59f80a0 ldr r8, [pc, #160] ; 3000960c <pthread_key_create+0xe0> 30009568: e5845010 str r5, [r4, #16] 3000956c: e1a06004 mov r6, r4 30009570: e3a05003 mov r5, #3
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
the_key->Values[ the_api ] = NULL;
30009574: e3a07000 mov r7, #0
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
30009578: e5b83004 ldr r3, [r8, #4]!
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
the_key->Values[ the_api ] = NULL;
3000957c: e5867018 str r7, [r6, #24]
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
30009580: e5933004 ldr r3, [r3, #4] 30009584: e1d391b0 ldrh r9, [r3, #16] 30009588: e2899001 add r9, r9, #1
true,
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
3000958c: e1a09109 lsl r9, r9, #2
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
30009590: e1a00009 mov r0, r9 30009594: eb0010b1 bl 3000d860 <_Workspace_Allocate>
if ( !table ) {
30009598: e2503000 subs r3, r0, #0
3000959c: 1a000007 bne 300095c0 <pthread_key_create+0x94>
_POSIX_Keys_Free_memory( the_key );
300095a0: e1a00004 mov r0, r4 300095a4: eb00002f bl 30009668 <_POSIX_Keys_Free_memory>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
300095a8: e59f0058 ldr r0, [pc, #88] ; 30009608 <pthread_key_create+0xdc> 300095ac: e1a01004 mov r1, r4 300095b0: eb0008de bl 3000b930 <_Objects_Free>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
300095b4: eb000c36 bl 3000c694 <_Thread_Enable_dispatch>
return ENOMEM;
300095b8: e3a0000c mov r0, #12
300095bc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
}
the_key->Values[ the_api ] = table;
300095c0: e5863018 str r3, [r6, #24]
memset( table, '\0', bytes_to_allocate );
300095c4: e1a01007 mov r1, r7 300095c8: e1a02009 mov r2, r9 300095cc: eb002480 bl 300127d4 <memset>
* This is a bit more complex than one might initially expect because
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
300095d0: e2555001 subs r5, r5, #1
_Thread_Enable_dispatch();
return ENOMEM;
}
the_key->Values[ the_api ] = table;
memset( table, '\0', bytes_to_allocate );
300095d4: e2866004 add r6, r6, #4
* This is a bit more complex than one might initially expect because
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
300095d8: 1affffe6 bne 30009578 <pthread_key_create+0x4c>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300095dc: e59f2024 ldr r2, [pc, #36] ; 30009608 <pthread_key_create+0xdc>
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
300095e0: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300095e4: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
300095e8: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300095ec: e7824101 str r4, [r2, r1, lsl #2]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
300095f0: e584500c str r5, [r4, #12]
the_key->Values[ the_api ] = table;
memset( table, '\0', bytes_to_allocate );
}
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
300095f4: e58a3000 str r3, [sl]
_Thread_Enable_dispatch();
300095f8: eb000c25 bl 3000c694 <_Thread_Enable_dispatch>
return 0;
300095fc: e1a00005 mov r0, r5
}
30009600: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
30025b98 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
30025b98: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
30025b9c: e2517000 subs r7, r1, #0 <== NOT EXECUTED 30025ba0: 0a000002 beq 30025bb0 <pthread_kill+0x18> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
30025ba4: e2478001 sub r8, r7, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
30025ba8: e358001f cmp r8, #31 <== NOT EXECUTED 30025bac: 9a000002 bls 30025bbc <pthread_kill+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30025bb0: ebffc191 bl 300161fc <__errno> <== NOT EXECUTED 30025bb4: e3a03016 mov r3, #22 <== NOT EXECUTED 30025bb8: ea000022 b 30025c48 <pthread_kill+0xb0> <== NOT EXECUTED
the_thread = _Thread_Get( thread, &location );
30025bbc: e1a0100d mov r1, sp <== NOT EXECUTED 30025bc0: ebffab36 bl 300108a0 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30025bc4: e59d6000 ldr r6, [sp] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
30025bc8: e1a05000 mov r5, r0 <== NOT EXECUTED
switch ( location ) {
30025bcc: e3560000 cmp r6, #0 <== NOT EXECUTED 30025bd0: 1a00001a bne 30025c40 <pthread_kill+0xa8> <== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
30025bd4: e59f2078 ldr r2, [pc, #120] ; 30025c54 <pthread_kill+0xbc> <== NOT EXECUTED 30025bd8: e3a0100c mov r1, #12 <== NOT EXECUTED 30025bdc: e0222791 mla r2, r1, r7, r2 <== NOT EXECUTED 30025be0: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
30025be4: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
30025be8: e3520001 cmp r2, #1 <== NOT EXECUTED 30025bec: 1a000002 bne 30025bfc <pthread_kill+0x64> <== NOT EXECUTED
_Thread_Enable_dispatch();
30025bf0: ebffab21 bl 3001087c <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30025bf4: e1a00006 mov r0, r6 <== NOT EXECUTED 30025bf8: ea000014 b 30025c50 <pthread_kill+0xb8> <== NOT EXECUTED
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
30025bfc: e59320d4 ldr r2, [r3, #212] ; 0xd4 <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
30025c00: e3a04001 mov r4, #1 <== NOT EXECUTED 30025c04: e1828814 orr r8, r2, r4, lsl r8 <== NOT EXECUTED
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
30025c08: e1a01007 mov r1, r7 <== NOT EXECUTED
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
30025c0c: e58380d4 str r8, [r3, #212] ; 0xd4 <== NOT EXECUTED
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
30025c10: e1a02006 mov r2, r6 <== NOT EXECUTED 30025c14: ebffff99 bl 30025a80 <_POSIX_signals_Unblock_thread> <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
30025c18: e59f3038 ldr r3, [pc, #56] ; 30025c58 <pthread_kill+0xc0> <== NOT EXECUTED 30025c1c: e5932000 ldr r2, [r3] <== NOT EXECUTED 30025c20: e3520000 cmp r2, #0 <== NOT EXECUTED 30025c24: 0a000002 beq 30025c34 <pthread_kill+0x9c> <== NOT EXECUTED 30025c28: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 30025c2c: e1550002 cmp r5, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
30025c30: 05c34010 strbeq r4, [r3, #16] <== NOT EXECUTED
}
_Thread_Enable_dispatch();
30025c34: ebffab10 bl 3001087c <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30025c38: e3a00000 mov r0, #0 <== NOT EXECUTED 30025c3c: ea000003 b 30025c50 <pthread_kill+0xb8> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
30025c40: ebffc16d bl 300161fc <__errno> <== NOT EXECUTED 30025c44: e3a03003 mov r3, #3 <== NOT EXECUTED 30025c48: e5803000 str r3, [r0] <== NOT EXECUTED 30025c4c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
30025c50: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000b6a0 <pthread_mutex_destroy>:
*/
int pthread_mutex_destroy(
pthread_mutex_t *mutex
)
{
3000b6a0: e92d4031 push {r0, r4, r5, lr}
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000b6a4: e1a0100d mov r1, sp 3000b6a8: eb000018 bl 3000b710 <_POSIX_Mutex_Get>
switch ( location ) {
3000b6ac: e59d5000 ldr r5, [sp]
)
{
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000b6b0: e1a04000 mov r4, r0
switch ( location ) {
3000b6b4: e3550000 cmp r5, #0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b6b8: 13a00016 movne r0, #22
{
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
switch ( location ) {
3000b6bc: 1a000011 bne 3000b708 <pthread_mutex_destroy+0x68>
/*
* XXX: There is an error for the mutex being locked
* or being in use by a condition variable.
*/
if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) {
3000b6c0: e5943064 ldr r3, [r4, #100] ; 0x64 3000b6c4: e3530000 cmp r3, #0
3000b6c8: 1a000002 bne 3000b6d8 <pthread_mutex_destroy+0x38>
_Thread_Enable_dispatch();
3000b6cc: eb000d82 bl 3000ecdc <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000b6d0: e3a00010 mov r0, #16 <== NOT EXECUTED 3000b6d4: ea00000b b 3000b708 <pthread_mutex_destroy+0x68> <== NOT EXECUTED
}
_Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object );
3000b6d8: e59f002c ldr r0, [pc, #44] ; 3000b70c <pthread_mutex_destroy+0x6c> 3000b6dc: e1a01004 mov r1, r4 3000b6e0: eb00097f bl 3000dce4 <_Objects_Close>
_CORE_mutex_Flush( &the_mutex->Mutex, NULL, EINVAL );
3000b6e4: e3a02016 mov r2, #22 3000b6e8: e2840014 add r0, r4, #20 3000b6ec: e1a01005 mov r1, r5 3000b6f0: eb000709 bl 3000d31c <_CORE_mutex_Flush>
RTEMS_INLINE_ROUTINE void _POSIX_Mutex_Free (
POSIX_Mutex_Control *the_mutex
)
{
_Objects_Free( &_POSIX_Mutex_Information, &the_mutex->Object );
3000b6f4: e59f0010 ldr r0, [pc, #16] ; 3000b70c <pthread_mutex_destroy+0x6c> 3000b6f8: e1a01004 mov r1, r4 3000b6fc: eb000a1d bl 3000df78 <_Objects_Free>
_POSIX_Mutex_Free( the_mutex );
_Thread_Enable_dispatch();
3000b700: eb000d75 bl 3000ecdc <_Thread_Enable_dispatch>
return 0;
3000b704: e1a00005 mov r0, r5
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000b708: e8bd8038 pop {r3, r4, r5, pc}
3000b81c <pthread_mutex_init>:
CORE_mutex_Attributes *the_mutex_attr;
const pthread_mutexattr_t *the_attr;
CORE_mutex_Disciplines the_discipline;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Mutex_Default_attributes;
3000b81c: e59f3130 ldr r3, [pc, #304] ; 3000b954 <pthread_mutex_init+0x138> 3000b820: e3510000 cmp r1, #0
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
3000b824: e92d40f0 push {r4, r5, r6, r7, lr}
CORE_mutex_Attributes *the_mutex_attr;
const pthread_mutexattr_t *the_attr;
CORE_mutex_Disciplines the_discipline;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Mutex_Default_attributes;
3000b828: 11a06001 movne r6, r1 3000b82c: 01a06003 moveq r6, r3
/* Check for NULL mutex */
if ( !mutex )
3000b830: e2505000 subs r5, r0, #0
3000b834: 0a000042 beq 3000b944 <pthread_mutex_init+0x128>
}
}
}
#endif
if ( !the_attr->is_initialized )
3000b838: e5963000 ldr r3, [r6] 3000b83c: e3530000 cmp r3, #0
3000b840: 0a00003f beq 3000b944 <pthread_mutex_init+0x128>
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000b844: e5963004 ldr r3, [r6, #4] 3000b848: e3530001 cmp r3, #1
return ENOSYS;
3000b84c: 03a00058 moveq r0, #88 ; 0x58
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000b850: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return ENOSYS;
if ( the_attr->process_shared != PTHREAD_PROCESS_PRIVATE )
3000b854: e3530000 cmp r3, #0
3000b858: 1a000039 bne 3000b944 <pthread_mutex_init+0x128>
return EINVAL;
/*
* Determine the discipline of the mutex
*/
switch ( the_attr->protocol ) {
3000b85c: e596700c ldr r7, [r6, #12] 3000b860: e3570001 cmp r7, #1
3000b864: 0a000006 beq 3000b884 <pthread_mutex_init+0x68>
3000b868: e3570002 cmp r7, #2
3000b86c: 0a000002 beq 3000b87c <pthread_mutex_init+0x60>
3000b870: e3570000 cmp r7, #0
3000b874: 1a000032 bne 3000b944 <pthread_mutex_init+0x128>
3000b878: ea000002 b 3000b888 <pthread_mutex_init+0x6c>
break;
case PTHREAD_PRIO_INHERIT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
break;
case PTHREAD_PRIO_PROTECT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
3000b87c: e3a07003 mov r7, #3 <== NOT EXECUTED
break;
3000b880: ea000000 b 3000b888 <pthread_mutex_init+0x6c> <== NOT EXECUTED
switch ( the_attr->protocol ) {
case PTHREAD_PRIO_NONE:
the_discipline = CORE_MUTEX_DISCIPLINES_FIFO;
break;
case PTHREAD_PRIO_INHERIT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
3000b884: e3a07002 mov r7, #2 <== NOT EXECUTED
}
/*
* Validate the priority ceiling field -- should always be valid.
*/
if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )
3000b888: e5960008 ldr r0, [r6, #8] 3000b88c: eb0000c1 bl 3000bb98 <_POSIX_Priority_Is_valid> 3000b890: e3500000 cmp r0, #0
3000b894: 0a00002a beq 3000b944 <pthread_mutex_init+0x128>
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
/*
* Validate the mutex type and set appropriate SuperCore mutex
* attributes.
*/
switch ( the_attr->type ) {
3000b898: e5963010 ldr r3, [r6, #16] 3000b89c: e3530003 cmp r3, #3
3000b8a0: 8a000029 bhi 3000b94c <pthread_mutex_init+0x130>
3000b8a4: e59f30ac ldr r3, [pc, #172] ; 3000b958 <pthread_mutex_init+0x13c> 3000b8a8: e5932000 ldr r2, [r3] 3000b8ac: e2822001 add r2, r2, #1 3000b8b0: e5832000 str r2, [r3]
* _POSIX_Mutex_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void )
{
return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information );
3000b8b4: e59f00a0 ldr r0, [pc, #160] ; 3000b95c <pthread_mutex_init+0x140> 3000b8b8: eb0008e7 bl 3000dc5c <_Objects_Allocate>
*/
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
3000b8bc: e2504000 subs r4, r0, #0
3000b8c0: 1a000002 bne 3000b8d0 <pthread_mutex_init+0xb4>
_Thread_Enable_dispatch();
3000b8c4: eb000d04 bl 3000ecdc <_Thread_Enable_dispatch>
return EAGAIN;
3000b8c8: e3a0000b mov r0, #11
3000b8cc: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
the_mutex->process_shared = the_attr->process_shared;
3000b8d0: e5963004 ldr r3, [r6, #4]
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = true;
3000b8d4: e3a02001 mov r2, #1
if ( !the_mutex ) {
_Thread_Enable_dispatch();
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
3000b8d8: e5843010 str r3, [r4, #16]
the_mutex_attr = &the_mutex->Mutex.Attributes;
if ( the_attr->recursive )
3000b8dc: e5963014 ldr r3, [r6, #20]
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = true;
3000b8e0: e5c42058 strb r2, [r4, #88] ; 0x58
the_mutex->process_shared = the_attr->process_shared;
the_mutex_attr = &the_mutex->Mutex.Attributes;
if ( the_attr->recursive )
3000b8e4: e3530000 cmp r3, #0
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
3000b8e8: 13a03000 movne r3, #0
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
3000b8ec: 03a03001 moveq r3, #1 3000b8f0: e5843054 str r3, [r4, #84] ; 0x54
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000b8f4: e59f3064 ldr r3, [pc, #100] ; 3000b960 <pthread_mutex_init+0x144>
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
the_mutex_attr = &the_mutex->Mutex.Attributes;
3000b8f8: e2841054 add r1, r4, #84 ; 0x54 3000b8fc: e5d30000 ldrb r0, [r3] 3000b900: e5963008 ldr r3, [r6, #8]
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = true;
the_mutex_attr->priority_ceiling =
_POSIX_Priority_To_core( the_attr->prio_ceiling );
the_mutex_attr->discipline = the_discipline;
3000b904: e584705c str r7, [r4, #92] ; 0x5c 3000b908: e0633000 rsb r3, r3, r0
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = true;
the_mutex_attr->priority_ceiling =
3000b90c: e5843060 str r3, [r4, #96] ; 0x60
the_mutex_attr->discipline = the_discipline;
/*
* Must be initialized to unlocked.
*/
_CORE_mutex_Initialize(
3000b910: e2840014 add r0, r4, #20 3000b914: eb000681 bl 3000d320 <_CORE_mutex_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b918: e59f203c ldr r2, [pc, #60] ; 3000b95c <pthread_mutex_init+0x140>
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000b91c: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b920: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000b924: e1d410b8 ldrh r1, [r4, #8]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000b928: e3a06000 mov r6, #0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b92c: e7824101 str r4, [r2, r1, lsl #2]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000b930: e584600c str r6, [r4, #12]
CORE_MUTEX_UNLOCKED
);
_Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 );
*mutex = the_mutex->Object.id;
3000b934: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
3000b938: eb000ce7 bl 3000ecdc <_Thread_Enable_dispatch>
return 0;
3000b93c: e1a00006 mov r0, r6
3000b940: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* Validate the priority ceiling field -- should always be valid.
*/
if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )
return EINVAL;
3000b944: e3a00016 mov r0, #22 <== NOT EXECUTED
3000b948: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
break;
default:
return EINVAL;
3000b94c: e3a00016 mov r0, #22 <== NOT EXECUTED
*mutex = the_mutex->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000b950: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000b9d0 <pthread_mutex_setprioceiling>:
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
3000b9d0: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
Priority_Control the_priority;
if ( !old_ceiling )
3000b9d4: e2528000 subs r8, r2, #0 <== NOT EXECUTED
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
3000b9d8: e1a04000 mov r4, r0 <== NOT EXECUTED 3000b9dc: e1a05001 mov r5, r1 <== NOT EXECUTED
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
Priority_Control the_priority;
if ( !old_ceiling )
3000b9e0: 0a00001b beq 3000ba54 <pthread_mutex_setprioceiling+0x84> <== NOT EXECUTED
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000b9e4: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b9e8: eb00006a bl 3000bb98 <_POSIX_Priority_Is_valid> <== NOT EXECUTED 3000b9ec: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b9f0: 0a000017 beq 3000ba54 <pthread_mutex_setprioceiling+0x84> <== NOT EXECUTED 3000b9f4: e59f6060 ldr r6, [pc, #96] ; 3000ba5c <pthread_mutex_setprioceiling+0x8c><== NOT EXECUTED
/*
* Must acquire the mutex before we can change it's ceiling.
* POSIX says block until we acquire it.
*/
(void) pthread_mutex_lock( mutex );
3000b9f8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b9fc: e5d67000 ldrb r7, [r6] <== NOT EXECUTED 3000ba00: ebffffd7 bl 3000b964 <pthread_mutex_lock> <== NOT EXECUTED
* operations. * * NOTE: This makes it easier to get 100% binary coverage since the * bad Id case is handled by the switch. */ the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000ba04: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ba08: e1a0100d mov r1, sp <== NOT EXECUTED 3000ba0c: ebffff3f bl 3000b710 <_POSIX_Mutex_Get> <== NOT EXECUTED
switch ( location ) {
3000ba10: e59d4000 ldr r4, [sp] <== NOT EXECUTED
* operations. * * NOTE: This makes it easier to get 100% binary coverage since the * bad Id case is handled by the switch. */ the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000ba14: e1a03000 mov r3, r0 <== NOT EXECUTED
switch ( location ) {
3000ba18: e3540000 cmp r4, #0 <== NOT EXECUTED 3000ba1c: 1a00000c bne 3000ba54 <pthread_mutex_setprioceiling+0x84> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000ba20: e5902060 ldr r2, [r0, #96] ; 0x60 <== NOT EXECUTED 3000ba24: e5d61000 ldrb r1, [r6] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000ba28: e0655007 rsb r5, r5, r7 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000ba2c: e0622001 rsb r2, r2, r1 <== NOT EXECUTED
case OBJECTS_LOCAL:
*old_ceiling = _POSIX_Priority_From_core(
3000ba30: e5882000 str r2, [r8] <== NOT EXECUTED
);
the_mutex->Mutex.Attributes.priority_ceiling = the_priority;
/*
* We are required to unlock the mutex before we return.
*/
_CORE_mutex_Surrender(
3000ba34: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
case OBJECTS_LOCAL:
*old_ceiling = _POSIX_Priority_From_core(
the_mutex->Mutex.Attributes.priority_ceiling
);
the_mutex->Mutex.Attributes.priority_ceiling = the_priority;
3000ba38: e5805060 str r5, [r0, #96] ; 0x60 <== NOT EXECUTED
/*
* We are required to unlock the mutex before we return.
*/
_CORE_mutex_Surrender(
3000ba3c: e1a02004 mov r2, r4 <== NOT EXECUTED 3000ba40: e2800014 add r0, r0, #20 <== NOT EXECUTED 3000ba44: eb0006ae bl 3000d504 <_CORE_mutex_Surrender> <== NOT EXECUTED
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
3000ba48: eb000ca3 bl 3000ecdc <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000ba4c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ba50: ea000000 b 3000ba58 <pthread_mutex_setprioceiling+0x88> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000ba54: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000ba58: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000ba60 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
3000ba60: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
3000ba64: e1a06000 mov r6, r0 <== NOT EXECUTED
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000ba68: e1a00001 mov r0, r1 <== NOT EXECUTED 3000ba6c: e1a0100d mov r1, sp <== NOT EXECUTED 3000ba70: eb00002a bl 3000bb20 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
3000ba74: e3500003 cmp r0, #3 <== NOT EXECUTED 3000ba78: 13a05000 movne r5, #0 <== NOT EXECUTED 3000ba7c: 03a05001 moveq r5, #1 <== NOT EXECUTED 3000ba80: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
3000ba84: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ba88: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ba8c: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000ba90: ebffffb6 bl 3000b970 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
3000ba94: e3550000 cmp r5, #0 <== NOT EXECUTED 3000ba98: 1a000008 bne 3000bac0 <pthread_mutex_timedlock+0x60> <== NOT EXECUTED 3000ba9c: e3500010 cmp r0, #16 <== NOT EXECUTED 3000baa0: 1a000006 bne 3000bac0 <pthread_mutex_timedlock+0x60> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000baa4: e3540000 cmp r4, #0 <== NOT EXECUTED
return EINVAL;
3000baa8: 03a00016 moveq r0, #22 <== NOT EXECUTED
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000baac: 0a000003 beq 3000bac0 <pthread_mutex_timedlock+0x60> <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000bab0: e2444001 sub r4, r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
3000bab4: e3540001 cmp r4, #1 <== NOT EXECUTED 3000bab8: 83a00010 movhi r0, #16 <== NOT EXECUTED 3000babc: 93a00074 movls r0, #116 ; 0x74 <== NOT EXECUTED
}
return lock_status;
}
3000bac0: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000bad4 <pthread_mutex_trylock>:
int pthread_mutex_trylock(
pthread_mutex_t *mutex
)
{
return _POSIX_Mutex_Lock_support( mutex, false, THREAD_QUEUE_WAIT_FOREVER );
3000bad4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000bad8: e1a02001 mov r2, r1 <== NOT EXECUTED 3000badc: eaffffa3 b 3000b970 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED
3000b504 <pthread_mutexattr_destroy>:
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000b504: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000b508: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000b50c: 012fff1e bxeq lr <== NOT EXECUTED 3000b510: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b514: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000b518: 13a00000 movne r0, #0 <== NOT EXECUTED 3000b51c: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000b520: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000b524: e12fff1e bx lr <== NOT EXECUTED
3000b528 <pthread_mutexattr_getprioceiling>:
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000b528: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000b52c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000b530: 012fff1e bxeq lr <== NOT EXECUTED 3000b534: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000b538: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b53c: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*prioceiling = attr->prio_ceiling;
3000b540: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000b544: 13a00000 movne r0, #0 <== NOT EXECUTED 3000b548: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*prioceiling = attr->prio_ceiling;
3000b54c: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
return EINVAL;
3000b550: 03a00016 moveq r0, #22 <== NOT EXECUTED
*prioceiling = attr->prio_ceiling;
return 0;
}
3000b554: e12fff1e bx lr <== NOT EXECUTED
3000b558 <pthread_mutexattr_getprotocol>:
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000b558: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000b55c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000b560: 012fff1e bxeq lr <== NOT EXECUTED 3000b564: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000b568: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b56c: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*protocol = attr->protocol;
3000b570: 1593300c ldrne r3, [r3, #12] <== NOT EXECUTED
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000b574: 13a00000 movne r0, #0 <== NOT EXECUTED 3000b578: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*protocol = attr->protocol;
3000b57c: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
return EINVAL;
3000b580: 03a00016 moveq r0, #22 <== NOT EXECUTED
*protocol = attr->protocol;
return 0;
}
3000b584: e12fff1e bx lr <== NOT EXECUTED
3000b588 <pthread_mutexattr_getpshared>:
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000b588: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000b58c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000b590: 012fff1e bxeq lr <== NOT EXECUTED 3000b594: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000b598: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b59c: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000b5a0: 15933004 ldrne r3, [r3, #4] <== NOT EXECUTED
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000b5a4: 13a00000 movne r0, #0 <== NOT EXECUTED 3000b5a8: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000b5ac: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
return EINVAL;
3000b5b0: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
return 0;
}
3000b5b4: e12fff1e bx lr <== NOT EXECUTED
3000b5e8 <pthread_mutexattr_setprioceiling>:
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
3000b5e8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !attr || !attr->is_initialized )
3000b5ec: e2504000 subs r4, r0, #0 <== NOT EXECUTED
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
3000b5f0: e1a05001 mov r5, r1 <== NOT EXECUTED
if ( !attr || !attr->is_initialized )
3000b5f4: 0a000009 beq 3000b620 <pthread_mutexattr_setprioceiling+0x38><== NOT EXECUTED 3000b5f8: e5943000 ldr r3, [r4] <== NOT EXECUTED 3000b5fc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b600: 0a000006 beq 3000b620 <pthread_mutexattr_setprioceiling+0x38><== NOT EXECUTED
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000b604: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b608: eb000162 bl 3000bb98 <_POSIX_Priority_Is_valid> <== NOT EXECUTED 3000b60c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
attr->prio_ceiling = prioceiling;
3000b610: 15845008 strne r5, [r4, #8] <== NOT EXECUTED
return 0;
3000b614: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000b618: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
3000b61c: ea000001 b 3000b628 <pthread_mutexattr_setprioceiling+0x40><== NOT EXECUTED
pthread_mutexattr_t *attr,
int prioceiling
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000b620: e3a00016 mov r0, #22 <== NOT EXECUTED
3000b624: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
return EINVAL;
3000b628: e3a00016 mov r0, #22 <== NOT EXECUTED
attr->prio_ceiling = prioceiling;
return 0;
}
3000b62c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b630 <pthread_mutexattr_setprotocol>:
int pthread_mutexattr_setprotocol(
pthread_mutexattr_t *attr,
int protocol
)
{
if ( !attr || !attr->is_initialized )
3000b630: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b634: 0a000007 beq 3000b658 <pthread_mutexattr_setprotocol+0x28> <== NOT EXECUTED 3000b638: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000b63c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b640: 0a000004 beq 3000b658 <pthread_mutexattr_setprotocol+0x28> <== NOT EXECUTED
return EINVAL;
switch ( protocol ) {
3000b644: e3510002 cmp r1, #2 <== NOT EXECUTED
case PTHREAD_PRIO_NONE:
case PTHREAD_PRIO_INHERIT:
case PTHREAD_PRIO_PROTECT:
attr->protocol = protocol;
3000b648: 9580100c strls r1, [r0, #12] <== NOT EXECUTED
return 0;
3000b64c: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( protocol ) {
3000b650: 912fff1e bxls lr <== NOT EXECUTED 3000b654: ea000001 b 3000b660 <pthread_mutexattr_setprotocol+0x30> <== NOT EXECUTED
pthread_mutexattr_t *attr,
int protocol
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000b658: e3a00016 mov r0, #22 <== NOT EXECUTED 3000b65c: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_PRIO_PROTECT:
attr->protocol = protocol;
return 0;
default:
return EINVAL;
3000b660: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000b664: e12fff1e bx lr <== NOT EXECUTED
3000b668 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
3000b668: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b66c: 0a000007 beq 3000b690 <pthread_mutexattr_setpshared+0x28> <== NOT EXECUTED 3000b670: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000b674: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b678: 0a000004 beq 3000b690 <pthread_mutexattr_setpshared+0x28> <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000b67c: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000b680: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000b684: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000b688: 912fff1e bxls lr <== NOT EXECUTED 3000b68c: ea000001 b 3000b698 <pthread_mutexattr_setpshared+0x30> <== NOT EXECUTED
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000b690: e3a00016 mov r0, #22 <== NOT EXECUTED 3000b694: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000b698: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000b69c: e12fff1e bx lr <== NOT EXECUTED
30009dd8 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
30009dd8: e3500000 cmp r0, #0 <== NOT EXECUTED 30009ddc: 13510000 cmpne r1, #0 <== NOT EXECUTED
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
30009de0: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
if ( !once_control || !init_routine )
30009de4: e1a04000 mov r4, r0 <== NOT EXECUTED 30009de8: e1a05001 mov r5, r1 <== NOT EXECUTED 30009dec: 13a00000 movne r0, #0 <== NOT EXECUTED 30009df0: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
30009df4: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
30009df8: 0a000012 beq 30009e48 <pthread_once+0x70> <== NOT EXECUTED
return EINVAL;
if ( !once_control->init_executed ) {
30009dfc: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30009e00: e3530000 cmp r3, #0 <== NOT EXECUTED 30009e04: 1a00000f bne 30009e48 <pthread_once+0x70> <== NOT EXECUTED
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
30009e08: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED 30009e0c: e1a01000 mov r1, r0 <== NOT EXECUTED 30009e10: e1a0200d mov r2, sp <== NOT EXECUTED 30009e14: eb0002c5 bl 3000a930 <rtems_task_mode> <== NOT EXECUTED
if ( !once_control->init_executed ) {
30009e18: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30009e1c: e3530000 cmp r3, #0 <== NOT EXECUTED
once_control->is_initialized = true;
30009e20: 02833001 addeq r3, r3, #1 <== NOT EXECUTED 30009e24: 05843000 streq r3, [r4] <== NOT EXECUTED
once_control->init_executed = true;
30009e28: 05843004 streq r3, [r4, #4] <== NOT EXECUTED
(*init_routine)();
30009e2c: 01a0e00f moveq lr, pc <== NOT EXECUTED 30009e30: 012fff15 bxeq r5 <== NOT EXECUTED
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
30009e34: e59d0000 ldr r0, [sp] <== NOT EXECUTED 30009e38: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED 30009e3c: e1a0200d mov r2, sp <== NOT EXECUTED 30009e40: eb0002ba bl 3000a930 <rtems_task_mode> <== NOT EXECUTED
} return 0;
30009e44: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30009e48: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000a8d0 <pthread_rwlock_destroy>:
)
{
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
3000a8d0: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_rwlock_destroy(
pthread_rwlock_t *rwlock
)
{
3000a8d4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
3000a8d8: 0a000017 beq 3000a93c <pthread_rwlock_destroy+0x6c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
3000a8dc: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a8e0: e59f005c ldr r0, [pc, #92] ; 3000a944 <pthread_rwlock_destroy+0x74><== NOT EXECUTED 3000a8e4: e1a0200d mov r2, sp <== NOT EXECUTED 3000a8e8: eb000a74 bl 3000d2c0 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000a8ec: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a8f0: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a8f4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a8f8: 1a00000f bne 3000a93c <pthread_rwlock_destroy+0x6c> <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* If there is at least one thread waiting, then do not delete it.
*/
if ( _Thread_queue_First( &the_rwlock->RWLock.Wait_queue ) != NULL ) {
3000a8fc: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000a900: eb000f6d bl 3000e6bc <_Thread_queue_First> <== NOT EXECUTED 3000a904: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000a908: 0a000002 beq 3000a918 <pthread_rwlock_destroy+0x48> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a90c: eb000d6f bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000a910: e3a00010 mov r0, #16 <== NOT EXECUTED 3000a914: ea000009 b 3000a940 <pthread_rwlock_destroy+0x70> <== NOT EXECUTED
/*
* POSIX doesn't require behavior when it is locked.
*/
_Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object );
3000a918: e59f0024 ldr r0, [pc, #36] ; 3000a944 <pthread_rwlock_destroy+0x74><== NOT EXECUTED 3000a91c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a920: eb00096c bl 3000ced8 <_Objects_Close> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free (
POSIX_RWLock_Control *the_RWLock
)
{
_Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object );
3000a924: e59f0018 ldr r0, [pc, #24] ; 3000a944 <pthread_rwlock_destroy+0x74><== NOT EXECUTED 3000a928: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a92c: eb000a0e bl 3000d16c <_Objects_Free> <== NOT EXECUTED
_POSIX_RWLock_Free( the_rwlock );
_Thread_Enable_dispatch();
3000a930: eb000d66 bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a934: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a938: ea000000 b 3000a940 <pthread_rwlock_destroy+0x70> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a93c: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a940: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000a948 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
3000a948: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr} <== NOT EXECUTED
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
3000a94c: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000a950: 0a000024 beq 3000a9e8 <pthread_rwlock_init+0xa0> <== NOT EXECUTED
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
3000a954: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a958: 1a000003 bne 3000a96c <pthread_rwlock_init+0x24> <== NOT EXECUTED
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
3000a95c: e1a0000d mov r0, sp <== NOT EXECUTED 3000a960: eb000254 bl 3000b2b8 <pthread_rwlockattr_init> <== NOT EXECUTED 3000a964: e1a0400d mov r4, sp <== NOT EXECUTED
the_attr = &default_attr;
3000a968: e1a0100d mov r1, sp <== NOT EXECUTED
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
3000a96c: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000a970: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a974: 0a00001b beq 3000a9e8 <pthread_rwlock_init+0xa0> <== NOT EXECUTED
return EINVAL;
switch ( the_attr->process_shared ) {
3000a978: e5915004 ldr r5, [r1, #4] <== NOT EXECUTED 3000a97c: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a980: 1a000018 bne 3000a9e8 <pthread_rwlock_init+0xa0> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000a984: e59f3064 ldr r3, [pc, #100] ; 3000a9f0 <pthread_rwlock_init+0xa8><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
3000a988: e58d5008 str r5, [sp, #8] <== NOT EXECUTED 3000a98c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000a990: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000a994: e5832000 str r2, [r3] <== NOT EXECUTED
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
_Objects_Allocate( &_POSIX_RWLock_Information );
3000a998: e59f6054 ldr r6, [pc, #84] ; 3000a9f4 <pthread_rwlock_init+0xac><== NOT EXECUTED 3000a99c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a9a0: eb00092a bl 3000ce50 <_Objects_Allocate> <== NOT EXECUTED
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
3000a9a4: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000a9a8: 1a000002 bne 3000a9b8 <pthread_rwlock_init+0x70> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a9ac: eb000d47 bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000a9b0: e3a0000b mov r0, #11 <== NOT EXECUTED 3000a9b4: ea00000c b 3000a9ec <pthread_rwlock_init+0xa4> <== NOT EXECUTED
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
3000a9b8: e2840010 add r0, r4, #16 <== NOT EXECUTED 3000a9bc: e28d1008 add r1, sp, #8 <== NOT EXECUTED 3000a9c0: eb000703 bl 3000c5d4 <_CORE_RWLock_Initialize> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a9c4: e596201c ldr r2, [r6, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000a9c8: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000a9cc: e1d410b8 ldrh r1, [r4, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a9d0: e7824101 str r4, [r2, r1, lsl #2] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000a9d4: e584500c str r5, [r4, #12] <== NOT EXECUTED
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
3000a9d8: e5873000 str r3, [r7] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a9dc: eb000d3b bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a9e0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a9e4: ea000000 b 3000a9ec <pthread_rwlock_init+0xa4> <== NOT EXECUTED
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
3000a9e8: e3a00016 mov r0, #22 <== NOT EXECUTED
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000a9ec: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000a9f8 <pthread_rwlock_rdlock>:
*/
int pthread_rwlock_rdlock(
pthread_rwlock_t *rwlock
)
{
3000a9f8: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000a9fc: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000aa00: 0a000011 beq 3000aa4c <pthread_rwlock_rdlock+0x54> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
3000aa04: e59f0048 ldr r0, [pc, #72] ; 3000aa54 <pthread_rwlock_rdlock+0x5c><== NOT EXECUTED 3000aa08: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000aa0c: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000aa10: eb000a2a bl 3000d2c0 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000aa14: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3000aa18: e3530000 cmp r3, #0 <== NOT EXECUTED 3000aa1c: 1a00000a bne 3000aa4c <pthread_rwlock_rdlock+0x54> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000aa20: e58d3000 str r3, [sp] <== NOT EXECUTED 3000aa24: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000aa28: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000aa2c: e3a02001 mov r2, #1 <== NOT EXECUTED 3000aa30: eb0006ef bl 3000c5f4 <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED
true, /* we are willing to wait forever */
0,
NULL
);
_Thread_Enable_dispatch();
3000aa34: eb000d25 bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000aa38: e59f3018 ldr r3, [pc, #24] ; 3000aa58 <pthread_rwlock_rdlock+0x60><== NOT EXECUTED 3000aa3c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000aa40: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000aa44: eb000060 bl 3000abcc <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000aa48: ea000000 b 3000aa50 <pthread_rwlock_rdlock+0x58> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000aa4c: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000aa50: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED
3000aa5c <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000aa5c: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000aa60: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000aa64: 0a000026 beq 3000ab04 <pthread_rwlock_timedrdlock+0xa8> <== NOT EXECUTED
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000aa68: e1a00001 mov r0, r1 <== NOT EXECUTED 3000aa6c: e28d1004 add r1, sp, #4 <== NOT EXECUTED 3000aa70: eb001883 bl 30010c84 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 3000aa74: e5961000 ldr r1, [r6] <== NOT EXECUTED 3000aa78: e1a04000 mov r4, r0 <== NOT EXECUTED 3000aa7c: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000aa80: e59f0084 ldr r0, [pc, #132] ; 3000ab0c <pthread_rwlock_timedrdlock+0xb0><== NOT EXECUTED 3000aa84: eb000a0d bl 3000d2c0 <_Objects_Get> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000aa88: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3000aa8c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000aa90: 1a00001b bne 3000ab04 <pthread_rwlock_timedrdlock+0xa8> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000aa94: e58d3000 str r3, [sp] <== NOT EXECUTED
int _EXFUN(pthread_rwlock_init, (pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr)); int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedrdlock,
3000aa98: e3540003 cmp r4, #3 <== NOT EXECUTED 3000aa9c: 13a05000 movne r5, #0 <== NOT EXECUTED 3000aaa0: 03a05001 moveq r5, #1 <== NOT EXECUTED 3000aaa4: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000aaa8: e5961000 ldr r1, [r6] <== NOT EXECUTED 3000aaac: e1a02005 mov r2, r5 <== NOT EXECUTED 3000aab0: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3000aab4: eb0006ce bl 3000c5f4 <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
3000aab8: eb000d04 bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !do_wait ) {
3000aabc: e3550000 cmp r5, #0 <== NOT EXECUTED 3000aac0: 1a00000a bne 3000aaf0 <pthread_rwlock_timedrdlock+0x94> <== NOT EXECUTED
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
3000aac4: e59f3044 ldr r3, [pc, #68] ; 3000ab10 <pthread_rwlock_timedrdlock+0xb4><== NOT EXECUTED 3000aac8: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000aacc: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000aad0: e3530002 cmp r3, #2 <== NOT EXECUTED 3000aad4: 1a000005 bne 3000aaf0 <pthread_rwlock_timedrdlock+0x94> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000aad8: e3540000 cmp r4, #0 <== NOT EXECUTED 3000aadc: 0a000008 beq 3000ab04 <pthread_rwlock_timedrdlock+0xa8> <== NOT EXECUTED
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000aae0: e2444001 sub r4, r4, #1 <== NOT EXECUTED 3000aae4: e3540001 cmp r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
3000aae8: 93a00074 movls r0, #116 ; 0x74 <== NOT EXECUTED
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000aaec: 9a000005 bls 3000ab08 <pthread_rwlock_timedrdlock+0xac> <== NOT EXECUTED
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000aaf0: e59f3018 ldr r3, [pc, #24] ; 3000ab10 <pthread_rwlock_timedrdlock+0xb4><== NOT EXECUTED 3000aaf4: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000aaf8: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000aafc: eb000032 bl 3000abcc <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000ab00: ea000000 b 3000ab08 <pthread_rwlock_timedrdlock+0xac> <== NOT EXECUTED
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
3000ab04: e3a00016 mov r0, #22 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000ab08: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
3000ab14 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000ab14: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000ab18: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000ab1c: 0a000026 beq 3000abbc <pthread_rwlock_timedwrlock+0xa8> <== NOT EXECUTED
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000ab20: e1a00001 mov r0, r1 <== NOT EXECUTED 3000ab24: e28d1004 add r1, sp, #4 <== NOT EXECUTED 3000ab28: eb001855 bl 30010c84 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 3000ab2c: e5961000 ldr r1, [r6] <== NOT EXECUTED 3000ab30: e1a04000 mov r4, r0 <== NOT EXECUTED 3000ab34: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000ab38: e59f0084 ldr r0, [pc, #132] ; 3000abc4 <pthread_rwlock_timedwrlock+0xb0><== NOT EXECUTED 3000ab3c: eb0009df bl 3000d2c0 <_Objects_Get> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000ab40: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3000ab44: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ab48: 1a00001b bne 3000abbc <pthread_rwlock_timedwrlock+0xa8> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000ab4c: e58d3000 str r3, [sp] <== NOT EXECUTED
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
3000ab50: e3540003 cmp r4, #3 <== NOT EXECUTED 3000ab54: 13a05000 movne r5, #0 <== NOT EXECUTED 3000ab58: 03a05001 moveq r5, #1 <== NOT EXECUTED 3000ab5c: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000ab60: e5961000 ldr r1, [r6] <== NOT EXECUTED 3000ab64: e1a02005 mov r2, r5 <== NOT EXECUTED 3000ab68: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3000ab6c: eb0006d4 bl 3000c6c4 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
3000ab70: eb000cd6 bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !do_wait &&
3000ab74: e3550000 cmp r5, #0 <== NOT EXECUTED 3000ab78: 1a00000a bne 3000aba8 <pthread_rwlock_timedwrlock+0x94> <== NOT EXECUTED
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
3000ab7c: e59f3044 ldr r3, [pc, #68] ; 3000abc8 <pthread_rwlock_timedwrlock+0xb4><== NOT EXECUTED 3000ab80: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
3000ab84: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000ab88: e3530002 cmp r3, #2 <== NOT EXECUTED 3000ab8c: 1a000005 bne 3000aba8 <pthread_rwlock_timedwrlock+0x94> <== NOT EXECUTED
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000ab90: e3540000 cmp r4, #0 <== NOT EXECUTED 3000ab94: 0a000008 beq 3000abbc <pthread_rwlock_timedwrlock+0xa8> <== NOT EXECUTED
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000ab98: e2444001 sub r4, r4, #1 <== NOT EXECUTED 3000ab9c: e3540001 cmp r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
3000aba0: 93a00074 movls r0, #116 ; 0x74 <== NOT EXECUTED
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000aba4: 9a000005 bls 3000abc0 <pthread_rwlock_timedwrlock+0xac> <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000aba8: e59f3018 ldr r3, [pc, #24] ; 3000abc8 <pthread_rwlock_timedwrlock+0xb4><== NOT EXECUTED 3000abac: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000abb0: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000abb4: eb000004 bl 3000abcc <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000abb8: ea000000 b 3000abc0 <pthread_rwlock_timedwrlock+0xac> <== NOT EXECUTED
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
3000abbc: e3a00016 mov r0, #22 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000abc0: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
3000abdc <pthread_rwlock_tryrdlock>:
*/
int pthread_rwlock_tryrdlock(
pthread_rwlock_t *rwlock
)
{
3000abdc: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000abe0: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000abe4: 0a000011 beq 3000ac30 <pthread_rwlock_tryrdlock+0x54> <== NOT EXECUTED 3000abe8: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000abec: e59f0044 ldr r0, [pc, #68] ; 3000ac38 <pthread_rwlock_tryrdlock+0x5c><== NOT EXECUTED 3000abf0: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000abf4: eb0009b1 bl 3000d2c0 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000abf8: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 3000abfc: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ac00: 1a00000a bne 3000ac30 <pthread_rwlock_tryrdlock+0x54> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000ac04: e58d2000 str r2, [sp] <== NOT EXECUTED 3000ac08: e1a03002 mov r3, r2 <== NOT EXECUTED 3000ac0c: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000ac10: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000ac14: eb000676 bl 3000c5f4 <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED
0,
NULL
);
_Thread_Enable_dispatch();
3000ac18: eb000cac bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000ac1c: e59f3018 ldr r3, [pc, #24] ; 3000ac3c <pthread_rwlock_tryrdlock+0x60><== NOT EXECUTED 3000ac20: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000ac24: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000ac28: ebffffe7 bl 3000abcc <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000ac2c: ea000000 b 3000ac34 <pthread_rwlock_tryrdlock+0x58> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000ac30: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000ac34: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED
3000ac40 <pthread_rwlock_trywrlock>:
*/
int pthread_rwlock_trywrlock(
pthread_rwlock_t *rwlock
)
{
3000ac40: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000ac44: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000ac48: 0a000011 beq 3000ac94 <pthread_rwlock_trywrlock+0x54> <== NOT EXECUTED 3000ac4c: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000ac50: e59f0044 ldr r0, [pc, #68] ; 3000ac9c <pthread_rwlock_trywrlock+0x5c><== NOT EXECUTED 3000ac54: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000ac58: eb000998 bl 3000d2c0 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000ac5c: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 3000ac60: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ac64: 1a00000a bne 3000ac94 <pthread_rwlock_trywrlock+0x54> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000ac68: e58d2000 str r2, [sp] <== NOT EXECUTED 3000ac6c: e1a03002 mov r3, r2 <== NOT EXECUTED 3000ac70: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000ac74: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000ac78: eb000691 bl 3000c6c4 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED
false, /* we are not willing to wait */
0,
NULL
);
_Thread_Enable_dispatch();
3000ac7c: eb000c93 bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000ac80: e59f3018 ldr r3, [pc, #24] ; 3000aca0 <pthread_rwlock_trywrlock+0x60><== NOT EXECUTED 3000ac84: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000ac88: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000ac8c: ebffffce bl 3000abcc <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000ac90: ea000000 b 3000ac98 <pthread_rwlock_trywrlock+0x58> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000ac94: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000ac98: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED
3000aca4 <pthread_rwlock_unlock>:
{
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
CORE_RWLock_Status status;
if ( !rwlock )
3000aca4: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_rwlock_unlock(
pthread_rwlock_t *rwlock
)
{
3000aca8: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
CORE_RWLock_Status status;
if ( !rwlock )
3000acac: 0a00000d beq 3000ace8 <pthread_rwlock_unlock+0x44> <== NOT EXECUTED 3000acb0: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000acb4: e59f0034 ldr r0, [pc, #52] ; 3000acf0 <pthread_rwlock_unlock+0x4c><== NOT EXECUTED 3000acb8: e1a0200d mov r2, sp <== NOT EXECUTED 3000acbc: eb00097f bl 3000d2c0 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000acc0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000acc4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000acc8: 1a000006 bne 3000ace8 <pthread_rwlock_unlock+0x44> <== NOT EXECUTED
case OBJECTS_LOCAL:
status = _CORE_RWLock_Release( &the_rwlock->RWLock );
3000accc: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000acd0: eb00069e bl 3000c750 <_CORE_RWLock_Release> <== NOT EXECUTED 3000acd4: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000acd8: eb000c7c bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_RWLock_Translate_core_RWLock_return_code( status );
3000acdc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ace0: ebffffb9 bl 3000abcc <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000ace4: ea000000 b 3000acec <pthread_rwlock_unlock+0x48> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000ace8: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000acec: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000acf4 <pthread_rwlock_wrlock>:
*/
int pthread_rwlock_wrlock(
pthread_rwlock_t *rwlock
)
{
3000acf4: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000acf8: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000acfc: 0a000011 beq 3000ad48 <pthread_rwlock_wrlock+0x54> <== NOT EXECUTED 3000ad00: e59f0048 ldr r0, [pc, #72] ; 3000ad50 <pthread_rwlock_wrlock+0x5c><== NOT EXECUTED 3000ad04: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000ad08: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000ad0c: eb00096b bl 3000d2c0 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000ad10: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3000ad14: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ad18: 1a00000a bne 3000ad48 <pthread_rwlock_wrlock+0x54> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000ad1c: e58d3000 str r3, [sp] <== NOT EXECUTED 3000ad20: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000ad24: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000ad28: e3a02001 mov r2, #1 <== NOT EXECUTED 3000ad2c: eb000664 bl 3000c6c4 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED
true, /* do not timeout -- wait forever */
0,
NULL
);
_Thread_Enable_dispatch();
3000ad30: eb000c66 bl 3000ded0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000ad34: e59f3018 ldr r3, [pc, #24] ; 3000ad54 <pthread_rwlock_wrlock+0x60><== NOT EXECUTED 3000ad38: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000ad3c: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000ad40: ebffffa1 bl 3000abcc <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000ad44: ea000000 b 3000ad4c <pthread_rwlock_wrlock+0x58> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000ad48: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000ad4c: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED
3000b26c <pthread_rwlockattr_destroy>:
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000b26c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000b270: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000b274: 012fff1e bxeq lr <== NOT EXECUTED 3000b278: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b27c: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000b280: 13a00000 movne r0, #0 <== NOT EXECUTED 3000b284: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000b288: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000b28c: e12fff1e bx lr <== NOT EXECUTED
3000b290 <pthread_rwlockattr_getpshared>:
int pthread_rwlockattr_getpshared(
const pthread_rwlockattr_t *attr,
int *pshared
)
{
if ( !attr )
3000b290: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000b294: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_rwlockattr_getpshared(
const pthread_rwlockattr_t *attr,
int *pshared
)
{
if ( !attr )
3000b298: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000b29c: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000b2a0: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000b2a4: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000b2a8: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
3000b2ac: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0;
3000b2b0: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000b2b4: e12fff1e bx lr <== NOT EXECUTED
3000b2b8 <pthread_rwlockattr_init>:
int pthread_rwlockattr_init(
pthread_rwlockattr_t *attr
)
{
if ( !attr )
3000b2b8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = true;
3000b2bc: 13a02001 movne r2, #1 <== NOT EXECUTED
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
3000b2c0: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr )
return EINVAL;
attr->is_initialized = true;
3000b2c4: 15832000 strne r2, [r3] <== NOT EXECUTED
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
3000b2c8: 15830004 strne r0, [r3, #4] <== NOT EXECUTED
int pthread_rwlockattr_init(
pthread_rwlockattr_t *attr
)
{
if ( !attr )
return EINVAL;
3000b2cc: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = true;
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
return 0;
}
3000b2d0: e12fff1e bx lr <== NOT EXECUTED
3000b2d4 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
3000b2d4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b2d8: 0a000007 beq 3000b2fc <pthread_rwlockattr_setpshared+0x28> <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000b2dc: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000b2e0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b2e4: 0a000004 beq 3000b2fc <pthread_rwlockattr_setpshared+0x28> <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000b2e8: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000b2ec: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000b2f0: 93a00000 movls r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000b2f4: 912fff1e bxls lr <== NOT EXECUTED 3000b2f8: ea000001 b 3000b304 <pthread_rwlockattr_setpshared+0x30> <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000b2fc: e3a00016 mov r0, #22 <== NOT EXECUTED 3000b300: e12fff1e bx lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000b304: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000b308: e12fff1e bx lr <== NOT EXECUTED
30025c5c <pthread_self>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
pthread_t pthread_self( void )
{
return _Thread_Executing->Object.id;
30025c5c: e59f3008 ldr r3, [pc, #8] ; 30025c6c <pthread_self+0x10> <== NOT EXECUTED 30025c60: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
}
30025c64: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 30025c68: e12fff1e bx lr <== NOT EXECUTED
30009144 <pthread_setcancelstate>:
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
30009144: e59f3060 ldr r3, [pc, #96] ; 300091ac <pthread_setcancelstate+0x68><== NOT EXECUTED
int pthread_setcancelstate(
int state,
int *oldstate
)
{
30009148: e92d4010 push {r4, lr} <== NOT EXECUTED
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
3000914c: e5934000 ldr r4, [r3] <== NOT EXECUTED 30009150: e3540000 cmp r4, #0 <== NOT EXECUTED
return EPROTO;
30009154: 13a00047 movne r0, #71 ; 0x47 <== NOT EXECUTED
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
30009158: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return EPROTO;
if ( !oldstate )
3000915c: e3510000 cmp r1, #0 <== NOT EXECUTED
return EINVAL;
30009160: 03a00016 moveq r0, #22 <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
if ( !oldstate )
30009164: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
30009168: e3500001 cmp r0, #1 <== NOT EXECUTED 3000916c: 8a00000c bhi 300091a4 <pthread_setcancelstate+0x60> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009170: e59fc038 ldr ip, [pc, #56] ; 300091b0 <pthread_setcancelstate+0x6c><== NOT EXECUTED
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30009174: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 30009178: e59ce000 ldr lr, [ip] <== NOT EXECUTED 3000917c: e59220fc ldr r2, [r2, #252] ; 0xfc <== NOT EXECUTED 30009180: e28ee001 add lr, lr, #1 <== NOT EXECUTED 30009184: e58ce000 str lr, [ip] <== NOT EXECUTED
_Thread_Disable_dispatch();
*oldstate = thread_support->cancelability_state;
30009188: e592c0d8 ldr ip, [r2, #216] ; 0xd8 <== NOT EXECUTED 3000918c: e581c000 str ip, [r1] <== NOT EXECUTED
thread_support->cancelability_state = state;
30009190: e58200d8 str r0, [r2, #216] ; 0xd8 <== NOT EXECUTED
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
30009194: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 30009198: eb0014d6 bl 3000e4f8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
3000919c: e1a00004 mov r0, r4 <== NOT EXECUTED
300091a0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( !oldstate )
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
return EINVAL;
300091a4: e3a00016 mov r0, #22 <== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
300091a8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300091b4 <pthread_setcanceltype>:
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
300091b4: e59f3060 ldr r3, [pc, #96] ; 3000921c <pthread_setcanceltype+0x68><== NOT EXECUTED
int pthread_setcanceltype(
int type,
int *oldtype
)
{
300091b8: e92d4010 push {r4, lr} <== NOT EXECUTED
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
300091bc: e5934000 ldr r4, [r3] <== NOT EXECUTED 300091c0: e3540000 cmp r4, #0 <== NOT EXECUTED
return EPROTO;
300091c4: 13a00047 movne r0, #71 ; 0x47 <== NOT EXECUTED
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
300091c8: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return EPROTO;
if ( !oldtype )
300091cc: e3510000 cmp r1, #0 <== NOT EXECUTED
return EINVAL;
300091d0: 03a00016 moveq r0, #22 <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
if ( !oldtype )
300091d4: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
300091d8: e3500001 cmp r0, #1 <== NOT EXECUTED 300091dc: 8a00000c bhi 30009214 <pthread_setcanceltype+0x60> <== NOT EXECUTED 300091e0: e59fc038 ldr ip, [pc, #56] ; 30009220 <pthread_setcanceltype+0x6c><== NOT EXECUTED
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
300091e4: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 300091e8: e59ce000 ldr lr, [ip] <== NOT EXECUTED 300091ec: e59220fc ldr r2, [r2, #252] ; 0xfc <== NOT EXECUTED 300091f0: e28ee001 add lr, lr, #1 <== NOT EXECUTED 300091f4: e58ce000 str lr, [ip] <== NOT EXECUTED
_Thread_Disable_dispatch();
*oldtype = thread_support->cancelability_type;
300091f8: e592c0dc ldr ip, [r2, #220] ; 0xdc <== NOT EXECUTED 300091fc: e581c000 str ip, [r1] <== NOT EXECUTED
thread_support->cancelability_type = type;
30009200: e58200dc str r0, [r2, #220] ; 0xdc <== NOT EXECUTED
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
30009204: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 30009208: eb0014ba bl 3000e4f8 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
3000920c: e1a00004 mov r0, r4 <== NOT EXECUTED
30009210: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( !oldtype )
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
return EINVAL;
30009214: e3a00016 mov r0, #22 <== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
30009218: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c27c <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
3000c27c: e92d41f7 push {r0, r1, r2, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int rc;
/*
* Check all the parameters
*/
if ( !param )
3000c280: e2528000 subs r8, r2, #0 <== NOT EXECUTED
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
3000c284: e1a04000 mov r4, r0 <== NOT EXECUTED 3000c288: e1a06001 mov r6, r1 <== NOT EXECUTED
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
3000c28c: 03a07016 moveq r7, #22 <== NOT EXECUTED
int rc;
/*
* Check all the parameters
*/
if ( !param )
3000c290: 0a000038 beq 3000c378 <pthread_setschedparam+0xfc> <== NOT EXECUTED
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
3000c294: e1a00001 mov r0, r1 <== NOT EXECUTED 3000c298: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000c29c: e1a01008 mov r1, r8 <== NOT EXECUTED 3000c2a0: e28d3004 add r3, sp, #4 <== NOT EXECUTED 3000c2a4: eb0016a8 bl 30011d4c <_POSIX_Thread_Translate_sched_param> <== NOT EXECUTED
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
3000c2a8: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000c2ac: 1a000031 bne 3000c378 <pthread_setschedparam+0xfc> <== NOT EXECUTED
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
3000c2b0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c2b4: e1a0100d mov r1, sp <== NOT EXECUTED 3000c2b8: eb000a90 bl 3000ed00 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000c2bc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
3000c2c0: e1a05000 mov r5, r0 <== NOT EXECUTED
switch ( location ) {
3000c2c4: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000c2c8: 13a07003 movne r7, #3 <== NOT EXECUTED
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000c2cc: 1a000029 bne 3000c378 <pthread_setschedparam+0xfc> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000c2d0: e59040fc ldr r4, [r0, #252] ; 0xfc <== NOT EXECUTED
if ( api->schedpolicy == SCHED_SPORADIC )
3000c2d4: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED 3000c2d8: e3530004 cmp r3, #4 <== NOT EXECUTED
(void) _Watchdog_Remove( &api->Sporadic_timer );
3000c2dc: 028400a8 addeq r0, r4, #168 ; 0xa8 <== NOT EXECUTED 3000c2e0: 0b000eac bleq 3000fd98 <_Watchdog_Remove> <== NOT EXECUTED
api->schedpolicy = policy;
3000c2e4: e5846084 str r6, [r4, #132] ; 0x84 <== NOT EXECUTED
api->schedparam = *param;
3000c2e8: e284c088 add ip, r4, #136 ; 0x88 <== NOT EXECUTED
3000c2ec: e8b8000f ldm r8!, {r0, r1, r2, r3} <== NOT EXECUTED
3000c2f0: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
the_thread->budget_algorithm = budget_algorithm;
3000c2f4: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
3000c2f8: e8980007 ldm r8, {r0, r1, r2} <== NOT EXECUTED
3000c2fc: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
the_thread->budget_algorithm = budget_algorithm;
3000c300: e585307c str r3, [r5, #124] ; 0x7c <== NOT EXECUTED
the_thread->budget_callout = budget_callout;
3000c304: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
switch ( api->schedpolicy ) {
3000c308: e3560000 cmp r6, #0 <== NOT EXECUTED
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
3000c30c: e5853080 str r3, [r5, #128] ; 0x80 <== NOT EXECUTED
switch ( api->schedpolicy ) {
3000c310: ba000017 blt 3000c374 <pthread_setschedparam+0xf8> <== NOT EXECUTED 3000c314: e3560002 cmp r6, #2 <== NOT EXECUTED 3000c318: da000002 ble 3000c328 <pthread_setschedparam+0xac> <== NOT EXECUTED 3000c31c: e3560004 cmp r6, #4 <== NOT EXECUTED 3000c320: 1a000013 bne 3000c374 <pthread_setschedparam+0xf8> <== NOT EXECUTED 3000c324: ea00000b b 3000c358 <pthread_setschedparam+0xdc> <== NOT EXECUTED
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000c328: e59f3050 ldr r3, [pc, #80] ; 3000c380 <pthread_setschedparam+0x104><== NOT EXECUTED
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
3000c32c: e1a00005 mov r0, r5 <== NOT EXECUTED
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000c330: e5933000 ldr r3, [r3] <== NOT EXECUTED
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
3000c334: e3a02001 mov r2, #1 <== NOT EXECUTED
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000c338: e5853078 str r3, [r5, #120] ; 0x78 <== NOT EXECUTED 3000c33c: e59f3040 ldr r3, [pc, #64] ; 3000c384 <pthread_setschedparam+0x108><== NOT EXECUTED 3000c340: e5d31000 ldrb r1, [r3] <== NOT EXECUTED 3000c344: e5943088 ldr r3, [r4, #136] ; 0x88 <== NOT EXECUTED 3000c348: e0631001 rsb r1, r3, r1 <== NOT EXECUTED
the_thread->real_priority =
3000c34c: e5851018 str r1, [r5, #24] <== NOT EXECUTED
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
3000c350: eb00095d bl 3000e8cc <_Thread_Change_priority> <== NOT EXECUTED
the_thread,
the_thread->real_priority,
true
);
break;
3000c354: ea000006 b 3000c374 <pthread_setschedparam+0xf8> <== NOT EXECUTED
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
3000c358: e5943088 ldr r3, [r4, #136] ; 0x88 <== NOT EXECUTED
_Watchdog_Remove( &api->Sporadic_timer );
3000c35c: e28400a8 add r0, r4, #168 ; 0xa8 <== NOT EXECUTED
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
3000c360: e58430a4 str r3, [r4, #164] ; 0xa4 <== NOT EXECUTED
_Watchdog_Remove( &api->Sporadic_timer );
3000c364: eb000e8b bl 3000fd98 <_Watchdog_Remove> <== NOT EXECUTED
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
3000c368: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c36c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000c370: ebffff79 bl 3000c15c <_POSIX_Threads_Sporadic_budget_TSR> <== NOT EXECUTED
break;
}
_Thread_Enable_dispatch();
3000c374: eb000a58 bl 3000ecdc <_Thread_Enable_dispatch> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
3000c378: e1a00007 mov r0, r7 <== NOT EXECUTED
3000c37c: e8bd81fe pop {r1, r2, r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300096e8 <pthread_setspecific>:
int pthread_setspecific(
pthread_key_t key,
const void *value
)
{
300096e8: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
300096ec: e1a03000 mov r3, r0 <== NOT EXECUTED
300096f0: e1a04001 mov r4, r1 <== NOT EXECUTED
300096f4: e59f0048 ldr r0, [pc, #72] ; 30009744 <pthread_setspecific+0x5c><== NOT EXECUTED
300096f8: e1a01003 mov r1, r3 <== NOT EXECUTED
300096fc: e1a0200d mov r2, sp <== NOT EXECUTED
30009700: eb0008df bl 3000ba84 <_Objects_Get> <== NOT EXECUTED
uint32_t api;
uint32_t index;
Objects_Locations location;
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
30009704: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30009708: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000970c: 13a00016 movne r0, #22 <== NOT EXECUTED
uint32_t api;
uint32_t index;
Objects_Locations location;
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
30009710: 1a00000a bne 30009740 <pthread_setspecific+0x58> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = _Objects_Get_API( _Thread_Executing->Object.id );
30009714: e59f302c ldr r3, [pc, #44] ; 30009748 <pthread_setspecific+0x60><== NOT EXECUTED 30009718: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000971c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30009720: e1a02c23 lsr r2, r3, #24 <== NOT EXECUTED 30009724: e2022007 and r2, r2, #7 <== NOT EXECUTED
index = _Objects_Get_index( _Thread_Executing->Object.id );
the_key->Values[ api ][ index ] = (void *) value;
30009728: e2822005 add r2, r2, #5 <== NOT EXECUTED 3000972c: e7902102 ldr r2, [r0, r2, lsl #2] <== NOT EXECUTED
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = _Objects_Get_API( _Thread_Executing->Object.id );
index = _Objects_Get_index( _Thread_Executing->Object.id );
30009730: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED
the_key->Values[ api ][ index ] = (void *) value;
30009734: e7824723 str r4, [r2, r3, lsr #14] <== NOT EXECUTED
_Thread_Enable_dispatch();
30009738: eb000bd5 bl 3000c694 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000973c: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
30009740: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000fc78 <pthread_sigmask>:
sigset_t *oset
)
{
POSIX_API_Control *api;
if ( !set && !oset )
3000fc78: e271c001 rsbs ip, r1, #1 <== NOT EXECUTED 3000fc7c: 33a0c000 movcc ip, #0 <== NOT EXECUTED 3000fc80: e3520000 cmp r2, #0 <== NOT EXECUTED 3000fc84: 03510000 cmpeq r1, #0 <== NOT EXECUTED
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
3000fc88: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set && !oset )
3000fc8c: 0a00001f beq 3000fd10 <pthread_sigmask+0x98> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000fc90: e59f30a0 ldr r3, [pc, #160] ; 3000fd38 <pthread_sigmask+0xc0><== NOT EXECUTED
if ( oset )
3000fc94: e3520000 cmp r2, #0 <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set && !oset )
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000fc98: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000fc9c: e59330fc ldr r3, [r3, #252] ; 0xfc <== NOT EXECUTED
if ( oset )
*oset = api->signals_blocked;
3000fca0: 159340d0 ldrne r4, [r3, #208] ; 0xd0 <== NOT EXECUTED 3000fca4: 15824000 strne r4, [r2] <== NOT EXECUTED
if ( !set )
3000fca8: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000fcac: 1a00001f bne 3000fd30 <pthread_sigmask+0xb8> <== NOT EXECUTED
return 0;
switch ( how ) {
3000fcb0: e3500001 cmp r0, #1 <== NOT EXECUTED 3000fcb4: 0a000005 beq 3000fcd0 <pthread_sigmask+0x58> <== NOT EXECUTED 3000fcb8: e3500002 cmp r0, #2 <== NOT EXECUTED 3000fcbc: 0a000007 beq 3000fce0 <pthread_sigmask+0x68> <== NOT EXECUTED 3000fcc0: e3500000 cmp r0, #0 <== NOT EXECUTED
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
break;
case SIG_SETMASK:
api->signals_blocked = *set;
3000fcc4: 05912000 ldreq r2, [r1] <== NOT EXECUTED
*oset = api->signals_blocked;
if ( !set )
return 0;
switch ( how ) {
3000fcc8: 0a000007 beq 3000fcec <pthread_sigmask+0x74> <== NOT EXECUTED 3000fccc: ea00000f b 3000fd10 <pthread_sigmask+0x98> <== NOT EXECUTED
case SIG_BLOCK:
api->signals_blocked |= *set;
3000fcd0: e59300d0 ldr r0, [r3, #208] ; 0xd0 <== NOT EXECUTED 3000fcd4: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000fcd8: e1802002 orr r2, r0, r2 <== NOT EXECUTED 3000fcdc: ea000002 b 3000fcec <pthread_sigmask+0x74> <== NOT EXECUTED
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
3000fce0: e5911000 ldr r1, [r1] <== NOT EXECUTED 3000fce4: e59320d0 ldr r2, [r3, #208] ; 0xd0 <== NOT EXECUTED 3000fce8: e1c22001 bic r2, r2, r1 <== NOT EXECUTED
break;
case SIG_SETMASK:
api->signals_blocked = *set;
3000fcec: e58320d0 str r2, [r3, #208] ; 0xd0 <== NOT EXECUTED
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
3000fcf0: e59f2044 ldr r2, [pc, #68] ; 3000fd3c <pthread_sigmask+0xc4><== NOT EXECUTED 3000fcf4: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000fcf8: e59320d4 ldr r2, [r3, #212] ; 0xd4 <== NOT EXECUTED
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
3000fcfc: e59330d0 ldr r3, [r3, #208] ; 0xd0 <== NOT EXECUTED
(api->signals_pending | _POSIX_signals_Pending) ) {
3000fd00: e1800002 orr r0, r0, r2 <== NOT EXECUTED
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
3000fd04: e1d00003 bics r0, r0, r3 <== NOT EXECUTED
3000fd08: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
3000fd0c: ea000004 b 3000fd24 <pthread_sigmask+0xac> <== NOT EXECUTED
break;
case SIG_SETMASK:
api->signals_blocked = *set;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000fd10: eb000965 bl 300122ac <__errno> <== NOT EXECUTED
3000fd14: e3a03016 mov r3, #22 <== NOT EXECUTED
3000fd18: e5803000 str r3, [r0] <== NOT EXECUTED
3000fd1c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000fd20: e8bd8010 pop {r4, pc} <== NOT EXECUTED
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
3000fd24: ebfff278 bl 3000c70c <_Thread_Dispatch> <== NOT EXECUTED
}
return 0;
3000fd28: e3a00000 mov r0, #0 <== NOT EXECUTED
3000fd2c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( oset )
*oset = api->signals_blocked;
if ( !set )
return 0;
3000fd30: e3a00000 mov r0, #0 <== NOT EXECUTED
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
3000fd34: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30009794 <pthread_spin_destroy>:
)
{
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
if ( !spinlock )
30009794: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_destroy(
pthread_spinlock_t *spinlock
)
{
30009798: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
if ( !spinlock )
3000979c: 0a000016 beq 300097fc <pthread_spin_destroy+0x68> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get (
pthread_spinlock_t *spinlock,
Objects_Locations *location
)
{
return (POSIX_Spinlock_Control *) _Objects_Get(
300097a0: e5931000 ldr r1, [r3] <== NOT EXECUTED 300097a4: e59f0058 ldr r0, [pc, #88] ; 30009804 <pthread_spin_destroy+0x70><== NOT EXECUTED 300097a8: e1a0200d mov r2, sp <== NOT EXECUTED 300097ac: eb000814 bl 3000b804 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
300097b0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300097b4: e1a04000 mov r4, r0 <== NOT EXECUTED 300097b8: e3530000 cmp r3, #0 <== NOT EXECUTED 300097bc: 1a00000e bne 300097fc <pthread_spin_destroy+0x68> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _CORE_spinlock_Is_busy(
CORE_spinlock_Control *the_spinlock
)
{
return (the_spinlock->users != 0);
300097c0: e5905018 ldr r5, [r0, #24] <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) {
300097c4: e3550000 cmp r5, #0 <== NOT EXECUTED 300097c8: 0a000002 beq 300097d8 <pthread_spin_destroy+0x44> <== NOT EXECUTED
_Thread_Enable_dispatch();
300097cc: eb000b10 bl 3000c414 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
300097d0: e3a00010 mov r0, #16 <== NOT EXECUTED 300097d4: ea000009 b 30009800 <pthread_spin_destroy+0x6c> <== NOT EXECUTED
}
_Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object );
300097d8: e59f0024 ldr r0, [pc, #36] ; 30009804 <pthread_spin_destroy+0x70><== NOT EXECUTED 300097dc: e1a01004 mov r1, r4 <== NOT EXECUTED 300097e0: eb00070d bl 3000b41c <_Objects_Close> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _POSIX_Spinlock_Free (
POSIX_Spinlock_Control *the_spinlock
)
{
_Objects_Free( &_POSIX_Spinlock_Information, &the_spinlock->Object );
300097e4: e59f0018 ldr r0, [pc, #24] ; 30009804 <pthread_spin_destroy+0x70><== NOT EXECUTED 300097e8: e1a01004 mov r1, r4 <== NOT EXECUTED 300097ec: eb0007af bl 3000b6b0 <_Objects_Free> <== NOT EXECUTED
_POSIX_Spinlock_Free( the_spinlock );
_Thread_Enable_dispatch();
300097f0: eb000b07 bl 3000c414 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
300097f4: e1a00005 mov r0, r5 <== NOT EXECUTED 300097f8: ea000000 b 30009800 <pthread_spin_destroy+0x6c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
300097fc: e3a00016 mov r0, #22 <== NOT EXECUTED
}
30009800: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30009808 <pthread_spin_init>:
int pthread_spin_init(
pthread_spinlock_t *spinlock,
int pshared
)
{
30009808: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock;
CORE_spinlock_Attributes attributes;
if ( !spinlock )
3000980c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
int pthread_spin_init(
pthread_spinlock_t *spinlock,
int pshared
)
{
30009810: e1a05001 mov r5, r1 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock;
CORE_spinlock_Attributes attributes;
if ( !spinlock )
30009814: 0a00001b beq 30009888 <pthread_spin_init+0x80> <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
30009818: e3510000 cmp r1, #0 <== NOT EXECUTED 3000981c: 1a000019 bne 30009888 <pthread_spin_init+0x80> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009820: e59f3068 ldr r3, [pc, #104] ; 30009890 <pthread_spin_init+0x88><== NOT EXECUTED 30009824: e5932000 ldr r2, [r3] <== NOT EXECUTED 30009828: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000982c: e5832000 str r2, [r3] <== NOT EXECUTED
* the inactive chain of free spinlock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Allocate( void )
{
return (POSIX_Spinlock_Control *)
_Objects_Allocate( &_POSIX_Spinlock_Information );
30009830: e59f605c ldr r6, [pc, #92] ; 30009894 <pthread_spin_init+0x8c><== NOT EXECUTED 30009834: e1a00006 mov r0, r6 <== NOT EXECUTED 30009838: eb0006d5 bl 3000b394 <_Objects_Allocate> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_spinlock = _POSIX_Spinlock_Allocate();
if ( !the_spinlock ) {
3000983c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30009840: 1a000002 bne 30009850 <pthread_spin_init+0x48> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009844: eb000af2 bl 3000c414 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
30009848: e3a0000b mov r0, #11 <== NOT EXECUTED 3000984c: ea00000e b 3000988c <pthread_spin_init+0x84> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _CORE_spinlock_Initialize_attributes(
CORE_spinlock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
30009850: e28d1004 add r1, sp, #4 <== NOT EXECUTED
}
_CORE_spinlock_Initialize_attributes( &attributes );
_CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes );
30009854: e2840010 add r0, r4, #16 <== NOT EXECUTED 30009858: e5215004 str r5, [r1, #-4]! <== NOT EXECUTED 3000985c: e1a0100d mov r1, sp <== NOT EXECUTED 30009860: eb000520 bl 3000ace8 <_CORE_spinlock_Initialize> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009864: e596201c ldr r2, [r6, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
30009868: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000986c: e1d410b8 ldrh r1, [r4, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009870: e7824101 str r4, [r2, r1, lsl #2] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
30009874: e584500c str r5, [r4, #12] <== NOT EXECUTED
_Objects_Open_u32( &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 );
*spinlock = the_spinlock->Object.id;
30009878: e5873000 str r3, [r7] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000987c: eb000ae4 bl 3000c414 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009880: e1a00005 mov r0, r5 <== NOT EXECUTED 30009884: ea000000 b 3000988c <pthread_spin_init+0x84> <== NOT EXECUTED
switch ( pshared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
30009888: e3a00016 mov r0, #22 <== NOT EXECUTED
*spinlock = the_spinlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000988c: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
30009898 <pthread_spin_lock>:
{
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
30009898: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_lock(
pthread_spinlock_t *spinlock
)
{
3000989c: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
300098a0: 0a00000e beq 300098e0 <pthread_spin_lock+0x48> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get (
pthread_spinlock_t *spinlock,
Objects_Locations *location
)
{
return (POSIX_Spinlock_Control *) _Objects_Get(
300098a4: e1a0200d mov r2, sp <== NOT EXECUTED 300098a8: e59f0038 ldr r0, [pc, #56] ; 300098e8 <pthread_spin_lock+0x50><== NOT EXECUTED 300098ac: e5931000 ldr r1, [r3] <== NOT EXECUTED 300098b0: eb0007d3 bl 3000b804 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
300098b4: e59d2000 ldr r2, [sp] <== NOT EXECUTED 300098b8: e3520000 cmp r2, #0 <== NOT EXECUTED 300098bc: 1a000007 bne 300098e0 <pthread_spin_lock+0x48> <== NOT EXECUTED
case OBJECTS_LOCAL:
status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, true, 0 );
300098c0: e3a01001 mov r1, #1 <== NOT EXECUTED 300098c4: e2800010 add r0, r0, #16 <== NOT EXECUTED 300098c8: eb000529 bl 3000ad74 <_CORE_spinlock_Wait> <== NOT EXECUTED 300098cc: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
300098d0: eb000acf bl 3000c414 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
300098d4: e1a00004 mov r0, r4 <== NOT EXECUTED 300098d8: eb000003 bl 300098ec <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 300098dc: ea000000 b 300098e4 <pthread_spin_lock+0x4c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
300098e0: e3a00016 mov r0, #22 <== NOT EXECUTED
}
300098e4: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
300098fc <pthread_spin_trylock>:
{
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
300098fc: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_trylock(
pthread_spinlock_t *spinlock
)
{
30009900: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
30009904: 0a00000e beq 30009944 <pthread_spin_trylock+0x48> <== NOT EXECUTED 30009908: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000990c: e59f0038 ldr r0, [pc, #56] ; 3000994c <pthread_spin_trylock+0x50><== NOT EXECUTED 30009910: e1a0200d mov r2, sp <== NOT EXECUTED 30009914: eb0007ba bl 3000b804 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
30009918: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000991c: e3510000 cmp r1, #0 <== NOT EXECUTED 30009920: 1a000007 bne 30009944 <pthread_spin_trylock+0x48> <== NOT EXECUTED
case OBJECTS_LOCAL:
status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, false, 0 );
30009924: e1a02001 mov r2, r1 <== NOT EXECUTED 30009928: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000992c: eb000510 bl 3000ad74 <_CORE_spinlock_Wait> <== NOT EXECUTED 30009930: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
30009934: eb000ab6 bl 3000c414 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
30009938: e1a00004 mov r0, r4 <== NOT EXECUTED 3000993c: ebffffea bl 300098ec <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 30009940: ea000000 b 30009948 <pthread_spin_trylock+0x4c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
30009944: e3a00016 mov r0, #22 <== NOT EXECUTED
}
30009948: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
30009950 <pthread_spin_unlock>:
{
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
30009950: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_unlock(
pthread_spinlock_t *spinlock
)
{
30009954: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
30009958: 0a00000d beq 30009994 <pthread_spin_unlock+0x44> <== NOT EXECUTED 3000995c: e5931000 ldr r1, [r3] <== NOT EXECUTED 30009960: e59f0034 ldr r0, [pc, #52] ; 3000999c <pthread_spin_unlock+0x4c><== NOT EXECUTED 30009964: e1a0200d mov r2, sp <== NOT EXECUTED 30009968: eb0007a5 bl 3000b804 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000996c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30009970: e3530000 cmp r3, #0 <== NOT EXECUTED 30009974: 1a000006 bne 30009994 <pthread_spin_unlock+0x44> <== NOT EXECUTED
case OBJECTS_LOCAL:
status = _CORE_spinlock_Release( &the_spinlock->Spinlock );
30009978: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000997c: eb0004e0 bl 3000ad04 <_CORE_spinlock_Release> <== NOT EXECUTED 30009980: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
30009984: eb000aa2 bl 3000c414 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
30009988: e1a00004 mov r0, r4 <== NOT EXECUTED 3000998c: ebffffd6 bl 300098ec <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 30009990: ea000000 b 30009998 <pthread_spin_unlock+0x48> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
30009994: e3a00016 mov r0, #22 <== NOT EXECUTED
}
30009998: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
30009a98 <pthread_testcancel>:
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
30009a98: e59f305c ldr r3, [pc, #92] ; 30009afc <pthread_testcancel+0x64><== NOT EXECUTED
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
30009a9c: e92d4010 push {r4, lr} <== NOT EXECUTED
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
30009aa0: e5934000 ldr r4, [r3] <== NOT EXECUTED
30009aa4: e3540000 cmp r4, #0 <== NOT EXECUTED
30009aa8: 18bd8010 popne {r4, pc} <== NOT EXECUTED
30009aac: e59f204c ldr r2, [pc, #76] ; 30009b00 <pthread_testcancel+0x68><== NOT EXECUTED
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30009ab0: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30009ab4: e5921000 ldr r1, [r2] <== NOT EXECUTED 30009ab8: e59330fc ldr r3, [r3, #252] ; 0xfc <== NOT EXECUTED 30009abc: e2811001 add r1, r1, #1 <== NOT EXECUTED 30009ac0: e5821000 str r1, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
30009ac4: e59320d8 ldr r2, [r3, #216] ; 0xd8 <== NOT EXECUTED 30009ac8: e3520000 cmp r2, #0 <== NOT EXECUTED 30009acc: 1a000002 bne 30009adc <pthread_testcancel+0x44> <== NOT EXECUTED
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
30009ad0: e59340e0 ldr r4, [r3, #224] ; 0xe0 <== NOT EXECUTED 30009ad4: e2544000 subs r4, r4, #0 <== NOT EXECUTED 30009ad8: 13a04001 movne r4, #1 <== NOT EXECUTED
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
30009adc: eb000a2d bl 3000c398 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( cancel )
30009ae0: e3540000 cmp r4, #0 <== NOT EXECUTED
30009ae4: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
30009ae8: e59f300c ldr r3, [pc, #12] ; 30009afc <pthread_testcancel+0x64><== NOT EXECUTED 30009aec: e3e01000 mvn r1, #0 <== NOT EXECUTED 30009af0: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
}
30009af4: e8bd4010 pop {r4, lr} <== NOT EXECUTED
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
30009af8: ea001684 b 3000f510 <_POSIX_Thread_Exit> <== NOT EXECUTED
30016a10 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
30016a10: e92d4030 push {r4, r5, lr}
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30016a14: e59f4098 ldr r4, [pc, #152] ; 30016ab4 <read+0xa4> 30016a18: e5944000 ldr r4, [r4] 30016a1c: e1500004 cmp r0, r4
30016a20: 2a000006 bcs 30016a40 <read+0x30> iop = rtems_libio_iop( fd );
30016a24: e59f408c ldr r4, [pc, #140] ; 30016ab8 <read+0xa8> 30016a28: e3a05038 mov r5, #56 ; 0x38 30016a2c: e5944000 ldr r4, [r4] 30016a30: e0244095 mla r4, r5, r0, r4
rtems_libio_check_is_open( iop );
30016a34: e5940014 ldr r0, [r4, #20] 30016a38: e3100c01 tst r0, #256 ; 0x100
30016a3c: 1a000002 bne 30016a4c <read+0x3c>
30016a40: ebffe99f bl 300110c4 <__errno> <== NOT EXECUTED 30016a44: e3a03009 mov r3, #9 <== NOT EXECUTED 30016a48: ea000003 b 30016a5c <read+0x4c> <== NOT EXECUTED
rtems_libio_check_buffer( buffer );
30016a4c: e3510000 cmp r1, #0
30016a50: 1a000004 bne 30016a68 <read+0x58>
30016a54: ebffe99a bl 300110c4 <__errno> <== NOT EXECUTED
30016a58: e3a03016 mov r3, #22 <== NOT EXECUTED
30016a5c: e5803000 str r3, [r0] <== NOT EXECUTED
30016a60: e3e00000 mvn r0, #0 <== NOT EXECUTED
30016a64: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
rtems_libio_check_count( count );
30016a68: e3520000 cmp r2, #0
30016a6c: 0a00000e beq 30016aac <read+0x9c> rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30016a70: e3100002 tst r0, #2
30016a74: 0afffff6 beq 30016a54 <read+0x44>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
30016a78: e5943020 ldr r3, [r4, #32] 30016a7c: e1a00004 mov r0, r4 30016a80: e1a0e00f mov lr, pc 30016a84: e593f008 ldr pc, [r3, #8]
if ( rc > 0 )
30016a88: e3500000 cmp r0, #0
30016a8c: d8bd8030 pople {r4, r5, pc}
iop->offset += rc;
30016a90: e284300c add r3, r4, #12
30016a94: e893000c ldm r3, {r2, r3}
30016a98: e0922000 adds r2, r2, r0
30016a9c: e0a33fc0 adc r3, r3, r0, asr #31
30016aa0: e584200c str r2, [r4, #12]
30016aa4: e5843010 str r3, [r4, #16]
30016aa8: 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 );
30016aac: e1a00002 mov r0, r2 <== NOT EXECUTED
if ( rc > 0 )
iop->offset += rc;
return rc;
}
30016ab0: 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: eb002a52 bl 30014040 <__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: eb0031c5 bl 30015e18 <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: eb002a3d bl 30014040 <__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: eb0027bb bl 30012058 <__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: eb0027a2 bl 30012058 <__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
30016b20 <realloc>:
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30016b20: e59f310c ldr r3, [pc, #268] ; 30016c34 <realloc+0x114>
void *realloc(
void *ptr,
size_t size
)
{
30016b24: e92d40f1 push {r0, r4, r5, r6, r7, lr}
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30016b28: e5932010 ldr r2, [r3, #16]
void *realloc(
void *ptr,
size_t size
)
{
30016b2c: e1a04000 mov r4, r0
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30016b30: e2822001 add r2, r2, #1 30016b34: 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())) {
30016b38: e59f30f8 ldr r3, [pc, #248] ; 30016c38 <realloc+0x118>
void *realloc(
void *ptr,
size_t size
)
{
30016b3c: 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())) {
30016b40: e5933000 ldr r3, [r3] 30016b44: e3530003 cmp r3, #3
30016b48: 1a000009 bne 30016b74 <realloc+0x54>
if (_Thread_Dispatch_disable_level > 0)
30016b4c: e59f30e8 ldr r3, [pc, #232] ; 30016c3c <realloc+0x11c> 30016b50: e5933000 ldr r3, [r3] 30016b54: e3530000 cmp r3, #0
return (void *) 0;
30016b58: 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)
30016b5c: 1a000032 bne 30016c2c <realloc+0x10c>
return (void *) 0;
if (_ISR_Nest_level > 0)
30016b60: e59f20d8 ldr r2, [pc, #216] ; 30016c40 <realloc+0x120> 30016b64: e5922000 ldr r2, [r2] 30016b68: e3520000 cmp r2, #0
return (void *) 0;
30016b6c: 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)
30016b70: 1a00002d bne 30016c2c <realloc+0x10c>
}
/*
* Continue with realloc().
*/
if ( !ptr )
30016b74: e3540000 cmp r4, #0
30016b78: 1a000003 bne 30016b8c <realloc+0x6c>
return malloc( size );
30016b7c: e1a00005 mov r0, r5 30016b80: ebffbe96 bl 300065e0 <malloc> 30016b84: e1a04000 mov r4, r0 30016b88: ea000027 b 30016c2c <realloc+0x10c>
if ( !size ) {
30016b8c: e3550000 cmp r5, #0
30016b90: 1a000003 bne 30016ba4 <realloc+0x84>
free( ptr );
30016b94: e1a00004 mov r0, r4 <== NOT EXECUTED 30016b98: ebffbdc1 bl 300062a4 <free> <== NOT EXECUTED
return (void *) 0;
30016b9c: e1a04005 mov r4, r5 <== NOT EXECUTED 30016ba0: ea000021 b 30016c2c <realloc+0x10c> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
30016ba4: e59f6098 ldr r6, [pc, #152] ; 30016c44 <realloc+0x124> 30016ba8: e1a01004 mov r1, r4 30016bac: e5960000 ldr r0, [r6] 30016bb0: e1a0200d mov r2, sp 30016bb4: eb00004e bl 30016cf4 <_Protected_heap_Get_block_size> 30016bb8: e2507000 subs r7, r0, #0
30016bbc: 1a000004 bne 30016bd4 <realloc+0xb4>
errno = EINVAL;
30016bc0: ebffe93f bl 300110c4 <__errno> <== NOT EXECUTED 30016bc4: e3a03016 mov r3, #22 <== NOT EXECUTED 30016bc8: e5803000 str r3, [r0] <== NOT EXECUTED
return (void *) 0;
30016bcc: e1a04007 mov r4, r7 <== NOT EXECUTED 30016bd0: ea000015 b 30016c2c <realloc+0x10c> <== NOT EXECUTED
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
30016bd4: e5960000 ldr r0, [r6] 30016bd8: e1a01004 mov r1, r4 30016bdc: e1a02005 mov r2, r5 30016be0: eb000054 bl 30016d38 <_Protected_heap_Resize_block> 30016be4: e3500000 cmp r0, #0
30016be8: 1a00000f bne 30016c2c <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 );
30016bec: e1a00005 mov r0, r5 30016bf0: ebffbe7a bl 300065e0 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
30016bf4: e59f3038 ldr r3, [pc, #56] ; 30016c34 <realloc+0x114>
if ( !new_area ) {
30016bf8: e2506000 subs r6, r0, #0
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
30016bfc: e5932004 ldr r2, [r3, #4] 30016c00: e2422001 sub r2, r2, #1 30016c04: e5832004 str r2, [r3, #4]
if ( !new_area ) {
30016c08: 0a000006 beq 30016c28 <realloc+0x108>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
30016c0c: e59d2000 ldr r2, [sp] <== NOT EXECUTED 30016c10: e1a01004 mov r1, r4 <== NOT EXECUTED 30016c14: e1550002 cmp r5, r2 <== NOT EXECUTED 30016c18: 31a02005 movcc r2, r5 <== NOT EXECUTED 30016c1c: ebffeb56 bl 3001197c <memcpy> <== NOT EXECUTED
free( ptr );
30016c20: e1a00004 mov r0, r4 <== NOT EXECUTED 30016c24: ebffbd9e 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;
30016c28: e1a04006 mov r4, r6
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
30016c2c: e1a00004 mov r0, r4
30016c30: 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: eb002c99 bl 3001279c <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: eb002c93 bl 3001279c <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: eb0028ba bl 300118a0 <__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}
3000a4c4 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
3000a4c4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
3000a4c8: e59f41ec ldr r4, [pc, #492] ; 3000a6bc <rtems_aio_enqueue+0x1f8><== NOT EXECUTED
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
3000a4cc: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED 3000a4d0: e1a06000 mov r6, r0 <== NOT EXECUTED
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
3000a4d4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a4d8: eb00024d bl 3000ae14 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0) {
3000a4dc: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000a4e0: 0a000002 beq 3000a4f0 <rtems_aio_enqueue+0x2c> <== NOT EXECUTED
free (req);
3000a4e4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a4e8: ebfff271 bl 30006eb4 <free> <== NOT EXECUTED
return result;
3000a4ec: ea00006f b 3000a6b0 <rtems_aio_enqueue+0x1ec> <== NOT EXECUTED
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
3000a4f0: eb000451 bl 3000b63c <pthread_self> <== NOT EXECUTED 3000a4f4: e28d101c add r1, sp, #28 <== NOT EXECUTED 3000a4f8: e1a0200d mov r2, sp <== NOT EXECUTED 3000a4fc: eb000359 bl 3000b268 <pthread_getschedparam> <== NOT EXECUTED
req->caller_thread = pthread_self ();
3000a500: eb00044d bl 3000b63c <pthread_self> <== NOT EXECUTED
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
3000a504: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 3000a508: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000a50c: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
3000a510: e5860010 str r0, [r6, #16] <== NOT EXECUTED
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
3000a514: e0622001 rsb r2, r2, r1 <== NOT EXECUTED 3000a518: e586200c str r2, [r6, #12] <== NOT EXECUTED
req->policy = policy;
3000a51c: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 3000a520: e5862008 str r2, [r6, #8] <== NOT EXECUTED
req->aiocbp->error_code = EINPROGRESS;
3000a524: e3a02077 mov r2, #119 ; 0x77 <== NOT EXECUTED 3000a528: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
3000a52c: e5942068 ldr r2, [r4, #104] ; 0x68 <== NOT EXECUTED
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
3000a530: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
3000a534: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a538: 1a00002e bne 3000a5f8 <rtems_aio_enqueue+0x134> <== NOT EXECUTED 3000a53c: e5942064 ldr r2, [r4, #100] ; 0x64 <== NOT EXECUTED 3000a540: e3520004 cmp r2, #4 <== NOT EXECUTED 3000a544: ca00002b bgt 3000a5f8 <rtems_aio_enqueue+0x134> <== NOT EXECUTED
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
3000a548: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a54c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000a550: e3a02001 mov r2, #1 <== NOT EXECUTED 3000a554: ebfffece bl 3000a094 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000a558: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
3000a55c: e1a07000 mov r7, r0 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000a560: e3530001 cmp r3, #1 <== NOT EXECUTED 3000a564: e2809008 add r9, r0, #8 <== NOT EXECUTED 3000a568: e280801c add r8, r0, #28 <== NOT EXECUTED 3000a56c: e280a020 add sl, r0, #32 <== NOT EXECUTED 3000a570: 1a000017 bne 3000a5d4 <rtems_aio_enqueue+0x110> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
3000a574: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a578: e1a00009 mov r0, r9 <== NOT EXECUTED 3000a57c: eb00084b bl 3000c6b0 <_Chain_Insert> <== NOT EXECUTED
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
3000a580: e1a01005 mov r1, r5 <== NOT EXECUTED
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
if (r_chain->new_fd == 1) {
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
3000a584: e5875018 str r5, [r7, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
3000a588: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a58c: eb0001ce bl 3000accc <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
3000a590: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a594: e1a0000a mov r0, sl <== NOT EXECUTED 3000a598: eb0000e3 bl 3000a92c <pthread_cond_init> <== NOT EXECUTED
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
3000a59c: e1a03007 mov r3, r7 <== NOT EXECUTED 3000a5a0: e28d0020 add r0, sp, #32 <== NOT EXECUTED 3000a5a4: e2841008 add r1, r4, #8 <== NOT EXECUTED 3000a5a8: e59f2110 ldr r2, [pc, #272] ; 3000a6c0 <rtems_aio_enqueue+0x1fc><== NOT EXECUTED 3000a5ac: eb000299 bl 3000b018 <pthread_create> <== NOT EXECUTED
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
3000a5b0: e2506000 subs r6, r0, #0 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
3000a5b4: 05943064 ldreq r3, [r4, #100] ; 0x64 <== NOT EXECUTED 3000a5b8: 02833001 addeq r3, r3, #1 <== NOT EXECUTED 3000a5bc: 05843064 streq r3, [r4, #100] ; 0x64 <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
3000a5c0: 0a000038 beq 3000a6a8 <rtems_aio_enqueue+0x1e4> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a5c4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a5c8: eb000230 bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
3000a5cc: e1a05006 mov r5, r6 <== NOT EXECUTED 3000a5d0: ea000036 b 3000a6b0 <rtems_aio_enqueue+0x1ec> <== NOT EXECUTED
}
++aio_request_queue.active_threads;
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
3000a5d4: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a5d8: eb00020d bl 3000ae14 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
3000a5dc: e1a00009 mov r0, r9 <== NOT EXECUTED 3000a5e0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a5e4: ebffff76 bl 3000a3c4 <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
3000a5e8: e1a0000a mov r0, sl <== NOT EXECUTED 3000a5ec: eb0000fe bl 3000a9ec <pthread_cond_signal> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000a5f0: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a5f4: ea00000e b 3000a634 <rtems_aio_enqueue+0x170> <== NOT EXECUTED
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
3000a5f8: e59f00c4 ldr r0, [pc, #196] ; 3000a6c4 <rtems_aio_enqueue+0x200><== NOT EXECUTED 3000a5fc: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a600: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a604: ebfffea2 bl 3000a094 <rtems_aio_search_fd> <== NOT EXECUTED
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
3000a608: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000a60c: 0a00000a beq 3000a63c <rtems_aio_enqueue+0x178> <== NOT EXECUTED
{
pthread_mutex_lock (&r_chain->mutex);
3000a610: e284701c add r7, r4, #28 <== NOT EXECUTED 3000a614: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a618: eb0001fd bl 3000ae14 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
3000a61c: e2840008 add r0, r4, #8 <== NOT EXECUTED 3000a620: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a624: ebffff66 bl 3000a3c4 <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
3000a628: e2840020 add r0, r4, #32 <== NOT EXECUTED 3000a62c: eb0000ee bl 3000a9ec <pthread_cond_signal> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000a630: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a634: eb000215 bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED 3000a638: ea00001a b 3000a6a8 <rtems_aio_enqueue+0x1e4> <== NOT EXECUTED
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
3000a63c: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 3000a640: e59f0080 ldr r0, [pc, #128] ; 3000a6c8 <rtems_aio_enqueue+0x204><== NOT EXECUTED 3000a644: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a648: e3a02001 mov r2, #1 <== NOT EXECUTED 3000a64c: ebfffe90 bl 3000a094 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000a650: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
3000a654: e1a07000 mov r7, r0 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000a658: e3530001 cmp r3, #1 <== NOT EXECUTED 3000a65c: e2800008 add r0, r0, #8 <== NOT EXECUTED 3000a660: 1a000009 bne 3000a68c <rtems_aio_enqueue+0x1c8> <== NOT EXECUTED 3000a664: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a668: eb000810 bl 3000c6b0 <_Chain_Insert> <== NOT EXECUTED
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
3000a66c: e1a01004 mov r1, r4 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
3000a670: e5874018 str r4, [r7, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
3000a674: e287001c add r0, r7, #28 <== NOT EXECUTED 3000a678: eb000193 bl 3000accc <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
3000a67c: e2870020 add r0, r7, #32 <== NOT EXECUTED 3000a680: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a684: eb0000a8 bl 3000a92c <pthread_cond_init> <== NOT EXECUTED 3000a688: ea000001 b 3000a694 <rtems_aio_enqueue+0x1d0> <== NOT EXECUTED
} else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
3000a68c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a690: ebffff4b bl 3000a3c4 <rtems_aio_insert_prio> <== NOT EXECUTED
if (aio_request_queue.idle_threads > 0)
3000a694: e59f0020 ldr r0, [pc, #32] ; 3000a6bc <rtems_aio_enqueue+0x1f8><== NOT EXECUTED 3000a698: e5903068 ldr r3, [r0, #104] ; 0x68 <== NOT EXECUTED 3000a69c: e3530000 cmp r3, #0 <== NOT EXECUTED
pthread_cond_signal (&aio_request_queue.new_req);
3000a6a0: c2800004 addgt r0, r0, #4 <== NOT EXECUTED 3000a6a4: cb0000d0 blgt 3000a9ec <pthread_cond_signal> <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a6a8: e59f000c ldr r0, [pc, #12] ; 3000a6bc <rtems_aio_enqueue+0x1f8><== NOT EXECUTED 3000a6ac: eb0001f7 bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
return 0; }
3000a6b0: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a6b4: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
3000a6b8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
3000a178 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
3000a178: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
3000a17c: e59f4238 ldr r4, [pc, #568] ; 3000a3bc <rtems_aio_handle+0x244><== NOT EXECUTED
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
3000a180: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED 3000a184: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
3000a188: e28d7020 add r7, sp, #32 <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
3000a18c: e28db004 add fp, sp, #4 <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
3000a190: e285a01c add sl, r5, #28 <== NOT EXECUTED 3000a194: e1a0000a mov r0, sl <== NOT EXECUTED 3000a198: eb00031d bl 3000ae14 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
3000a19c: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3000a1a0: 1a000082 bne 3000a3b0 <rtems_aio_handle+0x238> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a1a4: e5956008 ldr r6, [r5, #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 );
3000a1a8: e285300c add r3, r5, #12 <== NOT EXECUTED
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
3000a1ac: e1560003 cmp r6, r3 <== NOT EXECUTED 3000a1b0: 0a000035 beq 3000a28c <rtems_aio_handle+0x114> <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
3000a1b4: eb000520 bl 3000b63c <pthread_self> <== NOT EXECUTED 3000a1b8: e28d1028 add r1, sp, #40 ; 0x28 <== NOT EXECUTED 3000a1bc: e1a0200b mov r2, fp <== NOT EXECUTED 3000a1c0: eb000428 bl 3000b268 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
3000a1c4: e596300c ldr r3, [r6, #12] <== NOT EXECUTED 3000a1c8: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
3000a1cc: eb00051a bl 3000b63c <pthread_self> <== NOT EXECUTED 3000a1d0: e1a0200b mov r2, fp <== NOT EXECUTED 3000a1d4: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 3000a1d8: eb00051c bl 3000b650 <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000a1dc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a1e0: eb00091d bl 3000c65c <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
3000a1e4: e1a0000a mov r0, sl <== NOT EXECUTED 3000a1e8: eb000328 bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
3000a1ec: e5962014 ldr r2, [r6, #20] <== NOT EXECUTED 3000a1f0: e592302c ldr r3, [r2, #44] ; 0x2c <== NOT EXECUTED 3000a1f4: e3530002 cmp r3, #2 <== NOT EXECUTED 3000a1f8: 0a00000b beq 3000a22c <rtems_aio_handle+0xb4> <== NOT EXECUTED 3000a1fc: e3530003 cmp r3, #3 <== NOT EXECUTED 3000a200: 0a000011 beq 3000a24c <rtems_aio_handle+0xd4> <== NOT EXECUTED 3000a204: e3530001 cmp r3, #1 <== NOT EXECUTED 3000a208: 1a000013 bne 3000a25c <rtems_aio_handle+0xe4> <== NOT EXECUTED
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
3000a20c: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED 3000a210: e5923004 ldr r3, [r2, #4] <== NOT EXECUTED 3000a214: e58d1000 str r1, [sp] <== NOT EXECUTED 3000a218: e592100c ldr r1, [r2, #12] <== NOT EXECUTED 3000a21c: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000a220: e5922010 ldr r2, [r2, #16] <== NOT EXECUTED 3000a224: eb0028f9 bl 30014610 <pread> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
3000a228: ea000009 b 3000a254 <rtems_aio_handle+0xdc> <== NOT EXECUTED
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
3000a22c: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED 3000a230: e5923004 ldr r3, [r2, #4] <== NOT EXECUTED 3000a234: e58d1000 str r1, [sp] <== NOT EXECUTED 3000a238: e592100c ldr r1, [r2, #12] <== NOT EXECUTED 3000a23c: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000a240: e5922010 ldr r2, [r2, #16] <== NOT EXECUTED 3000a244: eb00293b bl 30014738 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
3000a248: ea000001 b 3000a254 <rtems_aio_handle+0xdc> <== NOT EXECUTED
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
3000a24c: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000a250: eb001989 bl 3001087c <fsync> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
3000a254: e3700001 cmn r0, #1 <== NOT EXECUTED 3000a258: 1a000006 bne 3000a278 <rtems_aio_handle+0x100> <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000a25c: e5966014 ldr r6, [r6, #20] <== NOT EXECUTED 3000a260: e3e02000 mvn r2, #0 <== NOT EXECUTED 3000a264: e5862034 str r2, [r6, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = errno;
3000a268: eb0025e4 bl 30013a00 <__errno> <== NOT EXECUTED 3000a26c: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000a270: e5863030 str r3, [r6, #48] ; 0x30 <== NOT EXECUTED 3000a274: eaffffc5 b 3000a190 <rtems_aio_handle+0x18> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
3000a278: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
req->aiocbp->error_code = 0;
3000a27c: e3a02000 mov r2, #0 <== NOT EXECUTED
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
3000a280: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = 0;
3000a284: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED 3000a288: eaffffc0 b 3000a190 <rtems_aio_handle+0x18> <== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
3000a28c: e59f8128 ldr r8, [pc, #296] ; 3000a3bc <rtems_aio_handle+0x244><== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
3000a290: e1a0000a mov r0, sl <== NOT EXECUTED 3000a294: eb0002fd bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
3000a298: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a29c: eb0002dc bl 3000ae14 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
3000a2a0: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000a2a4: e1530006 cmp r3, r6 <== NOT EXECUTED 3000a2a8: 1a00003d bne 3000a3a4 <rtems_aio_handle+0x22c> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
3000a2ac: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a2b0: e3a00001 mov r0, #1 <== NOT EXECUTED 3000a2b4: eb00014e bl 3000a7f4 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
3000a2b8: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
3000a2bc: e2856020 add r6, r5, #32 <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
3000a2c0: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
3000a2c4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a2c8: e1a01008 mov r1, r8 <== NOT EXECUTED 3000a2cc: e1a02007 mov r2, r7 <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
3000a2d0: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
3000a2d4: e58d9024 str r9, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
3000a2d8: eb0001da bl 3000aa48 <pthread_cond_timedwait> <== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
3000a2dc: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED 3000a2e0: 1a00002f bne 3000a3a4 <rtems_aio_handle+0x22c> <== NOT EXECUTED 3000a2e4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a2e8: eb0008db bl 3000c65c <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
3000a2ec: e1a0000a mov r0, sl <== NOT EXECUTED 3000a2f0: eb000229 bl 3000ab9c <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
3000a2f4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a2f8: eb00015b bl 3000a86c <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
3000a2fc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a300: ebfff2eb bl 30006eb4 <free> <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
3000a304: e5943054 ldr r3, [r4, #84] ; 0x54 <== NOT EXECUTED 3000a308: e59f20b0 ldr r2, [pc, #176] ; 3000a3c0 <rtems_aio_handle+0x248><== NOT EXECUTED 3000a30c: e1530002 cmp r3, r2 <== NOT EXECUTED 3000a310: 1a000018 bne 3000a378 <rtems_aio_handle+0x200> <== NOT EXECUTED
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
3000a314: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED
--aio_request_queue.active_threads; clock_gettime (CLOCK_REALTIME, &timeout);
3000a318: e1a01007 mov r1, r7 <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
3000a31c: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000a320: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED
--aio_request_queue.active_threads;
3000a324: e5943064 ldr r3, [r4, #100] ; 0x64 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
3000a328: e3a00001 mov r0, #1 <== NOT EXECUTED
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
3000a32c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000a330: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
3000a334: eb00012e bl 3000a7f4 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
3000a338: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000a33c: e2880004 add r0, r8, #4 <== NOT EXECUTED
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
3000a340: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000a344: e1a01008 mov r1, r8 <== NOT EXECUTED 3000a348: e1a02007 mov r2, r7 <== NOT EXECUTED
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
3000a34c: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
3000a350: e58d9024 str r9, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000a354: eb0001bb bl 3000aa48 <pthread_cond_timedwait> <== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
3000a358: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED 3000a35c: 1a000005 bne 3000a378 <rtems_aio_handle+0x200> <== NOT EXECUTED
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
3000a360: e5983068 ldr r3, [r8, #104] ; 0x68 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a364: e1a00008 mov r0, r8 <== NOT EXECUTED
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
3000a368: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000a36c: e5883068 str r3, [r8, #104] ; 0x68 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a370: eb0002c6 bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
3000a374: ea00000d b 3000a3b0 <rtems_aio_handle+0x238> <== NOT EXECUTED
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
3000a378: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a37c: e5945054 ldr r5, [r4, #84] ; 0x54 <== NOT EXECUTED
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
3000a380: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000a384: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED
++aio_request_queue.active_threads;
3000a388: e5943064 ldr r3, [r4, #100] ; 0x64 <== NOT EXECUTED 3000a38c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a390: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000a394: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED 3000a398: eb0008af bl 3000c65c <_Chain_Extract> <== NOT EXECUTED
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = (rtems_aio_request_chain *) node;
rtems_aio_move_to_work (r_chain);
3000a39c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a3a0: ebffff65 bl 3000a13c <rtems_aio_move_to_work> <== NOT EXECUTED
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a3a4: e59f0010 ldr r0, [pc, #16] ; 3000a3bc <rtems_aio_handle+0x244><== NOT EXECUTED 3000a3a8: eb0002b8 bl 3000ae90 <pthread_mutex_unlock> <== NOT EXECUTED 3000a3ac: eaffff77 b 3000a190 <rtems_aio_handle+0x18> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a3b0: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a3b4: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
3000a3b8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30009fd4 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
30009fd4: e92d4010 push {r4, lr} <== NOT EXECUTED
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
30009fd8: e59f00a4 ldr r0, [pc, #164] ; 3000a084 <rtems_aio_init+0xb0><== NOT EXECUTED 30009fdc: eb0003ed bl 3000af98 <pthread_attr_init> <== NOT EXECUTED
if (result != 0)
30009fe0: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30009fe4: 1a000024 bne 3000a07c <rtems_aio_init+0xa8> <== NOT EXECUTED
return result;
result =
30009fe8: e59f0094 ldr r0, [pc, #148] ; 3000a084 <rtems_aio_init+0xb0><== NOT EXECUTED 30009fec: e1a01004 mov r1, r4 <== NOT EXECUTED 30009ff0: eb0003fa bl 3000afe0 <pthread_attr_setdetachstate> <== NOT EXECUTED
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
30009ff4: e3500000 cmp r0, #0 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
30009ff8: 159f0084 ldrne r0, [pc, #132] ; 3000a084 <rtems_aio_init+0xb0><== NOT EXECUTED 30009ffc: 1b0003dc blne 3000af74 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
3000a000: e59f0080 ldr r0, [pc, #128] ; 3000a088 <rtems_aio_init+0xb4><== NOT EXECUTED 3000a004: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a008: eb00032f bl 3000accc <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
3000a00c: e3500000 cmp r0, #0 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
3000a010: 159f006c ldrne r0, [pc, #108] ; 3000a084 <rtems_aio_init+0xb0><== NOT EXECUTED 3000a014: 1b0003d6 blne 3000af74 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
3000a018: e59f006c ldr r0, [pc, #108] ; 3000a08c <rtems_aio_init+0xb8><== NOT EXECUTED 3000a01c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a020: eb000241 bl 3000a92c <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
3000a024: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000a028: 0a000003 beq 3000a03c <rtems_aio_init+0x68> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
3000a02c: e59f0054 ldr r0, [pc, #84] ; 3000a088 <rtems_aio_init+0xb4><== NOT EXECUTED 3000a030: eb0002d9 bl 3000ab9c <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
3000a034: e59f0048 ldr r0, [pc, #72] ; 3000a084 <rtems_aio_init+0xb0><== NOT EXECUTED 3000a038: eb0003cd bl 3000af74 <pthread_attr_destroy> <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000a03c: e59f3044 ldr r3, [pc, #68] ; 3000a088 <rtems_aio_init+0xb4><== NOT EXECUTED 3000a040: e283204c add r2, r3, #76 ; 0x4c <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3000a044: e2831048 add r1, r3, #72 ; 0x48 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000a048: e5832048 str r2, [r3, #72] ; 0x48 <== NOT EXECUTED
head->previous = NULL;
3000a04c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a050: e583204c str r2, [r3, #76] ; 0x4c <== NOT EXECUTED
tail->previous = head;
3000a054: e5831050 str r1, [r3, #80] ; 0x50 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3000a058: e5832058 str r2, [r3, #88] ; 0x58 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000a05c: e2831058 add r1, r3, #88 ; 0x58 <== NOT EXECUTED
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
3000a060: e5832064 str r2, [r3, #100] ; 0x64 <== NOT EXECUTED
aio_request_queue.idle_threads = 0;
3000a064: e5832068 str r2, [r3, #104] ; 0x68 <== NOT EXECUTED
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
3000a068: e59f2020 ldr r2, [pc, #32] ; 3000a090 <rtems_aio_init+0xbc><== NOT EXECUTED 3000a06c: e5831054 str r1, [r3, #84] ; 0x54 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3000a070: e2831054 add r1, r3, #84 ; 0x54 <== NOT EXECUTED 3000a074: e583105c str r1, [r3, #92] ; 0x5c <== NOT EXECUTED 3000a078: e5832060 str r2, [r3, #96] ; 0x60 <== NOT EXECUTED
return result;
}
3000a07c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000a080: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a3c4 <rtems_aio_insert_prio>:
3000a3c4: e1a03000 mov r3, r0 <== NOT EXECUTED 3000a3c8: e4932004 ldr r2, [r3], #4 <== NOT EXECUTED
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
3000a3cc: e1a0c001 mov ip, r1 <== NOT EXECUTED
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
3000a3d0: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a3d4: 0a00000d beq 3000a410 <rtems_aio_insert_prio+0x4c> <== NOT EXECUTED
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
3000a3d8: e5921014 ldr r1, [r2, #20] <== NOT EXECUTED
while (req->aiocbp->aio_reqprio > prio &&
3000a3dc: e59c0014 ldr r0, [ip, #20] <== NOT EXECUTED
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
3000a3e0: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED
while (req->aiocbp->aio_reqprio > prio &&
3000a3e4: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED 3000a3e8: ea000002 b 3000a3f8 <rtems_aio_insert_prio+0x34> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a3ec: e5922000 ldr r2, [r2] <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
3000a3f0: e5921014 ldr r1, [r2, #20] <== NOT EXECUTED 3000a3f4: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
3000a3f8: e1500001 cmp r0, r1 <== NOT EXECUTED 3000a3fc: da000001 ble 3000a408 <rtems_aio_insert_prio+0x44> <== NOT EXECUTED 3000a400: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a404: 1afffff8 bne 3000a3ec <rtems_aio_insert_prio+0x28> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
3000a408: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED 3000a40c: e1a0100c mov r1, ip <== NOT EXECUTED 3000a410: ea0008a6 b 3000c6b0 <_Chain_Insert> <== NOT EXECUTED
3000a13c <rtems_aio_move_to_work>:
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a13c: e59f2030 ldr r2, [pc, #48] ; 3000a174 <rtems_aio_move_to_work+0x38><== NOT EXECUTED
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
3000a140: e1a01000 mov r1, r0 <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a144: e5923048 ldr r3, [r2, #72] ; 0x48 <== NOT EXECUTED
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
3000a148: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED 3000a14c: e282204c add r2, r2, #76 ; 0x4c <== NOT EXECUTED 3000a150: ea000000 b 3000a158 <rtems_aio_move_to_work+0x1c> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a154: e5933000 ldr r3, [r3] <== NOT EXECUTED
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
3000a158: e593c014 ldr ip, [r3, #20] <== NOT EXECUTED 3000a15c: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000a160: aa000001 bge 3000a16c <rtems_aio_move_to_work+0x30> <== NOT EXECUTED 3000a164: e1530002 cmp r3, r2 <== NOT EXECUTED 3000a168: 1afffff9 bne 3000a154 <rtems_aio_move_to_work+0x18> <== NOT EXECUTED 3000a16c: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 3000a170: ea00094e b 3000c6b0 <_Chain_Insert> <== NOT EXECUTED
3000a414 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
3000a414: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
3000a418: e280700c add r7, r0, #12 <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a41c: e5904008 ldr r4, [r0, #8] <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
3000a420: e3a0608c mov r6, #140 ; 0x8c <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000a424: e3e05000 mvn r5, #0 <== NOT EXECUTED
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
3000a428: ea000008 b 3000a450 <rtems_aio_remove_fd+0x3c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000a42c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a430: eb000889 bl 3000c65c <_Chain_Extract> <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
3000a434: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a438: e5948000 ldr r8, [r4] <== NOT EXECUTED
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
3000a43c: e1a00004 mov r0, r4 <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
3000a440: e5836030 str r6, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000a444: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
3000a448: ebfff299 bl 30006eb4 <free> <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
3000a44c: e1a04008 mov r4, r8 <== NOT EXECUTED
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
3000a450: e1540007 cmp r4, r7 <== NOT EXECUTED 3000a454: 1afffff4 bne 3000a42c <rtems_aio_remove_fd+0x18> <== NOT EXECUTED
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
3000a458: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000a45c <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
3000a45c: e92d4010 push {r4, lr} <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a460: e1a03000 mov r3, r0 <== NOT EXECUTED 3000a464: e4934004 ldr r4, [r3], #4 <== NOT EXECUTED
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
3000a468: e1540003 cmp r4, r3 <== NOT EXECUTED
return AIO_ALLDONE;
3000a46c: 03a00002 moveq r0, #2 <== NOT EXECUTED
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
3000a470: 1a000003 bne 3000a484 <rtems_aio_remove_req+0x28> <== NOT EXECUTED
3000a474: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a478: e5904000 ldr r4, [r0] <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
3000a47c: e1540003 cmp r4, r3 <== NOT EXECUTED 3000a480: 0a00000d beq 3000a4bc <rtems_aio_remove_req+0x60> <== NOT EXECUTED 3000a484: e5942014 ldr r2, [r4, #20] <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
3000a488: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
3000a48c: e1520001 cmp r2, r1 <== NOT EXECUTED 3000a490: 1afffff8 bne 3000a478 <rtems_aio_remove_req+0x1c> <== NOT EXECUTED 3000a494: eb000870 bl 3000c65c <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
3000a498: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000a49c: e3a0208c mov r2, #140 ; 0x8c <== NOT EXECUTED 3000a4a0: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
current->aiocbp->return_value = -1;
3000a4a4: e3e02000 mvn r2, #0 <== NOT EXECUTED
free (current);
3000a4a8: e1a00004 mov r0, r4 <== NOT EXECUTED
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
3000a4ac: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
free (current);
3000a4b0: ebfff27f bl 30006eb4 <free> <== NOT EXECUTED
}
return AIO_CANCELED;
3000a4b4: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a4b8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
3000a4bc: e3a00001 mov r0, #1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
3000a4c0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a094 <rtems_aio_search_fd>:
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
3000a094: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a098: e1a03000 mov r3, r0 <== NOT EXECUTED
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
3000a09c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a0a0: e1a05001 mov r5, r1 <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a0a4: e4936004 ldr r6, [r3], #4 <== NOT EXECUTED 3000a0a8: ea000000 b 3000a0b0 <rtems_aio_search_fd+0x1c> <== NOT EXECUTED 3000a0ac: e5966000 ldr r6, [r6] <== NOT EXECUTED
rtems_chain_node *node;
node = rtems_chain_first (chain);
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
3000a0b0: e5961014 ldr r1, [r6, #20] <== NOT EXECUTED
node = rtems_chain_next (node);
3000a0b4: e1a08006 mov r8, r6 <== NOT EXECUTED
rtems_chain_node *node;
node = rtems_chain_first (chain);
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
3000a0b8: e1510005 cmp r1, r5 <== NOT EXECUTED 3000a0bc: ba000003 blt 3000a0d0 <rtems_aio_search_fd+0x3c> <== NOT EXECUTED
node = rtems_chain_next (node);
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
3000a0c0: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000a0c4: 05863018 streq r3, [r6, #24] <== NOT EXECUTED
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
3000a0c8: 0a000019 beq 3000a134 <rtems_aio_search_fd+0xa0> <== NOT EXECUTED 3000a0cc: ea000001 b 3000a0d8 <rtems_aio_search_fd+0x44> <== NOT EXECUTED
rtems_chain_node *node;
node = rtems_chain_first (chain);
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
3000a0d0: e1560003 cmp r6, r3 <== NOT EXECUTED 3000a0d4: 1afffff4 bne 3000a0ac <rtems_aio_search_fd+0x18> <== NOT EXECUTED
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
3000a0d8: e3520000 cmp r2, #0 <== NOT EXECUTED
r_chain = NULL;
3000a0dc: 01a06002 moveq r6, r2 <== NOT EXECUTED
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
3000a0e0: 0a000013 beq 3000a134 <rtems_aio_search_fd+0xa0> <== NOT EXECUTED
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
3000a0e4: e3a00024 mov r0, #36 ; 0x24 <== NOT EXECUTED 3000a0e8: ebfff4d7 bl 3000744c <malloc> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000a0ec: e280300c add r3, r0, #12 <== NOT EXECUTED
head->next = tail;
3000a0f0: e5803008 str r3, [r0, #8] <== NOT EXECUTED
head->previous = NULL;
3000a0f4: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a0f8: e580300c str r3, [r0, #12] <== NOT EXECUTED
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
3000a0fc: e5942000 ldr r2, [r4] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3000a100: e2803008 add r3, r0, #8 <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
3000a104: e5803010 str r3, [r0, #16] <== 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 );
3000a108: e2843004 add r3, r4, #4 <== NOT EXECUTED
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
3000a10c: e1a07000 mov r7, r0 <== NOT EXECUTED
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
3000a110: e1520003 cmp r2, r3 <== NOT EXECUTED
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
3000a114: e1a06000 mov r6, r0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
3000a118: e1a01007 mov r1, r7 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
3000a11c: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000a120: 15980004 ldrne r0, [r8, #4] <== NOT EXECUTED 3000a124: eb000961 bl 3000c6b0 <_Chain_Insert> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
rtems_chain_prepend (chain, &r_chain->next_fd);
else
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
r_chain->new_fd = 1;
3000a128: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a12c: e5873018 str r3, [r7, #24] <== NOT EXECUTED
r_chain->fildes = fildes;
3000a130: e5875014 str r5, [r7, #20] <== NOT EXECUTED
}
}
return r_chain;
}
3000a134: e1a00006 mov r0, r6 <== NOT EXECUTED
3000a138: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
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
30015a8c <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;
}
30015a8c: e59f0000 ldr r0, [pc, #0] ; 30015a94 <rtems_assoc_name_bad+0x8><== NOT EXECUTED 30015a90: e12fff1e bx lr <== NOT EXECUTED
30012b0c <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30012b0c: e92d4010 push {r4, lr} <== NOT EXECUTED
30012b10: e1a04001 mov r4, r1 <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
30012b14: eb000006 bl 30012b34 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if (nap)
30012b18: e3500000 cmp r0, #0 <== NOT EXECUTED 30012b1c: 0a000001 beq 30012b28 <rtems_assoc_name_by_local+0x1c> <== NOT EXECUTED
return nap->name;
return rtems_assoc_name_bad(local_value);
}
30012b20: e5900000 ldr r0, [r0] <== NOT EXECUTED
30012b24: 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);
30012b28: e1a00004 mov r0, r4 <== NOT EXECUTED
}
30012b2c: 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);
30012b30: ea000bd5 b 30015a8c <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: 1b002f4d blne 30012984 <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: eb002f47 bl 30012984 <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: ea001ee1 b 3000e8c0 <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: 1b002f28 blne 30012984 <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: eb002f22 bl 30012984 <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
30012b34 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30012b34: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30012b38: e1a04000 mov r4, r0 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30012b3c: e5900000 ldr r0, [r0] <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30012b40: e1a05001 mov r5, r1 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30012b44: e3500000 cmp r0, #0 <== NOT EXECUTED 30012b48: 0a00000a beq 30012b78 <rtems_assoc_ptr_by_local+0x44> <== NOT EXECUTED 30012b4c: e59f103c ldr r1, [pc, #60] ; 30012b90 <rtems_assoc_ptr_by_local+0x5c><== NOT EXECUTED 30012b50: eb0011ad bl 3001720c <strcmp> <== NOT EXECUTED 30012b54: e3500000 cmp r0, #0 <== NOT EXECUTED
default_ap = ap++;
30012b58: 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;
30012b5c: 13a00000 movne r0, #0 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
30012b60: 1a000004 bne 30012b78 <rtems_assoc_ptr_by_local+0x44> <== NOT EXECUTED 30012b64: ea000002 b 30012b74 <rtems_assoc_ptr_by_local+0x40> <== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
30012b68: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30012b6c: e1530005 cmp r3, r5 <== NOT EXECUTED 30012b70: 0a000004 beq 30012b88 <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++)
30012b74: e284400c add r4, r4, #12 <== NOT EXECUTED 30012b78: e5943000 ldr r3, [r4] <== NOT EXECUTED 30012b7c: e3530000 cmp r3, #0 <== NOT EXECUTED 30012b80: 1afffff8 bne 30012b68 <rtems_assoc_ptr_by_local+0x34> <== NOT EXECUTED
if (ap->local_value == local_value)
return ap;
return default_ap;
30012b84: e1a04000 mov r4, r0 <== NOT EXECUTED
}
30012b88: e1a00004 mov r0, r4 <== NOT EXECUTED
30012b8c: 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: eb002f1c bl 30012a30 <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: eb002f15 bl 30012a30 <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
3001080c <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
3001080c: e92d4030 push {r4, r5, lr}
30010810: e1a04000 mov r4, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30010814: e5900000 ldr r0, [r0]
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
30010818: e1a05001 mov r5, r1
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
3001081c: e3500000 cmp r0, #0
30010820: 0a00000a beq 30010850 <rtems_assoc_ptr_by_remote+0x44>
30010824: e59f103c ldr r1, [pc, #60] ; 30010868 <rtems_assoc_ptr_by_remote+0x5c> 30010828: eb000533 bl 30011cfc <strcmp> 3001082c: e3500000 cmp r0, #0
default_ap = ap++;
30010830: 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;
30010834: 13a00000 movne r0, #0
if (rtems_assoc_is_default(ap))
30010838: 1a000004 bne 30010850 <rtems_assoc_ptr_by_remote+0x44>
3001083c: ea000002 b 3001084c <rtems_assoc_ptr_by_remote+0x40> <== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
30010840: e5943008 ldr r3, [r4, #8] 30010844: e1530005 cmp r3, r5
30010848: 0a000004 beq 30010860 <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++)
3001084c: e284400c add r4, r4, #12 30010850: e5943000 ldr r3, [r4] 30010854: e3530000 cmp r3, #0
30010858: 1afffff8 bne 30010840 <rtems_assoc_ptr_by_remote+0x34>
if (ap->remote_value == remote_value)
return ap;
return default_ap;
3001085c: e1a04000 mov r4, r0
}
30010860: e1a00004 mov r0, r4
30010864: 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
30011430 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
30011430: 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 ) )
30011434: e2508000 subs r8, r0, #0
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
30011438: e1a04001 mov r4, r1 3001143c: e1a06003 mov r6, r3
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30011440: 03a00003 moveq r0, #3
)
{
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
30011444: 0a000026 beq 300114e4 <rtems_barrier_create+0xb4>
return RTEMS_INVALID_NAME;
if ( !id )
30011448: e3530000 cmp r3, #0
return RTEMS_INVALID_ADDRESS;
3001144c: 03a00009 moveq r0, #9
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30011450: 0a000023 beq 300114e4 <rtems_barrier_create+0xb4>
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
30011454: e3110010 tst r1, #16
30011458: 0a000004 beq 30011470 <rtems_barrier_create+0x40>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
3001145c: e3a03000 mov r3, #0 <== NOT EXECUTED
if ( maximum_waiters == 0 )
30011460: 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;
30011464: e58d3000 str r3, [sp] <== NOT EXECUTED
if ( maximum_waiters == 0 )
30011468: 1a000002 bne 30011478 <rtems_barrier_create+0x48> <== NOT EXECUTED 3001146c: ea00001b b 300114e0 <rtems_barrier_create+0xb0> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
30011470: e3a03001 mov r3, #1 30011474: e58d3000 str r3, [sp] 30011478: e59f3068 ldr r3, [pc, #104] ; 300114e8 <rtems_barrier_create+0xb8>
the_attributes.maximum_count = maximum_waiters;
3001147c: e58d2004 str r2, [sp, #4] 30011480: e5932000 ldr r2, [r3] 30011484: e2822001 add r2, r2, #1 30011488: 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 );
3001148c: e59f7058 ldr r7, [pc, #88] ; 300114ec <rtems_barrier_create+0xbc> 30011490: e1a00007 mov r0, r7 30011494: ebffec9f bl 3000c718 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
30011498: e2505000 subs r5, r0, #0
3001149c: 1a000002 bne 300114ac <rtems_barrier_create+0x7c>
_Thread_Enable_dispatch();
300114a0: ebfff0ca bl 3000d7d0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
300114a4: e3a00005 mov r0, #5 <== NOT EXECUTED 300114a8: ea00000d b 300114e4 <rtems_barrier_create+0xb4> <== NOT EXECUTED
}
the_barrier->attribute_set = attribute_set;
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
300114ac: e2850014 add r0, r5, #20 300114b0: e1a0100d mov r1, sp
if ( !the_barrier ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
300114b4: e5854010 str r4, [r5, #16]
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
300114b8: eb00021d bl 30011d34 <_CORE_barrier_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300114bc: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300114c0: e5953008 ldr r3, [r5, #8] 300114c4: e1d510b8 ldrh r1, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300114c8: e7825101 str r5, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300114cc: e585800c str r8, [r5, #12]
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
300114d0: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
300114d4: ebfff0bd bl 3000d7d0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300114d8: e3a00000 mov r0, #0 300114dc: ea000000 b 300114e4 <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;
300114e0: e3a0000a mov r0, #10 <== NOT EXECUTED
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
300114e4: 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: eb000137 bl 3000a77c <_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: eb000150 bl 3000a80c <_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: eb00014e bl 3000a85c <_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: eb00015c bl 3000a8b8 <_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
3000a224 <rtems_clock_get_seconds_since_epoch>:
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000a224: e3500000 cmp r0, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000a228: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000a22c: 012fff1e bxeq lr <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
3000a230: e59f301c ldr r3, [pc, #28] ; 3000a254 <rtems_clock_get_seconds_since_epoch+0x30><== NOT EXECUTED 3000a234: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 3000a238: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch();
3000a23c: 159f3014 ldrne r3, [pc, #20] ; 3000a258 <rtems_clock_get_seconds_since_epoch+0x34><== NOT EXECUTED
{
if ( !the_interval )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
3000a240: 03a0000b moveq r0, #11 <== NOT EXECUTED
*the_interval = _TOD_Seconds_since_epoch();
3000a244: 15933000 ldrne r3, [r3] <== NOT EXECUTED 3000a248: 15803000 strne r3, [r0] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a24c: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000a250: 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: eb002e59 bl 300147d0 <__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: eb00110a bl 300199dc <_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: eb0064f3 bl 3002e998 <__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: eb000551 bl 3000a610 <_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: eb0004fa bl 3000a294 <_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: eb000e55 bl 3000c808 <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
30008eb0: eb000cdd bl 3000c22c <_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: 0b000a1a bleq 3000b740 <_Thread_Dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
30008ed4: e3a00000 mov r0, #0
30008ed8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30006ab8 <rtems_cpu_usage_report>:
void rtems_cpu_usage_report( void )
{
rtems_cpu_usage_report_with_plugin( NULL, printk_plugin );
30006ab8: e59f1004 ldr r1, [pc, #4] ; 30006ac4 <rtems_cpu_usage_report+0xc><== NOT EXECUTED 30006abc: e3a00000 mov r0, #0 <== NOT EXECUTED 30006ac0: eaffff8a 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: 0a000061 beq 30006a8c <rtems_cpu_usage_report_with_plugin+0x19c><== 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: e59f317c ldr r3, [pc, #380] ; 30006a94 <rtems_cpu_usage_report_with_plugin+0x1a4><== NOT EXECUTED
}
}
}
#endif
(*print)(
30006914: e59f117c ldr r1, [pc, #380] ; 30006a98 <rtems_cpu_usage_report_with_plugin+0x1a8><== 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: e59f5168 ldr r5, [pc, #360] ; 30006a9c <rtems_cpu_usage_report_with_plugin+0x1ac><== NOT EXECUTED 30006930: e28d8040 add r8, sp, #64 ; 0x40 <== NOT EXECUTED
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
30006934: e5b53004 ldr r3, [r5, #4]! <== NOT EXECUTED 30006938: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED
if ( information ) {
3000693c: e3560000 cmp r6, #0 <== NOT EXECUTED 30006940: 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 );
30006944: 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 ) {
30006948: 1a000040 bne 30006a50 <rtems_cpu_usage_report_with_plugin+0x160><== NOT EXECUTED 3000694c: ea000042 b 30006a5c <rtems_cpu_usage_report_with_plugin+0x16c><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
30006950: e596301c ldr r3, [r6, #28] <== NOT EXECUTED 30006954: e7934107 ldr r4, [r3, r7, lsl #2] <== NOT EXECUTED
if ( !the_thread )
30006958: e3540000 cmp r4, #0 <== NOT EXECUTED 3000695c: 0a00003a beq 30006a4c <rtems_cpu_usage_report_with_plugin+0x15c><== NOT EXECUTED
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
30006960: e3a0100d mov r1, #13 <== NOT EXECUTED 30006964: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30006968: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED 3000696c: eb000fde bl 3000a8ec <rtems_object_get_name> <== NOT EXECUTED
(*print)(
30006970: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 30006974: e28d3008 add r3, sp, #8 <== NOT EXECUTED 30006978: e1a00009 mov r0, r9 <== NOT EXECUTED 3000697c: e59f111c ldr r1, [pc, #284] ; 30006aa0 <rtems_cpu_usage_report_with_plugin+0x1b0><== NOT EXECUTED 30006980: e1a0e00f mov lr, pc <== NOT EXECUTED 30006984: 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;
30006988: e2843084 add r3, r4, #132 ; 0x84 <== NOT EXECUTED
3000698c: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30006990: e58d2030 str r2, [sp, #48] ; 0x30 <== NOT EXECUTED
30006994: e58d3034 str r3, [sp, #52] ; 0x34 <== NOT EXECUTED
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
30006998: e59f2104 ldr r2, [pc, #260] ; 30006aa4 <rtems_cpu_usage_report_with_plugin+0x1b4><== NOT EXECUTED 3000699c: e5923004 ldr r3, [r2, #4] <== NOT EXECUTED 300069a0: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 300069a4: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 300069a8: e1520003 cmp r2, r3 <== NOT EXECUTED 300069ac: 1a00000e bne 300069ec <rtems_cpu_usage_report_with_plugin+0xfc><== NOT EXECUTED
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
300069b0: e59f20f0 ldr r2, [pc, #240] ; 30006aa8 <rtems_cpu_usage_report_with_plugin+0x1b8><== NOT EXECUTED
_TOD_Get_uptime( &uptime );
300069b4: 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;
300069b8: e8920018 ldm r2, {r3, r4} <== NOT EXECUTED
300069bc: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
300069c0: e58d401c str r4, [sp, #28] <== NOT EXECUTED
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
300069c4: 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 );
300069c8: eb001467 bl 3000bb6c <_TOD_Get_uptime> <== NOT EXECUTED
_Timestamp_Subtract( &last, &uptime, &used );
300069cc: e28d0018 add r0, sp, #24 <== NOT EXECUTED 300069d0: e1a01008 mov r1, r8 <== NOT EXECUTED 300069d4: e1a02004 mov r2, r4 <== NOT EXECUTED 300069d8: eb001d2a bl 3000de88 <_Timespec_Subtract> <== NOT EXECUTED
_Timestamp_Add_to( &ran, &used );
300069dc: e1a0000b mov r0, fp <== NOT EXECUTED 300069e0: e1a01004 mov r1, r4 <== NOT EXECUTED 300069e4: eb001cec bl 3000dd9c <_Timespec_Add_to> <== NOT EXECUTED 300069e8: ea000001 b 300069f4 <rtems_cpu_usage_report_with_plugin+0x104><== NOT EXECUTED
} else {
_TOD_Get_uptime( &uptime );
300069ec: e1a00008 mov r0, r8 <== NOT EXECUTED 300069f0: eb00145d bl 3000bb6c <_TOD_Get_uptime> <== NOT EXECUTED
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
300069f4: e28d0028 add r0, sp, #40 ; 0x28 <== NOT EXECUTED 300069f8: e1a01008 mov r1, r8 <== NOT EXECUTED 300069fc: e28d2038 add r2, sp, #56 ; 0x38 <== NOT EXECUTED 30006a00: eb001d20 bl 3000de88 <_Timespec_Subtract> <== NOT EXECUTED
_Timestamp_Divide( &ran, &total, &ival, &fval );
30006a04: e28d204c add r2, sp, #76 ; 0x4c <== NOT EXECUTED 30006a08: e28d3048 add r3, sp, #72 ; 0x48 <== NOT EXECUTED 30006a0c: e1a0000b mov r0, fp <== NOT EXECUTED 30006a10: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 30006a14: eb001cf8 bl 3000ddfc <_Timespec_Divide> <== NOT EXECUTED
/*
* Print the information
*/
(*print)( context,
30006a18: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30006a1c: e59d0034 ldr r0, [sp, #52] ; 0x34 <== NOT EXECUTED 30006a20: eb005663 bl 3001c3b4 <__aeabi_uidiv> <== NOT EXECUTED 30006a24: e59d204c ldr r2, [sp, #76] ; 0x4c <== NOT EXECUTED 30006a28: e1a03000 mov r3, r0 <== NOT EXECUTED 30006a2c: e58d2000 str r2, [sp] <== NOT EXECUTED 30006a30: e59d2048 ldr r2, [sp, #72] ; 0x48 <== NOT EXECUTED 30006a34: e1a00009 mov r0, r9 <== NOT EXECUTED 30006a38: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 30006a3c: e59f1068 ldr r1, [pc, #104] ; 30006aac <rtems_cpu_usage_report_with_plugin+0x1bc><== NOT EXECUTED 30006a40: e59d2030 ldr r2, [sp, #48] ; 0x30 <== NOT EXECUTED 30006a44: e1a0e00f mov lr, pc <== NOT EXECUTED 30006a48: e12fff1a bx sl <== NOT EXECUTED
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
30006a4c: e2877001 add r7, r7, #1 <== NOT EXECUTED 30006a50: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED 30006a54: e1570003 cmp r7, r3 <== NOT EXECUTED 30006a58: 9affffbc bls 30006950 <rtems_cpu_usage_report_with_plugin+0x60><== NOT EXECUTED
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
30006a5c: e59f304c ldr r3, [pc, #76] ; 30006ab0 <rtems_cpu_usage_report_with_plugin+0x1c0><== NOT EXECUTED 30006a60: e1550003 cmp r5, r3 <== NOT EXECUTED 30006a64: 1affffb2 bne 30006934 <rtems_cpu_usage_report_with_plugin+0x44><== NOT EXECUTED
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
30006a68: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30006a6c: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED 30006a70: eb00564f bl 3001c3b4 <__aeabi_uidiv> <== NOT EXECUTED 30006a74: e59f1038 ldr r1, [pc, #56] ; 30006ab4 <rtems_cpu_usage_report_with_plugin+0x1c4><== NOT EXECUTED 30006a78: e1a03000 mov r3, r0 <== NOT EXECUTED 30006a7c: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 30006a80: e1a00009 mov r0, r9 <== NOT EXECUTED 30006a84: e1a0e00f mov lr, pc <== NOT EXECUTED 30006a88: e12fff1a bx sl <== NOT EXECUTED
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
30006a8c: e28dd050 add sp, sp, #80 ; 0x50 <== NOT EXECUTED
30006a90: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30006ad8 <rtems_cpu_usage_reset>:
/*
* rtems_cpu_usage_reset
*/
void rtems_cpu_usage_reset( void )
{
30006ad8: e92d4010 push {r4, lr} <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &CPU_usage_Uptime_at_last_reset );
30006adc: e59f401c ldr r4, [pc, #28] ; 30006b00 <rtems_cpu_usage_reset+0x28><== NOT EXECUTED 30006ae0: e1a00004 mov r0, r4 <== NOT EXECUTED 30006ae4: eb001420 bl 3000bb6c <_TOD_Get_uptime> <== NOT EXECUTED
_Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
30006ae8: e8940006 ldm r4, {r1, r2} <== NOT EXECUTED
30006aec: e59f3010 ldr r3, [pc, #16] ; 30006b04 <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);
30006af0: e59f0010 ldr r0, [pc, #16] ; 30006b08 <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;
30006af4: 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);
}
30006af8: 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);
30006afc: ea00158c b 3000c134 <rtems_iterate_over_all_threads> <== NOT EXECUTED
30011018 <rtems_deviceio_errno>:
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
30011018: e3500000 cmp r0, #0
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
3001101c: e92d4010 push {r4, lr}
if (sc == RTEMS_SUCCESSFUL) {
30011020: 08bd8010 popeq {r4, pc}
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
30011024: e350001c cmp r0, #28 <== NOT EXECUTED
eno = status_code_to_errno [sc];
30011028: 959f3014 ldrls r3, [pc, #20] ; 30011044 <rtems_deviceio_errno+0x2c><== NOT EXECUTED
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
3001102c: 83a04016 movhi r4, #22 <== NOT EXECUTED
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
30011030: 97934100 ldrls r4, [r3, r0, lsl #2] <== NOT EXECUTED
}
errno = eno;
30011034: eb000022 bl 300110c4 <__errno> <== NOT EXECUTED 30011038: e5804000 str r4, [r0] <== NOT EXECUTED
return -1;
3001103c: e3e00000 mvn r0, #0 <== NOT EXECUTED
} }
30011040: 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: eb002e21 bl 300161fc <__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: eb002e0f bl 300161d4 <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: e59660f8 ldr r6, [r6, #248] ; 0xf8
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: eb000a48 bl 3000b850 <_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
3000b33c <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000b33c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Extension_Control *the_extension;
if ( !id )
3000b340: e2527000 subs r7, r2, #0
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000b344: e1a05000 mov r5, r0 3000b348: e1a08001 mov r8, r1
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000b34c: 03a00009 moveq r0, #9
rtems_id *id
)
{
Extension_Control *the_extension;
if ( !id )
3000b350: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
3000b354: e3550000 cmp r5, #0
3000b358: 0a00001c beq 3000b3d0 <rtems_extension_create+0x94>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b35c: e59f3074 ldr r3, [pc, #116] ; 3000b3d8 <rtems_extension_create+0x9c> 3000b360: e5932000 ldr r2, [r3] 3000b364: e2822001 add r2, r2, #1 3000b368: 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 );
3000b36c: e59f6068 ldr r6, [pc, #104] ; 3000b3dc <rtems_extension_create+0xa0> 3000b370: e1a00006 mov r0, r6 3000b374: eb000386 bl 3000c194 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
3000b378: e2504000 subs r4, r0, #0
3000b37c: 1a000002 bne 3000b38c <rtems_extension_create+0x50>
_Thread_Enable_dispatch();
3000b380: eb0007e5 bl 3000d31c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000b384: e3a00005 mov r0, #5 <== NOT EXECUTED
3000b388: 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;
3000b38c: e284c024 add ip, r4, #36 ; 0x24
3000b390: e1a0e008 mov lr, r8
3000b394: e8be000f ldm lr!, {r0, r1, r2, r3}
3000b398: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000b39c: e89e000f ldm lr, {r0, r1, r2, r3}
3000b3a0: e88c000f stm ip, {r0, r1, r2, r3}
_User_extensions_Add_set( extension );
3000b3a4: e2840010 add r0, r4, #16 3000b3a8: eb000ac8 bl 3000ded0 <_User_extensions_Add_set>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b3ac: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000b3b0: e5943008 ldr r3, [r4, #8] 3000b3b4: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b3b8: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000b3bc: e584500c str r5, [r4, #12]
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
3000b3c0: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
3000b3c4: eb0007d4 bl 3000d31c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b3c8: e3a00000 mov r0, #0
3000b3cc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000b3d0: e3a00003 mov r0, #3 <== NOT EXECUTED
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000b3d4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000bda0 <rtems_extension_ident>:
rtems_status_code rtems_extension_ident(
rtems_name name,
rtems_id *id
)
{
3000bda0: e1a02000 mov r2, r0 <== NOT EXECUTED
3000bda4: e1a03001 mov r3, r1 <== NOT EXECUTED
3000bda8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
status = _Objects_Name_to_id_u32(
3000bdac: e1a01002 mov r1, r2 <== NOT EXECUTED 3000bdb0: e59f0010 ldr r0, [pc, #16] ; 3000bdc8 <rtems_extension_ident+0x28><== NOT EXECUTED 3000bdb4: e3e02102 mvn r2, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000bdb8: eb000498 bl 3000d020 <_Objects_Name_to_id_u32> <== NOT EXECUTED
OBJECTS_SEARCH_LOCAL_NODE,
id
);
return _Status_Object_name_errors_to_status[ status ];
}
3000bdbc: e59f3008 ldr r3, [pc, #8] ; 3000bdcc <rtems_extension_ident+0x2c><== NOT EXECUTED
3000bdc0: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
3000bdc4: 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: eb000eaa bl 30009b0c <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}
3000bd84 <rtems_get_version_string>:
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
}
3000bd84: e59f0000 ldr r0, [pc, #0] ; 3000bd8c <rtems_get_version_string+0x8><== NOT EXECUTED 3000bd88: 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: 1b0011c2 blne 3000b574 <_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: 1b0011a9 blne 3000b574 <_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: ea001332 b 3000fe50 <_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
30010d50 <rtems_io_close>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010d50: e59fc044 ldr ip, [pc, #68] ; 30010d9c <rtems_io_close+0x4c>
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010d54: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010d58: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010d5c: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010d60: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30010d64: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010d68: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
30010d6c: e59fc02c ldr ip, [pc, #44] ; 30010da0 <rtems_io_close+0x50> 30010d70: e3a04018 mov r4, #24 30010d74: e59cc000 ldr ip, [ip] 30010d78: e023c394 mla r3, r4, r3, ip 30010d7c: e5933008 ldr r3, [r3, #8]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010d80: e3530000 cmp r3, #0
30010d84: 0a000002 beq 30010d94 <rtems_io_close+0x44>
30010d88: e1a0e00f mov lr, pc
30010d8c: e12fff13 bx r3
30010d90: e8bd8010 pop {r4, pc}
30010d94: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010d98: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30010da4 <rtems_io_control>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010da4: e59fc044 ldr ip, [pc, #68] ; 30010df0 <rtems_io_control+0x4c>
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010da8: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010dac: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010db0: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010db4: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30010db8: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010dbc: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
30010dc0: e59fc02c ldr ip, [pc, #44] ; 30010df4 <rtems_io_control+0x50> 30010dc4: e3a04018 mov r4, #24 30010dc8: e59cc000 ldr ip, [ip] 30010dcc: e023c394 mla r3, r4, r3, ip 30010dd0: e5933014 ldr r3, [r3, #20]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010dd4: e3530000 cmp r3, #0
30010dd8: 0a000002 beq 30010de8 <rtems_io_control+0x44>
30010ddc: e1a0e00f mov lr, pc
30010de0: e12fff13 bx r3
30010de4: e8bd8010 pop {r4, pc}
30010de8: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010dec: 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: eb00303d bl 3001206c <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: eb003023 bl 3001206c <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
30010df8 <rtems_io_open>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010df8: e59fc044 ldr ip, [pc, #68] ; 30010e44 <rtems_io_open+0x4c>
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010dfc: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e00: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010e04: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e08: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30010e0c: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e10: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
30010e14: e59fc02c ldr ip, [pc, #44] ; 30010e48 <rtems_io_open+0x50> 30010e18: e3a04018 mov r4, #24 30010e1c: e59cc000 ldr ip, [ip] 30010e20: e023c394 mla r3, r4, r3, ip 30010e24: e5933004 ldr r3, [r3, #4]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010e28: e3530000 cmp r3, #0
30010e2c: 0a000002 beq 30010e3c <rtems_io_open+0x44>
30010e30: e1a0e00f mov lr, pc
30010e34: e12fff13 bx r3
30010e38: e8bd8010 pop {r4, pc}
30010e3c: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010e40: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30010e4c <rtems_io_read>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e4c: e59fc044 ldr ip, [pc, #68] ; 30010e98 <rtems_io_read+0x4c>
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010e50: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e54: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010e58: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e5c: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30010e60: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e64: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
30010e68: e59fc02c ldr ip, [pc, #44] ; 30010e9c <rtems_io_read+0x50> 30010e6c: e3a04018 mov r4, #24 30010e70: e59cc000 ldr ip, [ip] 30010e74: e023c394 mla r3, r4, r3, ip 30010e78: e593300c ldr r3, [r3, #12]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010e7c: e3530000 cmp r3, #0
30010e80: 0a000002 beq 30010e90 <rtems_io_read+0x44>
30010e84: e1a0e00f mov lr, pc
30010e88: e12fff13 bx r3
30010e8c: e8bd8010 pop {r4, pc}
30010e90: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010e94: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000af0c <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
)
{
3000af0c: e92d4010 push {r4, lr}
3000af10: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000af14: e59f0158 ldr r0, [pc, #344] ; 3000b074 <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;
3000af18: e59f3158 ldr r3, [pc, #344] ; 3000b078 <rtems_io_register_driver+0x16c>
if ( rtems_interrupt_is_in_progress() )
3000af1c: 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;
3000af20: e5933000 ldr r3, [r3]
if ( rtems_interrupt_is_in_progress() )
3000af24: e3500000 cmp r0, #0
return RTEMS_CALLED_FROM_ISR;
3000af28: 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() )
3000af2c: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
3000af30: e3520000 cmp r2, #0
3000af34: 0a000041 beq 3000b040 <rtems_io_register_driver+0x134>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
3000af38: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
3000af3c: e5823000 str r3, [r2]
if ( driver_table == NULL )
3000af40: 0a00003e beq 3000b040 <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;
3000af44: e5910000 ldr r0, [r1] 3000af48: e3500000 cmp r0, #0
3000af4c: 1a00003f bne 3000b050 <rtems_io_register_driver+0x144>
3000af50: e5910004 ldr r0, [r1, #4] 3000af54: e3500000 cmp r0, #0
3000af58: 1a00003c bne 3000b050 <rtems_io_register_driver+0x144>
3000af5c: ea000037 b 3000b040 <rtems_io_register_driver+0x134> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000af60: e59f3114 ldr r3, [pc, #276] ; 3000b07c <rtems_io_register_driver+0x170> 3000af64: e5930000 ldr r0, [r3] 3000af68: e2800001 add r0, r0, #1 3000af6c: e5830000 str r0, [r3]
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
3000af70: e3540000 cmp r4, #0 3000af74: e59f0104 ldr r0, [pc, #260] ; 3000b080 <rtems_io_register_driver+0x174>
3000af78: 1a000010 bne 3000afc0 <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;
3000af7c: e59f30f4 ldr r3, [pc, #244] ; 3000b078 <rtems_io_register_driver+0x16c> 3000af80: e593c000 ldr ip, [r3] 3000af84: e5903000 ldr r3, [r0] 3000af88: ea000006 b 3000afa8 <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;
3000af8c: e5930000 ldr r0, [r3] 3000af90: e3500000 cmp r0, #0
3000af94: 1a000030 bne 3000b05c <rtems_io_register_driver+0x150>
3000af98: e5930004 ldr r0, [r3, #4] 3000af9c: e3500000 cmp r0, #0
3000afa0: 1a00002d bne 3000b05c <rtems_io_register_driver+0x150>
3000afa4: ea000001 b 3000afb0 <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 ) {
3000afa8: e154000c cmp r4, ip
3000afac: 3afffff6 bcc 3000af8c <rtems_io_register_driver+0x80>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
3000afb0: e154000c cmp r4, ip
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
3000afb4: e5824000 str r4, [r2]
if ( m != n )
3000afb8: 1a000011 bne 3000b004 <rtems_io_register_driver+0xf8>
3000afbc: ea000029 b 3000b068 <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;
3000afc0: e3a03018 mov r3, #24 <== NOT EXECUTED 3000afc4: e0030394 mul r3, r4, r3 <== NOT EXECUTED 3000afc8: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000afcc: 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;
3000afd0: e7903003 ldr r3, [r0, r3] <== NOT EXECUTED 3000afd4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000afd8: 13a03000 movne r3, #0 <== NOT EXECUTED 3000afdc: 1a000002 bne 3000afec <rtems_io_register_driver+0xe0> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
}
rtems_status_code rtems_io_register_driver(
3000afe0: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 3000afe4: e2733001 rsbs r3, r3, #1 <== NOT EXECUTED 3000afe8: 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 ) ) {
3000afec: e3530000 cmp r3, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
3000aff0: 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 ) ) {
3000aff4: 1a000002 bne 3000b004 <rtems_io_register_driver+0xf8> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000aff8: eb00075b bl 3000cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
3000affc: e3a0000c mov r0, #12 <== NOT EXECUTED
3000b000: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
3000b004: e59f3074 ldr r3, [pc, #116] ; 3000b080 <rtems_io_register_driver+0x174>
3000b008: e3a0c018 mov ip, #24
3000b00c: e5933000 ldr r3, [r3]
3000b010: e1a0e001 mov lr, r1
3000b014: e02c3c94 mla ip, r4, ip, r3
3000b018: e8be000f ldm lr!, {r0, r1, r2, r3}
3000b01c: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000b020: e89e0003 ldm lr, {r0, r1}
3000b024: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
3000b028: eb00074f bl 3000cd6c <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
3000b02c: e3a01000 mov r1, #0 3000b030: e1a00004 mov r0, r4 3000b034: e1a02001 mov r2, r1
}
3000b038: e8bd4010 pop {r4, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
3000b03c: ea001f88 b 30012e64 <rtems_io_initialize>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
3000b040: e3a00009 mov r0, #9 <== NOT EXECUTED
3000b044: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
3000b048: e3a0000a mov r0, #10 <== NOT EXECUTED
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
3000b04c: 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 )
3000b050: e1540003 cmp r4, r3
3000b054: 3affffc1 bcc 3000af60 <rtems_io_register_driver+0x54>
3000b058: eafffffa b 3000b048 <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 ) {
3000b05c: e2844001 add r4, r4, #1 3000b060: e2833018 add r3, r3, #24 3000b064: eaffffcf b 3000afa8 <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();
3000b068: eb00073f bl 3000cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
3000b06c: 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;
3000b070: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b084 <rtems_io_unregister_driver>:
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000b084: e59f305c ldr r3, [pc, #92] ; 3000b0e8 <rtems_io_unregister_driver+0x64>
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
3000b088: e92d4010 push {r4, lr}
if ( rtems_interrupt_is_in_progress() )
3000b08c: e5934000 ldr r4, [r3] 3000b090: e3540000 cmp r4, #0
return RTEMS_CALLED_FROM_ISR;
3000b094: 13a00012 movne r0, #18
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000b098: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
3000b09c: e59f3048 ldr r3, [pc, #72] ; 3000b0ec <rtems_io_unregister_driver+0x68> 3000b0a0: e5933000 ldr r3, [r3] 3000b0a4: e1500003 cmp r0, r3
3000b0a8: 2a00000c bcs 3000b0e0 <rtems_io_unregister_driver+0x5c>
3000b0ac: e59f303c ldr r3, [pc, #60] ; 3000b0f0 <rtems_io_unregister_driver+0x6c> 3000b0b0: e5932000 ldr r2, [r3] 3000b0b4: e2822001 add r2, r2, #1 3000b0b8: e5832000 str r2, [r3]
_Thread_Disable_dispatch();
memset(
3000b0bc: e59f3030 ldr r3, [pc, #48] ; 3000b0f4 <rtems_io_unregister_driver+0x70>
&_IO_Driver_address_table[major],
3000b0c0: 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(
3000b0c4: e5933000 ldr r3, [r3] 3000b0c8: e1a01004 mov r1, r4 3000b0cc: e0203092 mla r0, r2, r0, r3 3000b0d0: eb002a7a bl 30015ac0 <memset>
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
3000b0d4: eb000724 bl 3000cd6c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b0d8: e1a00004 mov r0, r4
3000b0dc: e8bd8010 pop {r4, pc}
}
return RTEMS_UNSATISFIED;
3000b0e0: e3a0000d mov r0, #13 <== NOT EXECUTED
}
3000b0e4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30010ea0 <rtems_io_write>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010ea0: e59fc044 ldr ip, [pc, #68] ; 30010eec <rtems_io_write+0x4c>
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010ea4: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010ea8: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010eac: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010eb0: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30010eb4: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010eb8: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
30010ebc: e59fc02c ldr ip, [pc, #44] ; 30010ef0 <rtems_io_write+0x50> 30010ec0: e3a04018 mov r4, #24 30010ec4: e59cc000 ldr ip, [ip] 30010ec8: e023c394 mla r3, r4, r3, ip 30010ecc: e5933010 ldr r3, [r3, #16]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010ed0: e3530000 cmp r3, #0
30010ed4: 0a000002 beq 30010ee4 <rtems_io_write+0x44>
30010ed8: e1a0e00f mov lr, pc
30010edc: e12fff13 bx r3
30010ee0: e8bd8010 pop {r4, pc}
30010ee4: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010ee8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c134 <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)
{
3000c134: 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 )
3000c138: e2508000 subs r8, r0, #0 <== NOT EXECUTED
3000c13c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c140: e59f4048 ldr r4, [pc, #72] ; 3000c190 <rtems_iterate_over_all_threads+0x5c><== NOT EXECUTED
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
3000c144: e284700c add r7, r4, #12 <== NOT EXECUTED
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
3000c148: e5b43004 ldr r3, [r4, #4]! <== NOT EXECUTED 3000c14c: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED
if ( !information )
3000c150: e3560000 cmp r6, #0 <== NOT EXECUTED 3000c154: 13a05001 movne r5, #1 <== NOT EXECUTED 3000c158: 1a000006 bne 3000c178 <rtems_iterate_over_all_threads+0x44><== NOT EXECUTED 3000c15c: ea000008 b 3000c184 <rtems_iterate_over_all_threads+0x50> <== NOT EXECUTED
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
3000c160: e596301c ldr r3, [r6, #28] <== NOT EXECUTED 3000c164: e7930105 ldr r0, [r3, r5, lsl #2] <== NOT EXECUTED
if ( !the_thread )
3000c168: e3500000 cmp r0, #0 <== NOT EXECUTED
continue;
(*routine)(the_thread);
3000c16c: 11a0e00f movne lr, pc <== NOT EXECUTED 3000c170: 112fff18 bxne r8 <== NOT EXECUTED
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000c174: e2855001 add r5, r5, #1 <== NOT EXECUTED 3000c178: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED 3000c17c: e1550003 cmp r5, r3 <== NOT EXECUTED 3000c180: 9afffff6 bls 3000c160 <rtems_iterate_over_all_threads+0x2c><== NOT EXECUTED
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
3000c184: e1540007 cmp r4, r7 <== NOT EXECUTED
3000c188: 1affffee bne 3000c148 <rtems_iterate_over_all_threads+0x14><== NOT EXECUTED
3000c18c: 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: eb000db0 bl 30009b0c <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: eb002a4d bl 30012210 <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
3000dcb0 <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
3000dcb0: e2003006 and r3, r0, #6 3000dcb4: e3530006 cmp r3, #6
fcntl_flags |= O_RDWR;
3000dcb8: 03a03002 moveq r3, #2
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
3000dcbc: 0a000005 beq 3000dcd8 <rtems_libio_to_fcntl_flags+0x28>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
3000dcc0: e3100002 tst r0, #2
fcntl_flags |= O_RDONLY;
3000dcc4: 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) {
3000dcc8: 1a000002 bne 3000dcd8 <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;
3000dccc: e3100004 tst r0, #4 <== NOT EXECUTED 3000dcd0: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000dcd4: 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 ) {
3000dcd8: e3100001 tst r0, #1
fcntl_flags |= O_NONBLOCK;
3000dcdc: 13833901 orrne r3, r3, #16384 ; 0x4000
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
3000dce0: e3100c02 tst r0, #512 ; 0x200
fcntl_flags |= O_APPEND;
3000dce4: 13833008 orrne r3, r3, #8
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
3000dce8: e3100b01 tst r0, #1024 ; 0x400
fcntl_flags |= O_CREAT;
3000dcec: 13833c02 orrne r3, r3, #512 ; 0x200
}
return fcntl_flags;
}
3000dcf0: e1a00003 mov r0, r3 3000dcf4: 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: eb00169b bl 3000ff20 <_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
30011e5c <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
30011e5c: e92d4070 push {r4, r5, r6, lr}
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
30011e60: e2504000 subs r4, r0, #0
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
30011e64: e1a05001 mov r5, r1 30011e68: e1a06002 mov r6, r2
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
30011e6c: 0a00001a beq 30011edc <rtems_memalign+0x80>
return EINVAL;
*pointer = NULL;
30011e70: e3a03000 mov r3, #0 30011e74: e5843000 str r3, [r4]
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30011e78: e59f306c ldr r3, [pc, #108] ; 30011eec <rtems_memalign+0x90> 30011e7c: e5933000 ldr r3, [r3] 30011e80: e3530003 cmp r3, #3
30011e84: 1a000002 bne 30011e94 <rtems_memalign+0x38>
!malloc_is_system_state_OK() )
30011e88: ebffd5ba 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()) &&
30011e8c: e3500000 cmp r0, #0
30011e90: 0a000011 beq 30011edc <rtems_memalign+0x80>
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
30011e94: ebffd5cb bl 300075c8 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
30011e98: e59f3050 ldr r3, [pc, #80] ; 30011ef0 <rtems_memalign+0x94> 30011e9c: e1a02005 mov r2, r5 30011ea0: e5930000 ldr r0, [r3] 30011ea4: e1a01006 mov r1, r6 30011ea8: e3a03000 mov r3, #0 30011eac: ebffe90a bl 3000c2dc <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
30011eb0: e2505000 subs r5, r0, #0
30011eb4: 0a00000a beq 30011ee4 <rtems_memalign+0x88>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
30011eb8: e59f3034 ldr r3, [pc, #52] ; 30011ef4 <rtems_memalign+0x98> 30011ebc: e5933000 ldr r3, [r3] 30011ec0: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
30011ec4: 11a00004 movne r0, r4 30011ec8: 11a0e00f movne lr, pc 30011ecc: 1593f004 ldrne pc, [r3, #4]
*pointer = return_this;
30011ed0: e5845000 str r5, [r4]
return 0;
30011ed4: e3a00000 mov r0, #0
30011ed8: 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;
30011edc: e3a00016 mov r0, #22 <== NOT EXECUTED
30011ee0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
30011ee4: e3a0000c mov r0, #12 <== NOT EXECUTED
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
30011ee8: 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: eb001416 bl 3001ae18 <_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: eb000d13 bl 30019238 <_CORE_message_queue_Broadcast> 30015de8: e1a04000 mov r4, r0
NULL,
#endif
count
);
_Thread_Enable_dispatch();
30015dec: eb00172f bl 3001bab0 <_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: eb001851 bl 300171c8 <_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: eb000bc8 bl 30013fb0 <_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: eb00045d bl 30012234 <_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: eb000816 bl 3001312c <_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: eb000bb6 bl 30013fb0 <_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: eb000bac bl 30013fb0 <_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: eb001395 bl 3001ae18 <_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: eb0016b4 bl 3001bab0 <_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: eb000843 bl 30013280 <_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: eb000451 bl 300122f4 <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
300111ac: eb000b7f bl 30013fb0 <_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}
300097a0 <rtems_object_api_maximum_class>:
int rtems_object_api_maximum_class(
int api
)
{
return _Objects_API_maximum_class(api);
300097a0: ea00057a b 3000ad90 <_Objects_API_maximum_class> <== NOT EXECUTED
300097a4 <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 )
300097a4: e2400001 sub r0, r0, #1 <== NOT EXECUTED
uint32_t api
)
{
if ( _Objects_Is_api_valid( api ) )
return 1;
return -1;
300097a8: e3500003 cmp r0, #3 <== NOT EXECUTED
}
300097ac: 33a00001 movcc r0, #1 <== NOT EXECUTED 300097b0: 23e00000 mvncs r0, #0 <== NOT EXECUTED 300097b4: e12fff1e bx lr <== NOT EXECUTED
300097b8 <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
300097b8: e3500001 cmp r0, #1 <== NOT EXECUTED
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
300097bc: 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 )
300097c0: 0a000005 beq 300097dc <rtems_object_get_api_class_name+0x24><== NOT EXECUTED
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
300097c4: e3500002 cmp r0, #2 <== NOT EXECUTED 300097c8: 0a000005 beq 300097e4 <rtems_object_get_api_class_name+0x2c><== NOT EXECUTED
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
300097cc: e3500003 cmp r0, #3 <== NOT EXECUTED
api_assoc = rtems_object_api_posix_assoc;
300097d0: 059f0034 ldreq r0, [pc, #52] ; 3000980c <rtems_object_get_api_class_name+0x54><== NOT EXECUTED
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
300097d4: 1a000008 bne 300097fc <rtems_object_get_api_class_name+0x44><== NOT EXECUTED 300097d8: ea000002 b 300097e8 <rtems_object_get_api_class_name+0x30> <== 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;
300097dc: e59f002c ldr r0, [pc, #44] ; 30009810 <rtems_object_get_api_class_name+0x58><== NOT EXECUTED 300097e0: ea000000 b 300097e8 <rtems_object_get_api_class_name+0x30> <== NOT EXECUTED
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
300097e4: e59f0028 ldr r0, [pc, #40] ; 30009814 <rtems_object_get_api_class_name+0x5c><== 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 );
300097e8: eb00128c bl 3000e220 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( class_assoc )
300097ec: e3500000 cmp r0, #0 <== NOT EXECUTED
return class_assoc->name;
300097f0: 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 )
300097f4: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
300097f8: ea000001 b 30009804 <rtems_object_get_api_class_name+0x4c> <== 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";
300097fc: e59f0014 ldr r0, [pc, #20] ; 30009818 <rtems_object_get_api_class_name+0x60><== NOT EXECUTED
30009800: 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";
30009804: e59f0010 ldr r0, [pc, #16] ; 3000981c <rtems_object_get_api_class_name+0x64><== NOT EXECUTED
}
30009808: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009820 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
30009820: e1a01000 mov r1, r0 <== NOT EXECUTED
30009824: 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 );
30009828: e59f0010 ldr r0, [pc, #16] ; 30009840 <rtems_object_get_api_name+0x20><== NOT EXECUTED 3000982c: eb00127b bl 3000e220 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( api_assoc )
30009830: e3500000 cmp r0, #0 <== NOT EXECUTED
return api_assoc->name;
30009834: 15900000 ldrne r0, [r0] <== NOT EXECUTED
return "BAD CLASS";
30009838: 059f0004 ldreq r0, [pc, #4] ; 30009844 <rtems_object_get_api_name+0x24><== NOT EXECUTED
}
3000983c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b30c <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
)
{
3000b30c: e92d4010 push {r4, lr} <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000b310: e2524000 subs r4, r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000b314: 03a00009 moveq r0, #9 <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000b318: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
3000b31c: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000b320: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3000b324: eb000693 bl 3000cd78 <_Objects_Get_information> <== NOT EXECUTED
if ( !obj_info )
3000b328: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b32c: 0a000014 beq 3000b384 <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;
3000b330: 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;
3000b334: 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;
3000b338: e5843000 str r3, [r4] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id;
3000b33c: 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++ )
3000b340: 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;
3000b344: e5843004 str r3, [r4, #4] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
3000b348: e5d03012 ldrb r3, [r0, #18] <== NOT EXECUTED
info->maximum = obj_info->maximum;
3000b34c: 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;
3000b350: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000b354: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b358: ea000004 b 3000b370 <rtems_object_get_class_information+0x64><== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000b35c: e590c01c ldr ip, [r0, #28] <== NOT EXECUTED 3000b360: 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++ )
3000b364: e2833001 add r3, r3, #1 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000b368: e35c0000 cmp ip, #0 <== NOT EXECUTED
unallocated++;
3000b36c: 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++ )
3000b370: e1530001 cmp r3, r1 <== NOT EXECUTED 3000b374: 9afffff8 bls 3000b35c <rtems_object_get_class_information+0x50><== NOT EXECUTED
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
3000b378: e5842010 str r2, [r4, #16] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b37c: e3a00000 mov r0, #0 <== NOT EXECUTED
3000b380: 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;
3000b384: e3a0000a mov r0, #10 <== NOT EXECUTED
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
3000b388: 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: eb0006bc bl 3000c118 <_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
3000a8ec <rtems_object_get_name>:
Objects_Id id,
size_t length,
char *name
)
{
return _Objects_Get_name_as_string( id, length, name );
3000a8ec: ea000744 b 3000c604 <_Objects_Get_name_as_string> <== NOT EXECUTED
3000b390 <rtems_object_id_api_maximum>:
#undef rtems_object_id_api_maximum
int rtems_object_id_api_maximum(void)
{
return OBJECTS_APIS_LAST;
}
3000b390: e3a00003 mov r0, #3 <== NOT EXECUTED 3000b394: e12fff1e bx lr <== NOT EXECUTED
3000b398 <rtems_object_id_api_minimum>:
#undef rtems_object_id_api_minimum
int rtems_object_id_api_minimum(void)
{
return OBJECTS_INTERNAL_API;
}
3000b398: e3a00001 mov r0, #1 <== NOT EXECUTED 3000b39c: e12fff1e bx lr <== NOT EXECUTED
3000b3a0 <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);
3000b3a0: e1a00c20 lsr r0, r0, #24 <== NOT EXECUTED
int rtems_object_id_get_api(
rtems_id id
)
{
return _Objects_Get_API( id );
}
3000b3a4: e2000007 and r0, r0, #7 <== NOT EXECUTED 3000b3a8: e12fff1e bx lr <== NOT EXECUTED
3000b3ac <rtems_object_id_get_class>:
int rtems_object_id_get_class(
rtems_id id
)
{
return _Objects_Get_class( id );
}
3000b3ac: e1a00da0 lsr r0, r0, #27 <== NOT EXECUTED 3000b3b0: e12fff1e bx lr <== NOT EXECUTED
3000b3b4 <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 );
3000b3b4: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
}
3000b3b8: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 3000b3bc: e12fff1e bx lr <== NOT EXECUTED
3000b3c0 <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;
3000b3c0: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED
int rtems_object_id_get_node(
rtems_id id
)
{
return _Objects_Get_node( id );
}
3000b3c4: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 3000b3c8: e12fff1e bx lr <== NOT EXECUTED
3000984c <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
3000984c: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
30009850: e2515000 subs r5, r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30009854: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
30009858: 0a000016 beq 300098b8 <rtems_object_set_name+0x6c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000985c: e3500000 cmp r0, #0 <== NOT EXECUTED 30009860: 059f3054 ldreq r3, [pc, #84] ; 300098bc <rtems_object_set_name+0x70><== NOT EXECUTED 30009864: 11a04000 movne r4, r0 <== NOT EXECUTED 30009868: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000986c: 05934008 ldreq r4, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
30009870: e1a00004 mov r0, r4 <== NOT EXECUTED 30009874: eb00060e bl 3000b0b4 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
30009878: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000987c: 0a00000c beq 300098b4 <rtems_object_set_name+0x68> <== NOT EXECUTED
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
30009880: e1a01004 mov r1, r4 <== NOT EXECUTED 30009884: e1a0200d mov r2, sp <== NOT EXECUTED 30009888: eb000683 bl 3000b29c <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3000988c: 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 );
30009890: e1a01000 mov r1, r0 <== NOT EXECUTED
switch ( location ) {
30009894: e3540000 cmp r4, #0 <== NOT EXECUTED 30009898: 1a000005 bne 300098b4 <rtems_object_set_name+0x68> <== NOT EXECUTED
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
3000989c: e1a02005 mov r2, r5 <== NOT EXECUTED 300098a0: e1a00006 mov r0, r6 <== NOT EXECUTED 300098a4: eb0006d5 bl 3000b400 <_Objects_Set_name> <== NOT EXECUTED
_Thread_Enable_dispatch();
300098a8: eb0009ae bl 3000bf68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300098ac: e1a00004 mov r0, r4 <== NOT EXECUTED 300098b0: ea000000 b 300098b8 <rtems_object_set_name+0x6c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300098b4: e3a00004 mov r0, #4 <== NOT EXECUTED
}
300098b8: 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: eb002e09 bl 300161fc <__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: eb0011cf bl 3001a968 <_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: eb00161e bl 3001bab0 <_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: eb006187 bl 3002e880 <__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: eb000bdf bl 300191f8 <_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: eb001605 bl 3001bab0 <_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: eb0012d0 bl 3001ae18 <_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: eb0011bb bl 3001a9f0 <_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: eb00125d bl 3001ac84 <_Objects_Free>
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
3001630c: eb0015e7 bl 3001bab0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30016310: e1a00005 mov r0, r5 30016314: ea000001 b 30016320 <rtems_partition_delete+0x60>
}
_Thread_Enable_dispatch();
30016318: eb0015e4 bl 3001bab0 <_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: eb00128a bl 3001ae18 <_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: eb0061aa bl 3002eae0 <__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: eb000b4b bl 30019178 <_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: eb001595 bl 3001bab0 <_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: eb001592 bl 3001bab0 <_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: eb00143c bl 3001a968 <_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: eb00188b bl 3001bab0 <_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: eb00187e bl 3001bab0 <_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: eb001264 bl 3001ae18 <_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: eb00157f bl 3001bab0 <_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: eb0019dc bl 3001cc34 <_Watchdog_Remove>
the_period->state = RATE_MONOTONIC_INACTIVE;
300164c0: e5854038 str r4, [r5, #56] ; 0x38
_Thread_Enable_dispatch();
300164c4: eb001579 bl 3001bab0 <_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: eb0007a8 bl 3000c118 <_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: eb000c29 bl 3000d328 <_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: eb002510 bl 30013700 <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: eb000c0e bl 3000d328 <_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
3001071c <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
3001071c: 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 )
30010720: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
30010724: 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;
30010728: 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 )
3001072c: 0a000025 beq 300107c8 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED 30010730: e59f0094 ldr r0, [pc, #148] ; 300107cc <rtems_rate_monotonic_get_statistics+0xb0><== NOT EXECUTED 30010734: e1a01003 mov r1, r3 <== NOT EXECUTED 30010738: e1a0200d mov r2, sp <== NOT EXECUTED 3001073c: ebffefd3 bl 3000c690 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30010740: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30010744: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30010748: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3001074c: 1a00001d bne 300107c8 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
30010750: e5903054 ldr r3, [r0, #84] ; 0x54 <== NOT EXECUTED 30010754: e5843000 str r3, [r4] <== NOT EXECUTED
dst->missed_count = src->missed_count;
30010758: e5903058 ldr r3, [r0, #88] ; 0x58 <== NOT EXECUTED 3001075c: e5843004 str r3, [r4, #4] <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
30010760: e280305c add r3, r0, #92 ; 0x5c <== NOT EXECUTED
30010764: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30010768: e5842008 str r2, [r4, #8] <== NOT EXECUTED
3001076c: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
30010770: e2803064 add r3, r0, #100 ; 0x64 <== NOT EXECUTED
30010774: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30010778: e5842010 str r2, [r4, #16] <== NOT EXECUTED
3001077c: e5843014 str r3, [r4, #20] <== NOT EXECUTED
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
30010780: e280306c add r3, r0, #108 ; 0x6c <== NOT EXECUTED
30010784: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30010788: e5842018 str r2, [r4, #24] <== NOT EXECUTED
3001078c: e584301c str r3, [r4, #28] <== NOT EXECUTED
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
30010790: e2803074 add r3, r0, #116 ; 0x74 <== NOT EXECUTED
30010794: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30010798: e5842020 str r2, [r4, #32] <== NOT EXECUTED
3001079c: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
300107a0: e280307c add r3, r0, #124 ; 0x7c <== NOT EXECUTED
300107a4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
300107a8: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED
300107ac: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
300107b0: e2803084 add r3, r0, #132 ; 0x84 <== NOT EXECUTED
300107b4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
300107b8: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED
300107bc: 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();
300107c0: ebfff2d8 bl 3000d328 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300107c4: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300107c8: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
300107d0 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
300107d0: 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 )
300107d4: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
300107d8: e1a03000 mov r3, r0 <== NOT EXECUTED 300107dc: 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;
300107e0: 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 )
300107e4: 0a000023 beq 30010878 <rtems_rate_monotonic_get_status+0xa8><== NOT EXECUTED 300107e8: e1a01003 mov r1, r3 <== NOT EXECUTED 300107ec: e28d2010 add r2, sp, #16 <== NOT EXECUTED 300107f0: e59f0088 ldr r0, [pc, #136] ; 30010880 <rtems_rate_monotonic_get_status+0xb0><== NOT EXECUTED 300107f4: ebffefa5 bl 3000c690 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300107f8: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 300107fc: e1a03000 mov r3, r0 <== NOT EXECUTED 30010800: e3520000 cmp r2, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30010804: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !status )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30010808: 1a00001a bne 30010878 <rtems_rate_monotonic_get_status+0xa8><== NOT EXECUTED
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
3001080c: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED
status->state = the_period->state;
30010810: 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;
30010814: 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 ) {
30010818: 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;
3001081c: 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 );
30010820: 05843008 streq r3, [r4, #8] <== NOT EXECUTED 30010824: 0584300c streq r3, [r4, #12] <== NOT EXECUTED
_Timespec_Set_to_zero( &status->executed_since_last_period );
30010828: 05843010 streq r3, [r4, #16] <== NOT EXECUTED 3001082c: 05843014 streq r3, [r4, #20] <== NOT EXECUTED 30010830: 0a00000e beq 30010870 <rtems_rate_monotonic_get_status+0xa0><== NOT EXECUTED
} else {
/*
* Grab the current status.
*/
valid_status =
30010834: e1a0100d mov r1, sp <== NOT EXECUTED 30010838: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3001083c: ebffe6bd bl 3000a338 <_Rate_monotonic_Get_status> <== NOT EXECUTED
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
30010840: e3500000 cmp r0, #0 <== NOT EXECUTED 30010844: 1a000002 bne 30010854 <rtems_rate_monotonic_get_status+0x84><== NOT EXECUTED
_Thread_Enable_dispatch();
30010848: ebfff2b6 bl 3000d328 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
3001084c: e3a0000b mov r0, #11 <== NOT EXECUTED 30010850: ea000008 b 30010878 <rtems_rate_monotonic_get_status+0xa8> <== NOT EXECUTED
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
30010854: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
30010858: e5842008 str r2, [r4, #8] <== NOT EXECUTED
3001085c: e584300c str r3, [r4, #12] <== NOT EXECUTED
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
30010860: e28d3008 add r3, sp, #8 <== NOT EXECUTED
30010864: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30010868: e5842010 str r2, [r4, #16] <== NOT EXECUTED
3001086c: e5843014 str r3, [r4, #20] <== NOT EXECUTED
status->since_last_period = since_last_period;
status->executed_since_last_period = executed;
#endif
}
_Thread_Enable_dispatch();
30010870: ebfff2ac bl 3000d328 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30010874: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30010878: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3001087c: 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: eb00084d bl 3000c690 <_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: eb000b69 bl 3000d328 <_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: eb000b60 bl 3000d328 <_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: eb000ef2 bl 3000e1c8 <_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: eb000b48 bl 3000d328 <_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: eb000d49 bl 3000db64 <_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: 0b000a69 bleq 3000d014 <_Thread_Clear_state>
_Thread_Enable_dispatch();
3000a66c: eb000b2d bl 3000d328 <_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: eb000ec8 bl 3000e1c8 <_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: eb000b1e bl 3000d328 <_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: eb0017ed bl 3001071c <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: eb001815 bl 300107d0 <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: eb000d8a bl 3000de08 <_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: eb0045b0 bl 3001beac <__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: eb0045aa bl 3001beac <__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: eb0045a4 bl 3001beac <__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: eb000d70 bl 3000de08 <_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: eb004596 bl 3001beac <__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: eb004590 bl 3001beac <__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: eb00458a bl 3001beac <__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: ea000a7e b 3000d328 <_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: eb000751 bl 3000c690 <_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: eb002364 bl 30013700 <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: eb000a68 bl 3000d328 <_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: eb00092f bl 300190e0 <_API_Mutex_Lock> 30016c20: e1a00005 mov r0, r5 30016c24: eb000f4f bl 3001a968 <_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: eb000e2a bl 3001a4f4 <_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: eb001008 bl 3001ac84 <_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: eb00154d bl 3001c1d4 <_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: eb000920 bl 30019144 <_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: eb0008d9 bl 300190e0 <_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: eb001013 bl 3001add8 <_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: eb000c0d bl 30019de8 <_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: eb0008d7 bl 30019144 <_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: eb0008b2 bl 300190e0 <_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: eb000fec bl 3001add8 <_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: eb000d14 bl 3001a2a0 <_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: eb0008ba bl 30019144 <_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: eb000895 bl 300190e0 <_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: eb000fcf bl 3001add8 <_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: 0b000d10 bleq 3001a2f4 <_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: eb0008a1 bl 30019144 <_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: eb00082f bl 300190e0 <_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: eb000f69 bl 3001add8 <_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: eb000e06 bl 3001a874 <_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: eb000834 bl 30019144 <_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: eb0007ff bl 300190e0 <_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: eb000f39 bl 3001add8 <_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: eb000d88 bl 3001a740 <_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: eb001fd5 bl 3001f08c <_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: eb0007ff bl 30019144 <_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: eb0007f9 bl 30019144 <_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: eb0007d5 bl 300190e0 <_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: eb000f0f bl 3001add8 <_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: eb000bbd bl 3001a0b0 <_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: eb001fac bl 3001f08c <_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: eb0007d6 bl 30019144 <_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: eb00051b bl 3000a748 <_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: eb00095a bl 3000b850 <_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: eb000393 bl 3000a180 <_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: 13a03002 movne r3, #2 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: eb0002b7 bl 30009e88 <_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: e3500006 cmp r0, #6
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: eb0005a9 bl 3000aa64 <_Objects_Free>
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
300093bc: eb000923 bl 3000b850 <_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: eb000919 bl 3000b850 <_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: eb0005e7 bl 3000abb8 <_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: eb0008ff bl 3000b850 <_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: e3a02004 mov r2, #4 30009464: eb000286 bl 30009e84 <_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: eb000340 bl 3000a17c <_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: eb0004d2 bl 3000a7d0 <_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: eb000574 bl 3000aa64 <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
30009490: eb0008ee bl 3000b850 <_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}
30012978 <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
30012978: e92d4001 push {r0, lr}
3001297c: e1a01000 mov r1, r0
30012980: e1a0200d mov r2, sp
30012984: e59f0044 ldr r0, [pc, #68] ; 300129d0 <rtems_semaphore_flush+0x58>
30012988: ebffe5cd bl 3000c0c4 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
3001298c: e59d3000 ldr r3, [sp] 30012990: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30012994: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30012998: 1a00000b bne 300129cc <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);
3001299c: e5901010 ldr r1, [r0, #16] 300129a0: e2800014 add r0, r0, #20
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
300129a4: e2111030 ands r1, r1, #48 ; 0x30
300129a8: 0a000003 beq 300129bc <rtems_semaphore_flush+0x44>
_CORE_mutex_Flush(
300129ac: e1a01003 mov r1, r3 300129b0: e3a02001 mov r2, #1 300129b4: ebffe275 bl 3000b390 <_CORE_mutex_Flush> 300129b8: ea000001 b 300129c4 <rtems_semaphore_flush+0x4c>
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
300129bc: e3a02001 mov r2, #1 <== NOT EXECUTED 300129c0: ebffe330 bl 3000b688 <_CORE_semaphore_Flush> <== NOT EXECUTED
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
300129c4: ebffe8e8 bl 3000cd6c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300129c8: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300129cc: 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: eb0005a2 bl 3000ab50 <_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: eb0002a7 bl 30009fa4 <_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: eb0009d4 bl 3000bce4 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
30009590: eb0008ae bl 3000b850 <_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}
30016ae8 <rtems_shutdown_executive>:
void rtems_shutdown_executive(
uint32_t result
)
{
if ( _System_state_Is_up( _System_state_Get() ) ) {
30016ae8: e59f3028 ldr r3, [pc, #40] ; 30016b18 <rtems_shutdown_executive+0x30>
*/
void rtems_shutdown_executive(
uint32_t result
)
{
30016aec: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( _System_state_Is_up( _System_state_Get() ) ) {
30016af0: e5932000 ldr r2, [r3] 30016af4: e3520003 cmp r2, #3 30016af8: 02822001 addeq r2, r2, #1 30016afc: 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 );
30016b00: 059f0014 ldreq r0, [pc, #20] ; 30016b1c <rtems_shutdown_executive+0x34> 30016b04: 0bffd864 bleq 3000cc9c <_CPU_Context_restore>
_System_state_Set( SYSTEM_STATE_SHUTDOWN );
_Thread_Stop_multitasking();
}
_Internal_error_Occurred(
30016b08: e3a00000 mov r0, #0 <== NOT EXECUTED 30016b0c: e3a01001 mov r1, #1 <== NOT EXECUTED 30016b10: e3a02014 mov r2, #20 <== NOT EXECUTED 30016b14: ebffcef4 bl 3000a6ec <_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: eb00110d bl 3001bad4 <_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: e59030f8 ldr r3, [r0, #248] ; 0xf8
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: eb0010e1 bl 3001bab0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30017728: e3a00000 mov r0, #0 3001772c: ea000001 b 30017738 <rtems_signal_send+0xb4>
}
_Thread_Enable_dispatch();
30017730: eb0010de bl 3001bab0 <_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}
30006494 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
30006494: e92d4810 push {r4, fp, lr}
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
30006498: e59f3078 ldr r3, [pc, #120] ; 30006518 <rtems_stack_checker_is_blown+0x84>
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
3000649c: e28db008 add fp, sp, #8
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
300064a0: e5933004 ldr r3, [r3, #4]
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
300064a4: e59300bc ldr r0, [r3, #188] ; 0xbc 300064a8: e15b0000 cmp fp, r0
return false;
300064ac: 33a04000 movcc r4, #0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
300064b0: 3a000004 bcc 300064c8 <rtems_stack_checker_is_blown+0x34>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
300064b4: e59340b8 ldr r4, [r3, #184] ; 0xb8 300064b8: e0804004 add r4, r0, r4
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
300064bc: e15b0004 cmp fp, r4 300064c0: 83a04000 movhi r4, #0 300064c4: 93a04001 movls r4, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
300064c8: e59f304c ldr r3, [pc, #76] ; 3000651c <rtems_stack_checker_is_blown+0x88> 300064cc: e5933008 ldr r3, [r3, #8] 300064d0: 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;
300064d4: 03a01001 moveq r1, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
300064d8: 0a000005 beq 300064f4 <rtems_stack_checker_is_blown+0x60>
pattern_ok = (!memcmp(
300064dc: e59f103c ldr r1, [pc, #60] ; 30006520 <rtems_stack_checker_is_blown+0x8c> 300064e0: e2800008 add r0, r0, #8 300064e4: e3a02010 mov r2, #16 300064e8: eb003772 bl 300142b8 <memcmp> 300064ec: e2701001 rsbs r1, r0, #1 300064f0: 33a01000 movcc r1, #0
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
300064f4: e3540000 cmp r4, #0
300064f8: 0a000001 beq 30006504 <rtems_stack_checker_is_blown+0x70>
300064fc: e3510000 cmp r1, #0
30006500: 1a000002 bne 30006510 <rtems_stack_checker_is_blown+0x7c>
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
30006504: e59f300c ldr r3, [pc, #12] ; 30006518 <rtems_stack_checker_is_blown+0x84><== NOT EXECUTED 30006508: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 3000650c: ebffff9d bl 30006388 <Stack_check_report_blown_task> <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
30006510: e3a00000 mov r0, #0
30006514: e8bd8810 pop {r4, fp, pc}
30006584 <rtems_stack_checker_report_usage>:
}
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
30006584: e59f1004 ldr r1, [pc, #4] ; 30006590 <rtems_stack_checker_report_usage+0xc><== NOT EXECUTED 30006588: e3a00000 mov r0, #0 <== NOT EXECUTED 3000658c: eaffffe4 b 30006524 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
30006524 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30006524: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if ( !print )
30006528: e2515000 subs r5, r1, #0 <== NOT EXECUTED
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000652c: e1a06000 mov r6, r0 <== NOT EXECUTED
if ( !print )
30006530: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return;
print_context = context;
30006534: e59f4038 ldr r4, [pc, #56] ; 30006574 <rtems_stack_checker_report_usage_with_plugin+0x50><== NOT EXECUTED
print_handler = print;
(*print)( context, "Stack usage by thread\n");
30006538: e59f1038 ldr r1, [pc, #56] ; 30006578 <rtems_stack_checker_report_usage_with_plugin+0x54><== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
3000653c: e5840004 str r0, [r4, #4] <== NOT EXECUTED
print_handler = print;
30006540: e5845000 str r5, [r4] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
30006544: e1a0e00f mov lr, pc <== NOT EXECUTED 30006548: e12fff15 bx r5 <== NOT EXECUTED
(*print)( context,
3000654c: e59f1028 ldr r1, [pc, #40] ; 3000657c <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED 30006550: e1a00006 mov r0, r6 <== NOT EXECUTED 30006554: e1a0e00f mov lr, pc <== NOT EXECUTED 30006558: 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 );
3000655c: e59f001c ldr r0, [pc, #28] ; 30006580 <rtems_stack_checker_report_usage_with_plugin+0x5c><== NOT EXECUTED 30006560: eb001a94 bl 3000cfb8 <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;
30006564: e3a03000 mov r3, #0 <== NOT EXECUTED 30006568: e5843004 str r3, [r4, #4] <== NOT EXECUTED
print_handler = NULL;
3000656c: e5843000 str r3, [r4] <== NOT EXECUTED
30006570: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30006430 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30006430: 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);
30006434: e59030bc ldr r3, [r0, #188] ; 0xbc <== NOT EXECUTED
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30006438: e28db00c add fp, sp, #12 <== NOT EXECUTED
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
3000643c: e15b0003 cmp fp, r3 <== NOT EXECUTED
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30006440: e1a04000 mov r4, r0 <== NOT EXECUTED
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
30006444: 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);
30006448: e2830008 add r0, r3, #8 <== NOT EXECUTED
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
3000644c: 3a000004 bcc 30006464 <rtems_stack_checker_switch_extension+0x34><== NOT EXECUTED
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
30006450: e59450b8 ldr r5, [r4, #184] ; 0xb8 <== NOT EXECUTED 30006454: e0835005 add r5, r3, r5 <== NOT EXECUTED
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
30006458: e15b0005 cmp fp, r5 <== NOT EXECUTED 3000645c: 83a05000 movhi r5, #0 <== NOT EXECUTED 30006460: 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,
30006464: e59f1024 ldr r1, [pc, #36] ; 30006490 <rtems_stack_checker_switch_extension+0x60><== NOT EXECUTED 30006468: e3a02010 mov r2, #16 <== NOT EXECUTED 3000646c: eb003791 bl 300142b8 <memcmp> <== NOT EXECUTED 30006470: e2701001 rsbs r1, r0, #1 <== NOT EXECUTED 30006474: 33a01000 movcc r1, #0 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
30006478: e3550000 cmp r5, #0 <== NOT EXECUTED
3000647c: 0a000001 beq 30006488 <rtems_stack_checker_switch_extension+0x58><== NOT EXECUTED
30006480: e3510000 cmp r1, #0 <== NOT EXECUTED
30006484: 18bd8830 popne {r4, r5, fp, pc} <== NOT EXECUTED
Stack_check_report_blown_task( running, pattern_ok );
30006488: e1a00004 mov r0, r4 <== NOT EXECUTED 3000648c: ebffffbd bl 30006388 <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: ea0020cd b 30012b0c <rtems_assoc_name_by_local> <== NOT EXECUTED
3000f94c <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
3000f94c: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr}
double result;
char *end;
if ( !n )
3000f950: e2516000 subs r6, r1, #0
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
3000f954: e1a07000 mov r7, r0 3000f958: e1a08002 mov r8, r2
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3000f95c: 03a00009 moveq r0, #9
)
{
double result;
char *end;
if ( !n )
3000f960: 0a00002e beq 3000fa20 <rtems_string_to_double+0xd4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
3000f964: eb000b6f bl 30012728 <__errno> 3000f968: e3a03000 mov r3, #0 3000f96c: e5803000 str r3, [r0]
*n = 0;
3000f970: e3a04000 mov r4, #0
3000f974: e3a03000 mov r3, #0
3000f978: e8860018 stm r6, {r3, r4}
result = strtod( s, &end );
3000f97c: e1a00007 mov r0, r7 3000f980: e1a0100d mov r1, sp 3000f984: eb0016de bl 30015504 <strtod>
if ( endptr )
3000f988: e3580000 cmp r8, #0
*endptr = end;
3000f98c: 159d3000 ldrne r3, [sp]
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
3000f990: e1a04000 mov r4, r0
if ( endptr )
*endptr = end;
3000f994: 15883000 strne r3, [r8]
if ( end == s )
3000f998: e59d3000 ldr r3, [sp]
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
3000f99c: e1a05001 mov r5, r1
if ( endptr )
*endptr = end;
if ( end == s )
3000f9a0: e1530007 cmp r3, r7
return RTEMS_NOT_DEFINED;
3000f9a4: 03a0000b moveq r0, #11
result = strtod( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
3000f9a8: 0a00001c beq 3000fa20 <rtems_string_to_double+0xd4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3000f9ac: eb000b5d bl 30012728 <__errno> 3000f9b0: e5903000 ldr r3, [r0] 3000f9b4: e3530022 cmp r3, #34 ; 0x22
3000f9b8: 1a000014 bne 3000fa10 <rtems_string_to_double+0xc4>
3000f9bc: e1a00004 mov r0, r4 3000f9c0: e1a01005 mov r1, r5 3000f9c4: e3a02000 mov r2, #0 3000f9c8: e3a03000 mov r3, #0 3000f9cc: ebffde79 bl 300073b8 <__cmpdf2> 3000f9d0: e3500000 cmp r0, #0
3000f9d4: 0a000010 beq 3000fa1c <rtems_string_to_double+0xd0>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
3000f9d8: e1a00004 mov r0, r4 3000f9dc: e1a01005 mov r1, r5 3000f9e0: e3e02000 mvn r2, #0 3000f9e4: e59f3038 ldr r3, [pc, #56] ; 3000fa24 <rtems_string_to_double+0xd8> 3000f9e8: ebffde6e bl 300073a8 <__gedf2> 3000f9ec: e3500000 cmp r0, #0
3000f9f0: ca000009 bgt 3000fa1c <rtems_string_to_double+0xd0>
3000f9f4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f9f8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f9fc: e3e02000 mvn r2, #0 <== NOT EXECUTED 3000fa00: e3e03601 mvn r3, #1048576 ; 0x100000 <== NOT EXECUTED 3000fa04: ebffde69 bl 300073b0 <__ledf2> <== NOT EXECUTED 3000fa08: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fa0c: ba000002 blt 3000fa1c <rtems_string_to_double+0xd0> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
3000fa10: e8860030 stm r6, {r4, r5}
return RTEMS_SUCCESSFUL;
3000fa14: e3a00000 mov r0, #0 3000fa18: ea000000 b 3000fa20 <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;
3000fa1c: e3a0000a mov r0, #10
*n = result;
return RTEMS_SUCCESSFUL;
}
3000fa20: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc}
3000fa28 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
3000fa28: e92d40f1 push {r0, r4, r5, r6, r7, lr}
float result;
char *end;
if ( !n )
3000fa2c: e2516000 subs r6, r1, #0
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
3000fa30: e1a04000 mov r4, r0 3000fa34: e1a07002 mov r7, r2
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3000fa38: 03a00009 moveq r0, #9
)
{
float result;
char *end;
if ( !n )
3000fa3c: 0a000026 beq 3000fadc <rtems_string_to_float+0xb4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
3000fa40: eb000b38 bl 30012728 <__errno> 3000fa44: e3a03000 mov r3, #0 3000fa48: e5803000 str r3, [r0]
*n = 0;
3000fa4c: e3a03000 mov r3, #0 3000fa50: e5863000 str r3, [r6]
result = strtof( s, &end );
3000fa54: e1a00004 mov r0, r4 3000fa58: e1a0100d mov r1, sp 3000fa5c: eb0016af bl 30015520 <strtof>
if ( endptr )
3000fa60: e3570000 cmp r7, #0
*endptr = end;
3000fa64: 159d3000 ldrne r3, [sp]
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
3000fa68: e1a05000 mov r5, r0
if ( endptr )
*endptr = end;
3000fa6c: 15873000 strne r3, [r7]
if ( end == s )
3000fa70: e59d3000 ldr r3, [sp] 3000fa74: e1530004 cmp r3, r4
return RTEMS_NOT_DEFINED;
3000fa78: 03a0000b moveq r0, #11
result = strtof( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
3000fa7c: 0a000016 beq 3000fadc <rtems_string_to_float+0xb4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3000fa80: eb000b28 bl 30012728 <__errno> 3000fa84: e5903000 ldr r3, [r0] 3000fa88: e3530022 cmp r3, #34 ; 0x22
3000fa8c: 1a00000e bne 3000facc <rtems_string_to_float+0xa4>
3000fa90: e1a00005 mov r0, r5 3000fa94: e3a01000 mov r1, #0 3000fa98: ebffde91 bl 300074e4 <__cmpsf2> 3000fa9c: e3500000 cmp r0, #0
3000faa0: 0a00000c beq 3000fad8 <rtems_string_to_float+0xb0>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
3000faa4: e1a00005 mov r0, r5 3000faa8: e59f1030 ldr r1, [pc, #48] ; 3000fae0 <rtems_string_to_float+0xb8> 3000faac: ebffde88 bl 300074d4 <__gesf2> 3000fab0: e3500000 cmp r0, #0
3000fab4: ca000007 bgt 3000fad8 <rtems_string_to_float+0xb0>
3000fab8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000fabc: e3e01502 mvn r1, #8388608 ; 0x800000 <== NOT EXECUTED 3000fac0: ebffde85 bl 300074dc <__lesf2> <== NOT EXECUTED 3000fac4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fac8: ba000002 blt 3000fad8 <rtems_string_to_float+0xb0> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
3000facc: e5865000 str r5, [r6]
return RTEMS_SUCCESSFUL;
3000fad0: e3a00000 mov r0, #0 3000fad4: ea000000 b 3000fadc <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;
3000fad8: e3a0000a mov r0, #10
*n = result;
return RTEMS_SUCCESSFUL;
}
3000fadc: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
3000fae4 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
3000fae4: e92d40f1 push {r0, r4, r5, r6, r7, lr}
long result;
char *end;
if ( !n )
3000fae8: e2516000 subs r6, r1, #0
const char *s,
int *n,
char **endptr,
int base
)
{
3000faec: e1a04000 mov r4, r0 3000faf0: e1a05002 mov r5, r2 3000faf4: e1a07003 mov r7, r3
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3000faf8: 03a00009 moveq r0, #9
)
{
long result;
char *end;
if ( !n )
3000fafc: 0a00001c beq 3000fb74 <rtems_string_to_int+0x90>
return RTEMS_INVALID_ADDRESS;
errno = 0;
3000fb00: eb000b08 bl 30012728 <__errno> 3000fb04: e3a03000 mov r3, #0 3000fb08: e5803000 str r3, [r0]
*n = 0;
result = strtol( s, &end, base );
3000fb0c: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
3000fb10: e5863000 str r3, [r6]
result = strtol( s, &end, base );
3000fb14: e1a00004 mov r0, r4 3000fb18: e1a0100d mov r1, sp 3000fb1c: eb001701 bl 30015728 <strtol>
if ( endptr )
3000fb20: e3550000 cmp r5, #0
*endptr = end;
3000fb24: 159d3000 ldrne r3, [sp]
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
3000fb28: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
3000fb2c: 15853000 strne r3, [r5]
if ( end == s )
3000fb30: e59d3000 ldr r3, [sp] 3000fb34: e1530004 cmp r3, r4
return RTEMS_NOT_DEFINED;
3000fb38: 03a0000b moveq r0, #11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
3000fb3c: 0a00000c beq 3000fb74 <rtems_string_to_int+0x90>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3000fb40: eb000af8 bl 30012728 <__errno> 3000fb44: e5903000 ldr r3, [r0] 3000fb48: e3530022 cmp r3, #34 ; 0x22
3000fb4c: 1a000004 bne 3000fb64 <rtems_string_to_int+0x80>
3000fb50: e3770106 cmn r7, #-2147483647 ; 0x80000001 3000fb54: 13570000 cmpne r7, #0
3000fb58: 0a000004 beq 3000fb70 <rtems_string_to_int+0x8c>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
3000fb5c: e3570102 cmp r7, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000fb60: 0a000002 beq 3000fb70 <rtems_string_to_int+0x8c> <== NOT EXECUTED
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
3000fb64: e5867000 str r7, [r6]
return RTEMS_SUCCESSFUL;
3000fb68: e3a00000 mov r0, #0 3000fb6c: ea000000 b 3000fb74 <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;
3000fb70: e3a0000a mov r0, #10
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
3000fb74: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
3000fcdc <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
3000fcdc: e92d40f1 push {r0, r4, r5, r6, r7, lr}
unsigned long result;
char *end;
if ( !n )
3000fce0: e2516000 subs r6, r1, #0
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
3000fce4: e1a04000 mov r4, r0 3000fce8: e1a05002 mov r5, r2 3000fcec: e1a07003 mov r7, r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3000fcf0: 03a00009 moveq r0, #9
)
{
unsigned long result;
char *end;
if ( !n )
3000fcf4: 0a00001e beq 3000fd74 <rtems_string_to_unsigned_char+0x98>
return RTEMS_INVALID_ADDRESS;
errno = 0;
3000fcf8: eb000a8a bl 30012728 <__errno> 3000fcfc: e3a03000 mov r3, #0 3000fd00: e5803000 str r3, [r0]
*n = 0;
result = strtoul( s, &end, base );
3000fd04: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
3000fd08: e5c63000 strb r3, [r6]
result = strtoul( s, &end, base );
3000fd0c: e1a00004 mov r0, r4 3000fd10: e1a0100d mov r1, sp 3000fd14: eb0017b2 bl 30015be4 <strtoul>
if ( endptr )
3000fd18: e3550000 cmp r5, #0
*endptr = end;
3000fd1c: 159d3000 ldrne r3, [sp]
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
3000fd20: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
3000fd24: 15853000 strne r3, [r5]
if ( end == s )
3000fd28: e59d3000 ldr r3, [sp] 3000fd2c: e1530004 cmp r3, r4
return RTEMS_NOT_DEFINED;
3000fd30: 03a0000b moveq r0, #11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
3000fd34: 0a00000e beq 3000fd74 <rtems_string_to_unsigned_char+0x98>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3000fd38: eb000a7a bl 30012728 <__errno> 3000fd3c: e5903000 ldr r3, [r0] 3000fd40: e3530022 cmp r3, #34 ; 0x22
3000fd44: 1a000002 bne 3000fd54 <rtems_string_to_unsigned_char+0x78>
(( result == 0 ) || ( result == ULONG_MAX )))
3000fd48: e2473001 sub r3, r7, #1 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3000fd4c: e3730003 cmn r3, #3 <== NOT EXECUTED 3000fd50: 8a000006 bhi 3000fd70 <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 ) {
3000fd54: e35700ff cmp r7, #255 ; 0xff
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
3000fd58: 95c67000 strbls r7, [r6]
return RTEMS_SUCCESSFUL;
3000fd5c: 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 ) {
3000fd60: 9a000003 bls 3000fd74 <rtems_string_to_unsigned_char+0x98>
errno = ERANGE;
3000fd64: eb000a6f bl 30012728 <__errno> <== NOT EXECUTED 3000fd68: e3a03022 mov r3, #34 ; 0x22 <== NOT EXECUTED 3000fd6c: 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;
3000fd70: e3a0000a mov r0, #10 <== NOT EXECUTED
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
3000fd74: 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: eb003fcd bl 30015fb8 <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: eb003fc1 bl 30016018 <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: eb00401c bl 3001619c <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: eb001e3c bl 3000da30 <_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: eb001e38 bl 3000da30 <_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: eb001e34 bl 3000da30 <_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: eb001e3e bl 3000da68 <_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: eb003dc6 bl 300158a8 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
3000618c: e1a00005 mov r0, r5 30006190: eb003f88 bl 30015fb8 <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: 1b003d06 blne 300155cc <strcat>
strcat(full_filename, filename);
300061b0: e1a01007 mov r1, r7 300061b4: e1a00005 mov r0, r5 300061b8: eb003d03 bl 300155cc <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: eb002100 bl 3000e600 <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: eb001f69 bl 3000dfd0 <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: eb00016e bl 30009d6c <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
300097b0: e1a00004 mov r0, r4 300097b4: e1a0100d mov r1, sp 300097b8: eb00082d bl 3000b874 <_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: eb0004c0 bl 3000aad8 <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
300097d4: e1a01004 mov r1, r4 300097d8: eb000767 bl 3000b57c <_Thread_Close> 300097dc: e5940008 ldr r0, [r4, #8] 300097e0: eb0004bc bl 3000aad8 <_Objects_Get_information_id> 300097e4: e1a01004 mov r1, r4 300097e8: eb00049d bl 3000aa64 <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
300097ec: e5950000 ldr r0, [r5] 300097f0: eb000176 bl 30009dd0 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
300097f4: eb000815 bl 3000b850 <_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: eb000171 bl 30009dd0 <_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: e59330f8 ldr r3, [r3, #248] ; 0xf8 <== 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: eb0008dc bl 3000db78 <_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: e59030f8 ldr r3, [r0, #248] ; 0xf8 3000b818: e2844008 add r4, r4, #8 3000b81c: e7933104 ldr r3, [r3, r4, lsl #2] 3000b820: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
3000b824: eb0008ca bl 3000db54 <_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: eb000531 bl 3000ad1c <_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: eb00100c bl 3001bad4 <_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: eb000ffb bl 3001bab0 <_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: eb000ff8 bl 3001bab0 <_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: eb0007fe bl 3000c524 <_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: eb0009f6 bl 3000cd20 <_Thread_Restart> 3000a544: e3500000 cmp r0, #0
3000a548: 0a000002 beq 3000a558 <rtems_task_restart+0x40>
_Thread_Enable_dispatch();
3000a54c: eb0007eb bl 3000c500 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a550: e1a00004 mov r0, r4 3000a554: ea000001 b 3000a560 <rtems_task_restart+0x48>
}
_Thread_Enable_dispatch();
3000a558: eb0007e8 bl 3000c500 <_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: eb000815 bl 3000ecc4 <_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: eb00073d bl 3000e98c <_Thread_Clear_state>
_Thread_Enable_dispatch();
3000cc94: eb000801 bl 3000eca0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000cc98: e1a00004 mov r0, r4 3000cc9c: ea000001 b 3000cca8 <rtems_task_resume+0x48>
}
_Thread_Enable_dispatch();
3000cca0: eb0007fe bl 3000eca0 <_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: e59330f8 ldr r3, [r3, #248] ; 0xf8 <== 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: eb00087b bl 3000db78 <_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: e59030f8 ldr r3, [r0, #248] ; 0xf8 3000b99c: e2844008 add r4, r4, #8 3000b9a0: e7835104 str r5, [r3, r4, lsl #2]
_Thread_Enable_dispatch();
3000b9a4: eb00086a bl 3000db54 <_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: eb000874 bl 3000fc30 <_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: eb000755 bl 3000f7fc <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
3000daa4: eb000858 bl 3000fc0c <_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: eb0007d8 bl 3000b874 <_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: eb000a2a bl 3000c1e0 <_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: eb0007c3 bl 3000b850 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30009940: e1a00004 mov r0, r4 30009944: ea000001 b 30009950 <rtems_task_start+0x5c>
}
_Thread_Enable_dispatch();
30009948: eb0007c0 bl 3000b850 <_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: eb0007e5 bl 3000ee68 <_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: eb0009e1 bl 3000f680 <_Thread_Set_state>
_Thread_Enable_dispatch();
3000cef8: eb0007d1 bl 3000ee44 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000cefc: e1a00004 mov r0, r4 3000cf00: ea000001 b 3000cf0c <rtems_task_suspend+0x48>
}
_Thread_Enable_dispatch();
3000cf04: eb0007ce bl 3000ee44 <_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: eb000815 bl 3000c674 <_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: 05906104 ldreq r6, [r0, #260] ; 0x104
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: eb000801 bl 3000c650 <_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: eb000c22 bl 3000d6f0 <_Workspace_Allocate>
if (new == NULL) {
3000a664: e3500000 cmp r0, #0
3000a668: 1a000002 bne 3000a678 <rtems_task_variable_add+0x78>
_Thread_Enable_dispatch();
3000a66c: eb0007f7 bl 3000c650 <_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: e5973104 ldr r3, [r7, #260] ; 0x104
_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: e5870104 str r0, [r7, #260] ; 0x104
_Thread_Enable_dispatch();
3000a694: eb0007ed bl 3000c650 <_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: eb0007ed bl 3000c674 <_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: 05901104 ldreq r1, [r0, #260] ; 0x104 <== 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: 05802104 streq r2, [r0, #260] ; 0x104 <== 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: eb0007d6 bl 3000c650 <_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: eb0007cf bl 3000c650 <_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: eb0007cc bl 3000c674 <_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: 05903104 ldreq r3, [r0, #260] ; 0x104 <== 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: eb0007b8 bl 3000c650 <_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: eb0007b2 bl 3000c650 <_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: eb0009bd bl 3000c08c <_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: eb000b0f bl 3000c604 <_Watchdog_Insert> <== NOT EXECUTED
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
}
_Thread_Enable_dispatch();
300099c4: eb0007a1 bl 3000b850 <_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: eb0009cc bl 3000d338 <_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: eb000b45 bl 3000d950 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
3000ac38: eb0007af bl 3000cafc <_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: eb001af0 bl 3000fb04 <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: eb000918 bl 30009b0c <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: eb0003f6 bl 30009b0c <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: eb0030c2 bl 30014a30 <__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: eb0030b9 bl 30014a30 <__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: eb003375 bl 300147d0 <__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: eb001b13 bl 3000fc00 <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: eb000966 bl 30009b0c <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: eb0033a9 bl 30014a30 <__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: 1b0007d4 blne 30009b0c <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: eb003182 bl 30014a30 <__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: eb003179 bl 30014a30 <__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: eb00301c bl 30014a30 <__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: eb0003ac bl 3000ad20 <_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: eb0007c9 bl 3000bda0 <_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: eb0007b9 bl 3000bda0 <_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: eb0004a1 bl 3000b190 <_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: eb000b62 bl 3000ccb4 <_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: eb000af8 bl 3000cb54 <_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: eb00078a bl 3000bda0 <_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: eb000ae7 bl 3001ae18 <_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: eb001266 bl 3001cc34 <_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: eb001202 bl 3001cad4 <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
300182c8: eb000df8 bl 3001bab0 <_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: eb000ac1 bl 3001ae18 <_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: eb000dda bl 3001bab0 <_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: eb000c39 bl 3001bab0 <_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: eb000aa0 bl 3001ae18 <_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: eb00121c bl 3001cc34 <_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: eb0011c1 bl 3001cad4 <_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: eb001211 bl 3001cc34 <_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: eb000daa bl 3001bab0 <_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: eb000a6b bl 3001ae18 <_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: eb0011eb bl 3001cc34 <_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: eb000d75 bl 3001bab0 <_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: eb000a2a bl 3001ae18 <_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: eb0011aa bl 3001cc34 <_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: eb000d3b bl 3001bab0 <_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: eb002f65 bl 300165d8 <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: eb002e6b bl 300161fc <__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: eb004a98 bl 3001d2cc <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: eb003036 bl 30016970 <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: eb003333 bl 3001757c <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: eb00332b bl 3001757c <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: eb00301e bl 30016970 <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: eb003018 bl 30016970 <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: eb002f2e bl 300165d8 <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: eb003490 bl 30013c34 <__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: eb003dad bl 300160f0 <__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: eb003e3e bl 30016350 <__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: bb003456 bllt 30013c34 <__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
30009e60 <sched_get_priority_max>:
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
30009e60: e3500004 cmp r0, #4 <== NOT EXECUTED
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
30009e64: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
switch ( policy ) {
30009e68: 8a000003 bhi 30009e7c <sched_get_priority_max+0x1c> <== NOT EXECUTED 30009e6c: e3a03001 mov r3, #1 <== NOT EXECUTED 30009e70: e1a00013 lsl r0, r3, r0 <== NOT EXECUTED 30009e74: e3100017 tst r0, #23 <== NOT EXECUTED 30009e78: 1a000004 bne 30009e90 <sched_get_priority_max+0x30> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30009e7c: eb002035 bl 30011f58 <__errno> <== NOT EXECUTED
30009e80: e3a03016 mov r3, #22 <== NOT EXECUTED
30009e84: e5803000 str r3, [r0] <== NOT EXECUTED
30009e88: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009e8c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
30009e90: e59f3008 ldr r3, [pc, #8] ; 30009ea0 <sched_get_priority_max+0x40><== NOT EXECUTED 30009e94: e5d30000 ldrb r0, [r3] <== NOT EXECUTED 30009e98: e2400001 sub r0, r0, #1 <== NOT EXECUTED
}
30009e9c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009ea4 <sched_get_priority_min>:
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
30009ea4: e3500004 cmp r0, #4 <== NOT EXECUTED
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
30009ea8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
switch ( policy ) {
30009eac: 8a000003 bhi 30009ec0 <sched_get_priority_min+0x1c> <== NOT EXECUTED 30009eb0: e3a03001 mov r3, #1 <== NOT EXECUTED 30009eb4: e1a00013 lsl r0, r3, r0 <== NOT EXECUTED 30009eb8: e3100017 tst r0, #23 <== NOT EXECUTED 30009ebc: 1a000004 bne 30009ed4 <sched_get_priority_min+0x30> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30009ec0: eb002024 bl 30011f58 <__errno> <== NOT EXECUTED
30009ec4: e3a03016 mov r3, #22 <== NOT EXECUTED
30009ec8: e5803000 str r3, [r0] <== NOT EXECUTED
30009ecc: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009ed0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
30009ed4: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30009ed8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000940c <sched_getparam>:
int sched_getparam(
pid_t pid __attribute__((unused)),
struct sched_param *param __attribute__((unused))
)
{
3000940c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009410: eb002170 bl 300119d8 <__errno> <== NOT EXECUTED 30009414: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009418: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000941c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009420: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009424 <sched_getscheduler>:
#include <rtems/posix/time.h>
int sched_getscheduler(
pid_t pid __attribute__((unused))
)
{
30009424: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009428: eb00216a bl 300119d8 <__errno> <== NOT EXECUTED 3000942c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009430: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009434: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009438: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009edc <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
30009edc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
30009ee0: e2505000 subs r5, r0, #0 <== NOT EXECUTED
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
30009ee4: e1a04001 mov r4, r1 <== NOT EXECUTED
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
30009ee8: 0a000005 beq 30009f04 <sched_rr_get_interval+0x28> <== NOT EXECUTED 30009eec: ebfff33d bl 30006be8 <getpid> <== NOT EXECUTED 30009ef0: e1550000 cmp r5, r0 <== NOT EXECUTED 30009ef4: 0a000002 beq 30009f04 <sched_rr_get_interval+0x28> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
30009ef8: eb002016 bl 30011f58 <__errno> <== NOT EXECUTED 30009efc: e3a03003 mov r3, #3 <== NOT EXECUTED 30009f00: ea000003 b 30009f14 <sched_rr_get_interval+0x38> <== NOT EXECUTED
if ( !interval )
30009f04: e3540000 cmp r4, #0 <== NOT EXECUTED 30009f08: 1a000004 bne 30009f20 <sched_rr_get_interval+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009f0c: eb002011 bl 30011f58 <__errno> <== NOT EXECUTED
30009f10: e3a03016 mov r3, #22 <== NOT EXECUTED
30009f14: e5803000 str r3, [r0] <== NOT EXECUTED
30009f18: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009f1c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
30009f20: e59f3010 ldr r3, [pc, #16] ; 30009f38 <sched_rr_get_interval+0x5c><== NOT EXECUTED 30009f24: e1a01004 mov r1, r4 <== NOT EXECUTED 30009f28: e5930000 ldr r0, [r3] <== NOT EXECUTED 30009f2c: eb000d46 bl 3000d44c <_Timespec_From_ticks> <== NOT EXECUTED
return 0;
30009f30: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30009f34: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000943c <sched_setparam>:
int sched_setparam(
pid_t pid __attribute__((unused)),
const struct sched_param *param __attribute__((unused))
)
{
3000943c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009440: eb002164 bl 300119d8 <__errno> <== NOT EXECUTED 30009444: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009448: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000944c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009450: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009454 <sched_setscheduler>:
int sched_setscheduler(
pid_t pid __attribute__((unused)),
int policy __attribute__((unused)),
const struct sched_param *param __attribute__((unused))
)
{
30009454: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009458: eb00215e bl 300119d8 <__errno> <== NOT EXECUTED 3000945c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009460: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009464: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009468: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c398 <sem_close>:
*/
int sem_close(
sem_t *sem
)
{
3000c398: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3000c39c: e1a03000 mov r3, r0 <== NOT EXECUTED
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
_Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location );
3000c3a0: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000c3a4: e59f0040 ldr r0, [pc, #64] ; 3000c3ec <sem_close+0x54> <== NOT EXECUTED 3000c3a8: e1a0200d mov r2, sp <== NOT EXECUTED 3000c3ac: eb00080d bl 3000e3e8 <_Objects_Get> <== NOT EXECUTED
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000c3b0: e59d4000 ldr r4, [sp] <== NOT EXECUTED 3000c3b4: e3540000 cmp r4, #0 <== NOT EXECUTED 3000c3b8: 1a000006 bne 3000c3d8 <sem_close+0x40> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_semaphore->open_count -= 1;
3000c3bc: e5902018 ldr r2, [r0, #24] <== NOT EXECUTED 3000c3c0: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000c3c4: e5802018 str r2, [r0, #24] <== NOT EXECUTED
_POSIX_Semaphore_Delete( the_semaphore );
3000c3c8: eb001884 bl 300125e0 <_POSIX_Semaphore_Delete> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c3cc: eb000b2b bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000c3d0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c3d4: ea000003 b 3000c3e8 <sem_close+0x50> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000c3d8: eb00238f bl 3001521c <__errno> <== NOT EXECUTED 3000c3dc: e3a03016 mov r3, #22 <== NOT EXECUTED 3000c3e0: e5803000 str r3, [r0] <== NOT EXECUTED 3000c3e4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000c3e8: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000c3f0 <sem_destroy>:
*/
int sem_destroy(
sem_t *sem
)
{
3000c3f0: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3000c3f4: e1a03000 mov r3, r0 <== NOT EXECUTED
3000c3f8: e1a0200d mov r2, sp <== NOT EXECUTED
3000c3fc: e59f0048 ldr r0, [pc, #72] ; 3000c44c <sem_destroy+0x5c> <== NOT EXECUTED
3000c400: e5931000 ldr r1, [r3] <== NOT EXECUTED
3000c404: eb0007f7 bl 3000e3e8 <_Objects_Get> <== NOT EXECUTED
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000c408: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000c40c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000c410: 1a000008 bne 3000c438 <sem_destroy+0x48> <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
3000c414: e5d04014 ldrb r4, [r0, #20] <== NOT EXECUTED 3000c418: e3540000 cmp r4, #0 <== NOT EXECUTED 3000c41c: 0a000001 beq 3000c428 <sem_destroy+0x38> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c420: eb000b16 bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000c424: ea000003 b 3000c438 <sem_destroy+0x48> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
_POSIX_Semaphore_Delete( the_semaphore );
3000c428: eb00186c bl 300125e0 <_POSIX_Semaphore_Delete> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c42c: eb000b13 bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000c430: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c434: ea000003 b 3000c448 <sem_destroy+0x58> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000c438: eb002377 bl 3001521c <__errno> <== NOT EXECUTED 3000c43c: e3a03016 mov r3, #22 <== NOT EXECUTED 3000c440: e5803000 str r3, [r0] <== NOT EXECUTED 3000c444: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000c448: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000c450 <sem_getvalue>:
int sem_getvalue(
sem_t *sem,
int *sval
)
{
3000c450: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3000c454: e1a03000 mov r3, r0 <== NOT EXECUTED
3000c458: e1a04001 mov r4, r1 <== NOT EXECUTED
3000c45c: e59f003c ldr r0, [pc, #60] ; 3000c4a0 <sem_getvalue+0x50> <== NOT EXECUTED
3000c460: e5931000 ldr r1, [r3] <== NOT EXECUTED
3000c464: e1a0200d mov r2, sp <== NOT EXECUTED
3000c468: eb0007de bl 3000e3e8 <_Objects_Get> <== NOT EXECUTED
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000c46c: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000c470: e3550000 cmp r5, #0 <== NOT EXECUTED 3000c474: 1a000004 bne 3000c48c <sem_getvalue+0x3c> <== NOT EXECUTED
case OBJECTS_LOCAL:
*sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore );
3000c478: e5903064 ldr r3, [r0, #100] ; 0x64 <== NOT EXECUTED 3000c47c: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c480: eb000afe bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000c484: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c488: ea000003 b 3000c49c <sem_getvalue+0x4c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000c48c: eb002362 bl 3001521c <__errno> <== NOT EXECUTED 3000c490: e3a03016 mov r3, #22 <== NOT EXECUTED 3000c494: e5803000 str r3, [r0] <== NOT EXECUTED 3000c498: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000c49c: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000c4a4 <sem_init>:
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
3000c4a4: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
3000c4a8: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000c4ac: 1a000004 bne 3000c4c4 <sem_init+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000c4b0: eb002359 bl 3001521c <__errno> <== NOT EXECUTED 3000c4b4: e3a03016 mov r3, #22 <== NOT EXECUTED 3000c4b8: e5803000 str r3, [r0] <== NOT EXECUTED 3000c4bc: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000c4c0: ea000006 b 3000c4e0 <sem_init+0x3c> <== NOT EXECUTED
status = _POSIX_Semaphore_Create_support(
3000c4c4: e1a0300d mov r3, sp <== NOT EXECUTED 3000c4c8: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c4cc: eb001806 bl 300124ec <_POSIX_Semaphore_Create_support> <== NOT EXECUTED
pshared,
value,
&the_semaphore
);
if ( status != -1 )
3000c4d0: e3700001 cmn r0, #1 <== NOT EXECUTED
*sem = the_semaphore->Object.id;
3000c4d4: 159d3000 ldrne r3, [sp] <== NOT EXECUTED 3000c4d8: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED 3000c4dc: 15843000 strne r3, [r4] <== NOT EXECUTED
return status;
}
3000c4e0: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000c4e4 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
3000c4e4: e92d000e push {r1, r2, r3} <== NOT EXECUTED
3000c4e8: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000c4ec: e59f30e4 ldr r3, [pc, #228] ; 3000c5d8 <sem_open+0xf4> <== NOT EXECUTED 3000c4f0: e59d4028 ldr r4, [sp, #40] ; 0x28 <== NOT EXECUTED 3000c4f4: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c4f8: e1a06000 mov r6, r0 <== NOT EXECUTED 3000c4fc: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000c500: e5832000 str r2, [r3] <== NOT EXECUTED
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
3000c504: e2147c02 ands r7, r4, #512 ; 0x200 <== NOT EXECUTED
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
3000c508: 128d3034 addne r3, sp, #52 ; 0x34 <== NOT EXECUTED
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
3000c50c: e28d1008 add r1, sp, #8 <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
3000c510: 158d300c strne r3, [sp, #12] <== NOT EXECUTED 3000c514: 159d5030 ldrne r5, [sp, #48] ; 0x30 <== NOT EXECUTED
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
3000c518: 01a05007 moveq r5, r7 <== NOT EXECUTED
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
3000c51c: eb001843 bl 30012630 <_POSIX_Semaphore_Name_to_id> <== NOT EXECUTED
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
3000c520: e2508000 subs r8, r0, #0 <== NOT EXECUTED 3000c524: 0a000007 beq 3000c548 <sem_open+0x64> <== NOT EXECUTED
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
3000c528: e3580002 cmp r8, #2 <== NOT EXECUTED 3000c52c: 1a000001 bne 3000c538 <sem_open+0x54> <== NOT EXECUTED 3000c530: e3570000 cmp r7, #0 <== NOT EXECUTED 3000c534: 1a000017 bne 3000c598 <sem_open+0xb4> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c538: eb000ad0 bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
3000c53c: eb002336 bl 3001521c <__errno> <== NOT EXECUTED 3000c540: e5808000 str r8, [r0] <== NOT EXECUTED 3000c544: ea000006 b 3000c564 <sem_open+0x80> <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
3000c548: e2044c0a and r4, r4, #2560 ; 0xa00 <== NOT EXECUTED 3000c54c: e3540c0a cmp r4, #2560 ; 0xa00 <== NOT EXECUTED 3000c550: 1a000005 bne 3000c56c <sem_open+0x88> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c554: eb000ac9 bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
3000c558: eb00232f bl 3001521c <__errno> <== NOT EXECUTED 3000c55c: e3a03011 mov r3, #17 <== NOT EXECUTED 3000c560: e5803000 str r3, [r0] <== NOT EXECUTED 3000c564: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000c568: ea000016 b 3000c5c8 <sem_open+0xe4> <== NOT EXECUTED 3000c56c: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3000c570: e1a0200d mov r2, sp <== NOT EXECUTED 3000c574: e59f0060 ldr r0, [pc, #96] ; 3000c5dc <sem_open+0xf8> <== NOT EXECUTED 3000c578: eb00079a bl 3000e3e8 <_Objects_Get> <== NOT EXECUTED
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
3000c57c: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
3000c580: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
the_semaphore->open_count += 1;
3000c584: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000c588: e5803018 str r3, [r0, #24] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c58c: eb000abb bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c590: eb000aba bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
goto return_id;
3000c594: ea000009 b 3000c5c0 <sem_open+0xdc> <== NOT EXECUTED
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
3000c598: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c59c: e1a02005 mov r2, r5 <== NOT EXECUTED 3000c5a0: e28d3004 add r3, sp, #4 <== NOT EXECUTED 3000c5a4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000c5a8: eb0017cf bl 300124ec <_POSIX_Semaphore_Create_support> <== NOT EXECUTED 3000c5ac: e1a04000 mov r4, r0 <== NOT EXECUTED
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
3000c5b0: eb000ab2 bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( status == -1 )
3000c5b4: e3740001 cmn r4, #1 <== NOT EXECUTED
return SEM_FAILED;
3000c5b8: 01a00004 moveq r0, r4 <== NOT EXECUTED
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
3000c5bc: 0a000001 beq 3000c5c8 <sem_open+0xe4> <== NOT EXECUTED
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
3000c5c0: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3000c5c4: e2800008 add r0, r0, #8 <== NOT EXECUTED
#endif return id; }
3000c5c8: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000c5cc: e8bd41f0 pop {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000c5d0: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000c5d4: e12fff1e bx lr <== NOT EXECUTED
3000c5e0 <sem_post>:
*/
int sem_post(
sem_t *sem
)
{
3000c5e0: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3000c5e4: e1a03000 mov r3, r0 <== NOT EXECUTED
3000c5e8: e5931000 ldr r1, [r3] <== NOT EXECUTED
3000c5ec: e59f0044 ldr r0, [pc, #68] ; 3000c638 <sem_post+0x58> <== NOT EXECUTED
3000c5f0: e1a0200d mov r2, sp <== NOT EXECUTED
3000c5f4: eb00077b bl 3000e3e8 <_Objects_Get> <== NOT EXECUTED
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000c5f8: e59d4000 ldr r4, [sp] <== NOT EXECUTED 3000c5fc: e1a03000 mov r3, r0 <== NOT EXECUTED 3000c600: e3540000 cmp r4, #0 <== NOT EXECUTED 3000c604: 1a000006 bne 3000c624 <sem_post+0x44> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_semaphore_Surrender(
3000c608: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED 3000c60c: e1a02004 mov r2, r4 <== NOT EXECUTED 3000c610: e280001c add r0, r0, #28 <== NOT EXECUTED 3000c614: eb0004f2 bl 3000d9e4 <_CORE_semaphore_Surrender> <== NOT EXECUTED
NULL /* XXX need to define a routine to handle this case */
#else
NULL
#endif
);
_Thread_Enable_dispatch();
3000c618: eb000a98 bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000c61c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c620: ea000003 b 3000c634 <sem_post+0x54> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000c624: eb0022fc bl 3001521c <__errno> <== NOT EXECUTED 3000c628: e3a03016 mov r3, #22 <== NOT EXECUTED 3000c62c: e5803000 str r3, [r0] <== NOT EXECUTED 3000c630: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000c634: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000c63c <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
3000c63c: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3000c640: e1a04000 mov r4, r0 <== NOT EXECUTED
* * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
3000c644: e1a00001 mov r0, r1 <== NOT EXECUTED 3000c648: e1a0100d mov r1, sp <== NOT EXECUTED 3000c64c: eb00152d bl 30011b08 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
3000c650: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000c654: e3500003 cmp r0, #3 <== NOT EXECUTED 3000c658: 13a01000 movne r1, #0 <== NOT EXECUTED 3000c65c: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000c660: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c664: eb001814 bl 300126bc <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
3000c668: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000c66c <sem_trywait>:
int sem_trywait(
sem_t *sem
)
{
return _POSIX_Semaphore_Wait_support(sem, false, THREAD_QUEUE_WAIT_FOREVER);
3000c66c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c670: e1a02001 mov r2, r1 <== NOT EXECUTED 3000c674: ea001810 b 300126bc <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
3000c678 <sem_unlink>:
3000c678: e59f3060 ldr r3, [pc, #96] ; 3000c6e0 <sem_unlink+0x68> <== NOT EXECUTED
*/
int sem_unlink(
const char *name
)
{
3000c67c: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3000c680: e5932000 ldr r2, [r3] <== NOT EXECUTED
3000c684: e2822001 add r2, r2, #1 <== NOT EXECUTED
3000c688: e5832000 str r2, [r3] <== NOT EXECUTED
register POSIX_Semaphore_Control *the_semaphore;
sem_t the_semaphore_id;
_Thread_Disable_dispatch();
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
3000c68c: e1a0100d mov r1, sp <== NOT EXECUTED 3000c690: eb0017e6 bl 30012630 <_POSIX_Semaphore_Name_to_id> <== NOT EXECUTED
if ( status != 0 ) {
3000c694: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000c698: 0a000004 beq 3000c6b0 <sem_unlink+0x38> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c69c: eb000a77 bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( status );
3000c6a0: eb0022dd bl 3001521c <__errno> <== NOT EXECUTED 3000c6a4: e5804000 str r4, [r0] <== NOT EXECUTED 3000c6a8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000c6ac: ea00000a b 3000c6dc <sem_unlink+0x64> <== NOT EXECUTED
_POSIX_Semaphore_Namespace_remove( the_semaphore );
_POSIX_Semaphore_Delete( the_semaphore );
_Thread_Enable_dispatch();
return 0;
}
3000c6b0: e59f002c ldr r0, [pc, #44] ; 3000c6e4 <sem_unlink+0x6c> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
3000c6b4: e1dd20b0 ldrh r2, [sp] <== NOT EXECUTED 3000c6b8: e590301c ldr r3, [r0, #28] <== NOT EXECUTED
if ( status != 0 ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( status );
}
the_semaphore = (POSIX_Semaphore_Control *) _Objects_Get_local_object(
3000c6bc: e7935102 ldr r5, [r3, r2, lsl #2] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Namespace_remove (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Namespace_remove(
3000c6c0: e1a01005 mov r1, r5 <== NOT EXECUTED
&_POSIX_Semaphore_Information,
_Objects_Get_index( the_semaphore_id )
);
the_semaphore->linked = false;
3000c6c4: e5c54015 strb r4, [r5, #21] <== NOT EXECUTED 3000c6c8: eb000796 bl 3000e528 <_Objects_Namespace_remove> <== NOT EXECUTED
_POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore );
3000c6cc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c6d0: eb0017c2 bl 300125e0 <_POSIX_Semaphore_Delete> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c6d4: eb000a69 bl 3000f080 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000c6d8: e1a00004 mov r0, r4 <== NOT EXECUTED
}
3000c6dc: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000c6e8 <sem_wait>:
int sem_wait(
sem_t *sem
)
{
return _POSIX_Semaphore_Wait_support( sem, true, THREAD_QUEUE_WAIT_FOREVER );
3000c6e8: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c6ec: e3a02000 mov r2, #0 <== NOT EXECUTED 3000c6f0: ea0017f1 b 300126bc <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
30008fac <seteuid>:
#include <rtems/userenv.h>
int seteuid( uid_t euid )
{
_POSIX_types_Euid = euid;
30008fac: e59f300c ldr r3, [pc, #12] ; 30008fc0 <seteuid+0x14> <== NOT EXECUTED 30008fb0: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008fb4: e1c303b6 strh r0, [r3, #54] ; 0x36 <== NOT EXECUTED
return 0; }
30008fb8: e3a00000 mov r0, #0 <== NOT EXECUTED 30008fbc: 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: 1b002b96 blne 300120f4 <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: eb002d6a bl 30012850 <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
30009318 <setitimer>:
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
if ( !value )
30009318: e3510000 cmp r1, #0 <== NOT EXECUTED
int setitimer(
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
3000931c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !value )
30009320: 0a000001 beq 3000932c <setitimer+0x14> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
30009324: e3520000 cmp r2, #0 <== NOT EXECUTED 30009328: 1a000002 bne 30009338 <setitimer+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
3000932c: eb002158 bl 30011894 <__errno> <== NOT EXECUTED 30009330: e3a0300e mov r3, #14 <== NOT EXECUTED 30009334: ea000006 b 30009354 <setitimer+0x3c> <== NOT EXECUTED
switch ( which ) {
30009338: e3500002 cmp r0, #2 <== NOT EXECUTED 3000933c: 8a000002 bhi 3000934c <setitimer+0x34> <== NOT EXECUTED
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
30009340: eb002153 bl 30011894 <__errno> <== NOT EXECUTED 30009344: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009348: ea000001 b 30009354 <setitimer+0x3c> <== NOT EXECUTED
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000934c: eb002150 bl 30011894 <__errno> <== NOT EXECUTED 30009350: e3a03016 mov r3, #22 <== NOT EXECUTED 30009354: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009358: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000935c: 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: eb0027e5 bl 30011fbc <__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: 1b002bea blne 300120f4 <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: eb002dbe bl 30012850 <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: eb0027df bl 30011fbc <__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
30009d58 <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
30009d58: e2523000 subs r3, r2, #0 <== NOT EXECUTED
*oact = _POSIX_signals_Vectors[ sig ];
30009d5c: 159f20b8 ldrne r2, [pc, #184] ; 30009e1c <sigaction+0xc4> <== NOT EXECUTED
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
30009d60: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
30009d64: e1a05001 mov r5, r1 <== NOT EXECUTED
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
30009d68: 13a0100c movne r1, #12 <== NOT EXECUTED 30009d6c: 10222091 mlane r2, r1, r0, r2 <== NOT EXECUTED
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
30009d70: e1a04000 mov r4, r0 <== NOT EXECUTED
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
30009d74: 18920007 ldmne r2, {r0, r1, r2} <== NOT EXECUTED
30009d78: 18830007 stmne r3, {r0, r1, r2} <== NOT EXECUTED
if ( !sig )
30009d7c: e3540000 cmp r4, #0 <== NOT EXECUTED 30009d80: 0a000004 beq 30009d98 <sigaction+0x40> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
30009d84: e2443001 sub r3, r4, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
30009d88: e353001f cmp r3, #31 <== NOT EXECUTED 30009d8c: 8a000001 bhi 30009d98 <sigaction+0x40> <== NOT EXECUTED
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
30009d90: e3540009 cmp r4, #9 <== NOT EXECUTED 30009d94: 1a000004 bne 30009dac <sigaction+0x54> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009d98: eb002143 bl 300122ac <__errno> <== NOT EXECUTED
30009d9c: e3a03016 mov r3, #22 <== NOT EXECUTED
30009da0: e5803000 str r3, [r0] <== NOT EXECUTED
30009da4: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009da8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
30009dac: e3550000 cmp r5, #0 <== NOT EXECUTED 30009db0: 0a000017 beq 30009e14 <sigaction+0xbc> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30009db4: e10f6000 mrs r6, CPSR <== NOT EXECUTED 30009db8: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 30009dbc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
30009dc0: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 30009dc4: e59f7050 ldr r7, [pc, #80] ; 30009e1c <sigaction+0xc4> <== NOT EXECUTED 30009dc8: e3530000 cmp r3, #0 <== NOT EXECUTED 30009dcc: 1a000007 bne 30009df0 <sigaction+0x98> <== NOT EXECUTED
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
30009dd0: e283300c add r3, r3, #12 <== NOT EXECUTED
30009dd4: e0040493 mul r4, r3, r4 <== NOT EXECUTED
30009dd8: e59f2040 ldr r2, [pc, #64] ; 30009e20 <sigaction+0xc8> <== NOT EXECUTED
30009ddc: e0873004 add r3, r7, r4 <== NOT EXECUTED
30009de0: e0824004 add r4, r2, r4 <== NOT EXECUTED
30009de4: e8940007 ldm r4, {r0, r1, r2} <== NOT EXECUTED
30009de8: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
30009dec: ea000005 b 30009e08 <sigaction+0xb0> <== NOT EXECUTED
} else {
_POSIX_signals_Clear_process_signals( sig );
30009df0: e1a00004 mov r0, r4 <== NOT EXECUTED 30009df4: eb0015e4 bl 3000f58c <_POSIX_signals_Clear_process_signals><== NOT EXECUTED
_POSIX_signals_Vectors[ sig ] = *act;
30009df8: e8950007 ldm r5, {r0, r1, r2} <== NOT EXECUTED
30009dfc: e3a0300c mov r3, #12 <== NOT EXECUTED
30009e00: e0247493 mla r4, r3, r4, r7 <== NOT EXECUTED
30009e04: e8840007 stm r4, {r0, r1, r2} <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009e08: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
30009e0c: e3a00000 mov r0, #0 <== NOT EXECUTED
30009e10: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30009e14: e1a00005 mov r0, r5 <== NOT EXECUTED
}
30009e18: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30009e24 <sigaddset>:
int sigaddset(
sigset_t *set,
int signo
)
{
if ( !set )
30009e24: e3500000 cmp r0, #0 <== NOT EXECUTED
int sigaddset(
sigset_t *set,
int signo
)
{
30009e28: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
30009e2c: 0a000004 beq 30009e44 <sigaddset+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
30009e30: e3510000 cmp r1, #0 <== NOT EXECUTED 30009e34: 0a000002 beq 30009e44 <sigaddset+0x20> <== NOT EXECUTED 30009e38: e2411001 sub r1, r1, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(signo) )
30009e3c: e351001f cmp r1, #31 <== NOT EXECUTED 30009e40: 9a000004 bls 30009e58 <sigaddset+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009e44: eb002118 bl 300122ac <__errno> <== NOT EXECUTED
30009e48: e3a03016 mov r3, #22 <== NOT EXECUTED
30009e4c: e5803000 str r3, [r0] <== NOT EXECUTED
30009e50: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009e54: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
*set |= signo_to_mask(signo);
30009e58: e5903000 ldr r3, [r0] <== NOT EXECUTED 30009e5c: e3a02001 mov r2, #1 <== NOT EXECUTED 30009e60: e1831112 orr r1, r3, r2, lsl r1 <== NOT EXECUTED 30009e64: e5801000 str r1, [r0] <== NOT EXECUTED
return 0;
30009e68: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30009e6c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000bf64 <sigdelset>:
int sigdelset(
sigset_t *set,
int signo
)
{
if ( !set )
3000bf64: e3500000 cmp r0, #0 <== NOT EXECUTED
int sigdelset(
sigset_t *set,
int signo
)
{
3000bf68: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000bf6c: 0a000004 beq 3000bf84 <sigdelset+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000bf70: e3510000 cmp r1, #0 <== NOT EXECUTED 3000bf74: 0a00000d beq 3000bfb0 <sigdelset+0x4c> <== NOT EXECUTED 3000bf78: e2411001 sub r1, r1, #1 <== NOT EXECUTED
return 0;
if ( !is_valid_signo(signo) )
3000bf7c: e351001f cmp r1, #31 <== NOT EXECUTED 3000bf80: 9a000004 bls 3000bf98 <sigdelset+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000bf84: eb002171 bl 30014550 <__errno> <== NOT EXECUTED
3000bf88: e3a03016 mov r3, #22 <== NOT EXECUTED
3000bf8c: e5803000 str r3, [r0] <== NOT EXECUTED
3000bf90: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000bf94: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
*set &= ~signo_to_mask(signo);
3000bf98: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000bf9c: e3a02001 mov r2, #1 <== NOT EXECUTED 3000bfa0: e1c31112 bic r1, r3, r2, lsl r1 <== NOT EXECUTED 3000bfa4: e5801000 str r1, [r0] <== NOT EXECUTED
return 0;
3000bfa8: e3a00000 mov r0, #0 <== NOT EXECUTED
3000bfac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
return 0;
3000bfb0: e1a00001 mov r0, r1 <== NOT EXECUTED
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
*set &= ~signo_to_mask(signo);
return 0;
}
3000bfb4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000e96c <sigemptyset>:
int sigemptyset(
sigset_t *set
)
{
if ( !set )
3000e96c: e2503000 subs r3, r0, #0
#include <rtems/seterr.h>
int sigemptyset(
sigset_t *set
)
{
3000e970: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( !set )
3000e974: 1a000004 bne 3000e98c <sigemptyset+0x20>
rtems_set_errno_and_return_minus_one( EINVAL );
3000e978: eb0009d1 bl 300110c4 <__errno> <== NOT EXECUTED
3000e97c: e3a03016 mov r3, #22 <== NOT EXECUTED
3000e980: e5803000 str r3, [r0] <== NOT EXECUTED
3000e984: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000e988: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
*set = 0;
3000e98c: e3a00000 mov r0, #0 3000e990: e5830000 str r0, [r3]
return 0; }
3000e994: e49df004 pop {pc} ; (ldr pc, [sp], #4)
3000bfe4 <sigfillset>:
int sigfillset(
sigset_t *set
)
{
if ( !set )
3000bfe4: e3500000 cmp r0, #0 <== NOT EXECUTED
#include <rtems/seterr.h>
int sigfillset(
sigset_t *set
)
{
3000bfe8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000bfec: 1a000004 bne 3000c004 <sigfillset+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000bff0: eb002156 bl 30014550 <__errno> <== NOT EXECUTED
3000bff4: e3a03016 mov r3, #22 <== NOT EXECUTED
3000bff8: e5803000 str r3, [r0] <== NOT EXECUTED
3000bffc: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000c000: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
*set = SIGNAL_ALL_MASK;
3000c004: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000c008: e5803000 str r3, [r0] <== NOT EXECUTED
return 0;
3000c00c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000c010: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c014 <sigismember>:
int sigismember(
const sigset_t *set,
int signo
)
{
if ( !set )
3000c014: e3500000 cmp r0, #0 <== NOT EXECUTED
int sigismember(
const sigset_t *set,
int signo
)
{
3000c018: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000c01c: 0a000004 beq 3000c034 <sigismember+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000c020: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c024: 0a00000d beq 3000c060 <sigismember+0x4c> <== NOT EXECUTED 3000c028: e2411001 sub r1, r1, #1 <== NOT EXECUTED
return 0;
if ( !is_valid_signo(signo) )
3000c02c: e351001f cmp r1, #31 <== NOT EXECUTED 3000c030: 9a000004 bls 3000c048 <sigismember+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000c034: eb002145 bl 30014550 <__errno> <== NOT EXECUTED
3000c038: e3a03016 mov r3, #22 <== NOT EXECUTED
3000c03c: e5803000 str r3, [r0] <== NOT EXECUTED
3000c040: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000c044: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( *set & signo_to_mask(signo) )
3000c048: e5903000 ldr r3, [r0] <== NOT EXECUTED
const sigset_t *set,
int signo
)
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
3000c04c: e3a02001 mov r2, #1 <== NOT EXECUTED
3000c050: e0133112 ands r3, r3, r2, lsl r1 <== NOT EXECUTED
3000c054: 03a00000 moveq r0, #0 <== NOT EXECUTED
3000c058: 13a00001 movne r0, #1 <== NOT EXECUTED
3000c05c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !signo )
return 0;
3000c060: e1a00001 mov r0, r1 <== NOT EXECUTED
if ( *set & signo_to_mask(signo) )
return 1;
return 0;
}
3000c064: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009c28 <signal>:
sighandler_t signal(
int signum,
sighandler_t handler
)
{
30009c28: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30009c2c: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
struct sigaction s;
struct sigaction old;
s.sa_handler = handler ;
sigemptyset(&s.sa_mask);
30009c30: e28d500c add r5, sp, #12 <== NOT EXECUTED
sighandler_t signal(
int signum,
sighandler_t handler
)
{
30009c34: e1a04000 mov r4, r0 <== NOT EXECUTED
struct sigaction s;
struct sigaction old;
s.sa_handler = handler ;
sigemptyset(&s.sa_mask);
30009c38: e2850004 add r0, r5, #4 <== NOT EXECUTED
)
{
struct sigaction s;
struct sigaction old;
s.sa_handler = handler ;
30009c3c: e58d1014 str r1, [sp, #20] <== NOT EXECUTED
sigemptyset(&s.sa_mask);
30009c40: ebffffed bl 30009bfc <sigemptyset> <== NOT EXECUTED
s.sa_flags = SA_RESTART | SA_INTERRUPT | SA_NOMASK; s.sa_restorer= NULL ; #elif defined(signal_like_SVR4) s.sa_flags = SA_RESTART; #else s.sa_flags = 0;
30009c44: e3a03000 mov r3, #0 <== NOT EXECUTED
#endif
sigaction( signum, &s, &old );
30009c48: e1a00004 mov r0, r4 <== NOT EXECUTED 30009c4c: e1a01005 mov r1, r5 <== NOT EXECUTED 30009c50: e1a0200d mov r2, sp <== NOT EXECUTED
s.sa_flags = SA_RESTART | SA_INTERRUPT | SA_NOMASK; s.sa_restorer= NULL ; #elif defined(signal_like_SVR4) s.sa_flags = SA_RESTART; #else s.sa_flags = 0;
30009c54: e58d300c str r3, [sp, #12] <== NOT EXECUTED
#endif
sigaction( signum, &s, &old );
30009c58: ebffffa1 bl 30009ae4 <sigaction> <== NOT EXECUTED
return (sighandler_t) old.sa_handler; }
30009c5c: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
30009c60: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30009c64: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30009e9c <sigpending>:
sigset_t *set
)
{
POSIX_API_Control *api;
if ( !set )
30009e9c: e3500000 cmp r0, #0 <== NOT EXECUTED
#include <rtems/seterr.h>
int sigpending(
sigset_t *set
)
{
30009ea0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set )
30009ea4: 1a000004 bne 30009ebc <sigpending+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009ea8: eb0020ff bl 300122ac <__errno> <== NOT EXECUTED
30009eac: e3a03016 mov r3, #22 <== NOT EXECUTED
30009eb0: e5803000 str r3, [r0] <== NOT EXECUTED
30009eb4: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009eb8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30009ebc: e59f3020 ldr r3, [pc, #32] ; 30009ee4 <sigpending+0x48> <== NOT EXECUTED
*set = api->signals_pending | _POSIX_signals_Pending;
30009ec0: e59f2020 ldr r2, [pc, #32] ; 30009ee8 <sigpending+0x4c> <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30009ec4: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
*set = api->signals_pending | _POSIX_signals_Pending;
30009ec8: e5922000 ldr r2, [r2] <== NOT EXECUTED 30009ecc: e59330fc ldr r3, [r3, #252] ; 0xfc <== NOT EXECUTED 30009ed0: e59330d4 ldr r3, [r3, #212] ; 0xd4 <== NOT EXECUTED 30009ed4: e1823003 orr r3, r2, r3 <== NOT EXECUTED 30009ed8: e5803000 str r3, [r0] <== NOT EXECUTED
return 0;
30009edc: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30009ee0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009eec <sigprocmask>:
/*
* P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask.
*/
#if defined(RTEMS_POSIX_API)
return pthread_sigmask( how, set, oset );
30009eec: ea001761 b 3000fc78 <pthread_sigmask> <== NOT EXECUTED
3000c0bc <sigqueue>:
int sigqueue(
pid_t pid,
int signo,
const union sigval value
)
{
3000c0bc: e92d4001 push {r0, lr} <== NOT EXECUTED
3000c0c0: e28d3004 add r3, sp, #4 <== NOT EXECUTED
3000c0c4: e5232004 str r2, [r3, #-4]! <== NOT EXECUTED
return killinfo( pid, signo, &value );
3000c0c8: e1a0200d mov r2, sp <== NOT EXECUTED 3000c0cc: eb001601 bl 300118d8 <killinfo> <== NOT EXECUTED
}
3000c0d0: e8bd8008 pop {r3, pc} <== NOT EXECUTED
3000c0d4 <sigsuspend>:
#include <rtems/seterr.h>
int sigsuspend(
const sigset_t *sigmask
)
{
3000c0d4: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
3000c0d8: e1a05000 mov r5, r0 <== NOT EXECUTED
/* * We use SIG_BLOCK and not SIG_SETMASK because there may be * signals which might be pending, which might get caught here. * We want the signals to be caught inside sigtimedwait. */ status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked );
3000c0dc: e28d4004 add r4, sp, #4 <== NOT EXECUTED 3000c0e0: e1a01005 mov r1, r5 <== NOT EXECUTED 3000c0e4: e1a02004 mov r2, r4 <== NOT EXECUTED 3000c0e8: e3a00001 mov r0, #1 <== NOT EXECUTED 3000c0ec: ebfffff1 bl 3000c0b8 <sigprocmask> <== NOT EXECUTED
current_unblocked_signals = ~(*sigmask);
3000c0f0: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000c0f4: e28d0008 add r0, sp, #8 <== NOT EXECUTED 3000c0f8: e1e03003 mvn r3, r3 <== NOT EXECUTED
status = sigtimedwait( ¤t_unblocked_signals, NULL, NULL );
3000c0fc: e3a01000 mov r1, #0 <== NOT EXECUTED
* signals which might be pending, which might get caught here.
* We want the signals to be caught inside sigtimedwait.
*/
status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked );
current_unblocked_signals = ~(*sigmask);
3000c100: e5203008 str r3, [r0, #-8]! <== NOT EXECUTED
status = sigtimedwait( ¤t_unblocked_signals, NULL, NULL );
3000c104: e1a02001 mov r2, r1 <== NOT EXECUTED 3000c108: e1a0000d mov r0, sp <== NOT EXECUTED 3000c10c: eb00001a bl 3000c17c <sigtimedwait> <== NOT EXECUTED
(void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL );
3000c110: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c114: e1a01004 mov r1, r4 <== NOT EXECUTED 3000c118: e1a02000 mov r2, r0 <== NOT EXECUTED 3000c11c: ebffffe5 bl 3000c0b8 <sigprocmask> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
assert( status != -1 );
#endif
rtems_set_errno_and_return_minus_one( EINTR );
3000c120: eb00210a bl 30014550 <__errno> <== NOT EXECUTED 3000c124: e3a03004 mov r3, #4 <== NOT EXECUTED 3000c128: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000c12c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000c130: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED
3000a1e8 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
3000a1e8: e92d45ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
3000a1ec: e2506000 subs r6, r0, #0 <== NOT EXECUTED
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
3000a1f0: e1a04001 mov r4, r1 <== NOT EXECUTED 3000a1f4: e1a05002 mov r5, r2 <== NOT EXECUTED
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
3000a1f8: 0a000009 beq 3000a224 <sigtimedwait+0x3c> <== NOT EXECUTED
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
3000a1fc: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a200: 0a00000a beq 3000a230 <sigtimedwait+0x48> <== NOT EXECUTED
if ( !_Timespec_Is_valid( timeout ) )
3000a204: e1a00002 mov r0, r2 <== NOT EXECUTED 3000a208: eb000d6d bl 3000d7c4 <_Timespec_Is_valid> <== NOT EXECUTED 3000a20c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a210: 0a000003 beq 3000a224 <sigtimedwait+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
3000a214: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a218: eb000d8c bl 3000d850 <_Timespec_To_ticks> <== NOT EXECUTED
if ( !interval )
3000a21c: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000a220: 1a000003 bne 3000a234 <sigtimedwait+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000a224: eb0021c7 bl 30012948 <__errno> <== NOT EXECUTED 3000a228: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a22c: ea000057 b 3000a390 <sigtimedwait+0x1a8> <== NOT EXECUTED
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
3000a230: e1a01002 mov r1, r2 <== NOT EXECUTED
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
the_thread = _Thread_Executing;
3000a234: e59f3168 ldr r3, [pc, #360] ; 3000a3a4 <sigtimedwait+0x1bc><== NOT EXECUTED
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
3000a238: e3540000 cmp r4, #0 <== NOT EXECUTED
the_thread = _Thread_Executing;
3000a23c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
3000a240: 028d4004 addeq r4, sp, #4 <== NOT EXECUTED
the_thread = _Thread_Executing;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000a244: e59380fc ldr r8, [r3, #252] ; 0xfc <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a248: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000a24c: e3872080 orr r2, r7, #128 ; 0x80 <== NOT EXECUTED 3000a250: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
*/
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
3000a254: e5962000 ldr r2, [r6] <== NOT EXECUTED 3000a258: e59800d4 ldr r0, [r8, #212] ; 0xd4 <== NOT EXECUTED 3000a25c: e012a000 ands sl, r2, r0 <== NOT EXECUTED 3000a260: 0a00000e beq 3000a2a0 <sigtimedwait+0xb8> <== NOT EXECUTED
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
3000a264: ebffffcd bl 3000a1a0 <_POSIX_signals_Get_lowest> <== NOT EXECUTED
_POSIX_signals_Clear_signals(
3000a268: e3a03000 mov r3, #0 <== NOT EXECUTED
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
3000a26c: e5840000 str r0, [r4] <== NOT EXECUTED 3000a270: e1a01000 mov r1, r0 <== NOT EXECUTED
_POSIX_signals_Clear_signals(
3000a274: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a278: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a27c: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a280: eb001698 bl 3000fce8 <_POSIX_signals_Clear_signals> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a284: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
3000a288: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a28c: e5843004 str r3, [r4, #4] <== NOT EXECUTED
the_info->si_value.sival_int = 0;
3000a290: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a294: e5843008 str r3, [r4, #8] <== NOT EXECUTED
return the_info->si_signo;
3000a298: e5945000 ldr r5, [r4] <== NOT EXECUTED 3000a29c: ea00003d b 3000a398 <sigtimedwait+0x1b0> <== NOT EXECUTED
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
3000a2a0: e59f0100 ldr r0, [pc, #256] ; 3000a3a8 <sigtimedwait+0x1c0><== NOT EXECUTED 3000a2a4: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000a2a8: e1120000 tst r2, r0 <== NOT EXECUTED 3000a2ac: 0a00000e beq 3000a2ec <sigtimedwait+0x104> <== NOT EXECUTED
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
3000a2b0: ebffffba bl 3000a1a0 <_POSIX_signals_Get_lowest> <== NOT EXECUTED 3000a2b4: e1a05000 mov r5, r0 <== NOT EXECUTED
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
3000a2b8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a2bc: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a2c0: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a2c4: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a2c8: e58da000 str sl, [sp] <== NOT EXECUTED 3000a2cc: eb001685 bl 3000fce8 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 3000a2d0: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
the_info->si_signo = signo;
the_info->si_code = SI_USER;
3000a2d4: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a2d8: e5843004 str r3, [r4, #4] <== NOT EXECUTED
the_info->si_value.sival_int = 0;
3000a2dc: e3a03000 mov r3, #0 <== NOT EXECUTED
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
_ISR_Enable( level );
the_info->si_signo = signo;
3000a2e0: e5845000 str r5, [r4] <== NOT EXECUTED
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
3000a2e4: e5843008 str r3, [r4, #8] <== NOT EXECUTED
return signo;
3000a2e8: ea00002a b 3000a398 <sigtimedwait+0x1b0> <== NOT EXECUTED
}
the_info->si_signo = -1;
3000a2ec: e3e02000 mvn r2, #0 <== NOT EXECUTED 3000a2f0: e5842000 str r2, [r4] <== NOT EXECUTED 3000a2f4: e59f20b0 ldr r2, [pc, #176] ; 3000a3ac <sigtimedwait+0x1c4><== NOT EXECUTED 3000a2f8: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000a2fc: e2800001 add r0, r0, #1 <== NOT EXECUTED 3000a300: e5820000 str r0, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
3000a304: e3a00004 mov r0, #4 <== NOT EXECUTED 3000a308: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
the_thread->Wait.option = *set;
3000a30c: e5960000 ldr r0, [r6] <== NOT EXECUTED
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
3000a310: e59f2098 ldr r2, [pc, #152] ; 3000a3b0 <sigtimedwait+0x1c8><== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
3000a314: e5830030 str r0, [r3, #48] ; 0x30 <== NOT EXECUTED
the_thread->Wait.return_argument = the_info;
3000a318: e5834028 str r4, [r3, #40] ; 0x28 <== NOT EXECUTED
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
3000a31c: e5832044 str r2, [r3, #68] ; 0x44 <== 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;
3000a320: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a324: e5823030 str r3, [r2, #48] ; 0x30 <== NOT EXECUTED 3000a328: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
the_thread->Wait.return_argument = the_info;
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
3000a32c: e59f007c ldr r0, [pc, #124] ; 3000a3b0 <sigtimedwait+0x1c8><== NOT EXECUTED 3000a330: e59f207c ldr r2, [pc, #124] ; 3000a3b4 <sigtimedwait+0x1cc><== NOT EXECUTED 3000a334: eb000b8f bl 3000d178 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a338: eb000a69 bl 3000cce4 <_Thread_Enable_dispatch> <== NOT EXECUTED
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false );
3000a33c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a340: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a344: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a348: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000a34c: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a350: eb001664 bl 3000fce8 <_POSIX_signals_Clear_signals> <== NOT EXECUTED
/* Set errno only if return code is not EINTR or
* if EINTR was caused by a signal being caught, which
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
3000a354: e59f3048 ldr r3, [pc, #72] ; 3000a3a4 <sigtimedwait+0x1bc> <== NOT EXECUTED 3000a358: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000a35c: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000a360: e3530004 cmp r3, #4 <== NOT EXECUTED 3000a364: 1a000005 bne 3000a380 <sigtimedwait+0x198> <== NOT EXECUTED
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
3000a368: e5945000 ldr r5, [r4] <== NOT EXECUTED 3000a36c: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000a370: e2452001 sub r2, r5, #1 <== NOT EXECUTED 3000a374: e3a01001 mov r1, #1 <== NOT EXECUTED 3000a378: e0133211 ands r3, r3, r1, lsl r2 <== NOT EXECUTED 3000a37c: 1a000005 bne 3000a398 <sigtimedwait+0x1b0> <== NOT EXECUTED
errno = _Thread_Executing->Wait.return_code;
3000a380: eb002170 bl 30012948 <__errno> <== NOT EXECUTED 3000a384: e59f3018 ldr r3, [pc, #24] ; 3000a3a4 <sigtimedwait+0x1bc> <== NOT EXECUTED 3000a388: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000a38c: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000a390: e5803000 str r3, [r0] <== NOT EXECUTED
return -1;
3000a394: e3e05000 mvn r5, #0 <== NOT EXECUTED
}
return the_info->si_signo;
}
3000a398: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a39c: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000a3a0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000c354 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
3000c354: e92d4010 push {r4, lr} <== NOT EXECUTED
3000c358: e1a04001 mov r4, r1 <== NOT EXECUTED
int status;
status = sigtimedwait( set, NULL, NULL );
3000c35c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c360: e1a02001 mov r2, r1 <== NOT EXECUTED 3000c364: ebffff84 bl 3000c17c <sigtimedwait> <== NOT EXECUTED
if ( status != -1 ) {
3000c368: e3700001 cmn r0, #1 <== NOT EXECUTED 3000c36c: 0a000004 beq 3000c384 <sigwait+0x30> <== NOT EXECUTED
if ( sig )
3000c370: e3540000 cmp r4, #0 <== NOT EXECUTED
*sig = status;
3000c374: 15840000 strne r0, [r4] <== NOT EXECUTED
return 0;
3000c378: 13a00000 movne r0, #0 <== NOT EXECUTED
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
3000c37c: 18bd8010 popne {r4, pc} <== NOT EXECUTED
3000c380: ea000002 b 3000c390 <sigwait+0x3c> <== NOT EXECUTED
*sig = status;
return 0;
}
return errno;
3000c384: eb002071 bl 30014550 <__errno> <== NOT EXECUTED
3000c388: e5900000 ldr r0, [r0] <== NOT EXECUTED
3000c38c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
3000c390: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
3000c394: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c34c <sigwaitinfo>:
int sigwaitinfo(
const sigset_t *set,
siginfo_t *info
)
{
return sigtimedwait( set, info, NULL );
3000c34c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000c350: eaffff89 b 3000c17c <sigtimedwait> <== 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: eb00211c bl 3000f59c <__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: eb002487 bl 30010358 <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: eb002370 bl 3000ff30 <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: eb003122 bl 30015e18 <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: eb002c0b bl 300149f8 <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: eb002b3b bl 30012fe4 <_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: ea000db3 b 3000b9d0 <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: e59030f4 ldr r3, [r0, #244] ; 0xf4 <== 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: e59250f4 ldr r5, [r2, #244] ; 0xf4 <== NOT EXECUTED
_Thread_Executing->libc_reent = this_reent;
300082a4: e58230f4 str r3, [r2, #244] ; 0xf4 <== NOT EXECUTED
_fwalk (t->libc_reent, sync_wrapper);
300082a8: e59000f4 ldr r0, [r0, #244] ; 0xf4 <== NOT EXECUTED 300082ac: eb002b4c bl 30012fe4 <_fwalk> <== NOT EXECUTED
_Thread_Executing->libc_reent = current_reent;
300082b0: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
300082b4: e58350f4 str r5, [r3, #244] ; 0xf4 <== 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: eb002861 bl 30012454 <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
30009094 <sysconf>:
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
30009094: e3500002 cmp r0, #2 <== NOT EXECUTED
*/
long sysconf(
int name
)
{
30009098: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( name == _SC_CLK_TCK )
3000909c: 1a000004 bne 300090b4 <sysconf+0x20> <== NOT EXECUTED
return (TOD_MICROSECONDS_PER_SECOND /
300090a0: e59f304c ldr r3, [pc, #76] ; 300090f4 <sysconf+0x60> <== NOT EXECUTED
300090a4: e59f004c ldr r0, [pc, #76] ; 300090f8 <sysconf+0x64> <== NOT EXECUTED
300090a8: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
300090ac: eb00306e bl 3001526c <__aeabi_uidiv> <== NOT EXECUTED
300090b0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
300090b4: e3500004 cmp r0, #4 <== NOT EXECUTED
return rtems_libio_number_iops;
300090b8: 059f303c ldreq r3, [pc, #60] ; 300090fc <sysconf+0x68> <== NOT EXECUTED 300090bc: 05930000 ldreq r0, [r3] <== NOT EXECUTED
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
300090c0: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
300090c4: e3500033 cmp r0, #51 ; 0x33 <== NOT EXECUTED
return 1024;
300090c8: 03a00b01 moveq r0, #1024 ; 0x400 <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
300090cc: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
return 1024;
if ( name == _SC_PAGESIZE )
300090d0: e3500008 cmp r0, #8 <== NOT EXECUTED 300090d4: 0a000004 beq 300090ec <sysconf+0x58> <== NOT EXECUTED
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
300090d8: eb002155 bl 30011634 <__errno> <== NOT EXECUTED
300090dc: e3a03016 mov r3, #22 <== NOT EXECUTED
300090e0: e5803000 str r3, [r0] <== NOT EXECUTED
300090e4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300090e8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( name == _SC_GETPW_R_SIZE_MAX )
return 1024;
if ( name == _SC_PAGESIZE )
return PAGE_SIZE;
300090ec: e3a00a01 mov r0, #4096 ; 0x1000 <== NOT EXECUTED
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
}
300090f0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ef9c <tcgetattr>:
int tcgetattr(
int fd,
struct termios *tp
)
{
3000ef9c: e1a02001 mov r2, r1 <== NOT EXECUTED
return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp );
3000efa0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000efa4: eaffff30 b 3000ec6c <ioctl> <== NOT EXECUTED
3000efa8 <tcsetattr>:
int fd,
int opt,
struct termios *tp
)
{
switch (opt) {
3000efa8: e3510000 cmp r1, #0 <== NOT EXECUTED
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
3000efac: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000efb0: e1a05000 mov r5, r0 <== NOT EXECUTED
3000efb4: e1a04002 mov r4, r2 <== NOT EXECUTED
switch (opt) {
3000efb8: 0a00000a beq 3000efe8 <tcsetattr+0x40> <== NOT EXECUTED 3000efbc: e3510001 cmp r1, #1 <== NOT EXECUTED 3000efc0: 0a000003 beq 3000efd4 <tcsetattr+0x2c> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000efc4: eb000eb8 bl 30012aac <__errno> <== NOT EXECUTED 3000efc8: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 3000efcc: e5803000 str r3, [r0] <== NOT EXECUTED 3000efd0: ea000009 b 3000effc <tcsetattr+0x54> <== NOT EXECUTED
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
3000efd4: e3a01003 mov r1, #3 <== NOT EXECUTED 3000efd8: e3a02000 mov r2, #0 <== NOT EXECUTED 3000efdc: ebffff22 bl 3000ec6c <ioctl> <== NOT EXECUTED 3000efe0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000efe4: ba000004 blt 3000effc <tcsetattr+0x54> <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
3000efe8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000efec: e3a01002 mov r1, #2 <== NOT EXECUTED 3000eff0: e1a02004 mov r2, r4 <== NOT EXECUTED
} }
3000eff4: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
3000eff8: eaffff1b b 3000ec6c <ioctl> <== NOT EXECUTED
} }
3000effc: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000f000: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
300093fc <timer_create>:
timer_t *timerid
)
{
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
300093fc: e3500001 cmp r0, #1 <== NOT EXECUTED
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
30009400: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30009404: e1a04001 mov r4, r1 <== NOT EXECUTED
30009408: e1a05002 mov r5, r2 <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
3000940c: 1a00000d bne 30009448 <timer_create+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
30009410: e3520000 cmp r2, #0 <== NOT EXECUTED 30009414: 0a00000b beq 30009448 <timer_create+0x4c> <== NOT EXECUTED
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
30009418: e3510000 cmp r1, #0 <== NOT EXECUTED 3000941c: 0a00000c beq 30009454 <timer_create+0x58> <== NOT EXECUTED
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
30009420: e5913000 ldr r3, [r1] <== NOT EXECUTED 30009424: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30009428: e3530001 cmp r3, #1 <== NOT EXECUTED 3000942c: 8a000005 bhi 30009448 <timer_create+0x4c> <== NOT EXECUTED
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
30009430: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 30009434: e3530000 cmp r3, #0 <== NOT EXECUTED 30009438: 0a000002 beq 30009448 <timer_create+0x4c> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000943c: e2433001 sub r3, r3, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
30009440: e353001f cmp r3, #31 <== NOT EXECUTED 30009444: 9a000002 bls 30009454 <timer_create+0x58> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009448: eb00225e bl 30011dc8 <__errno> <== NOT EXECUTED 3000944c: e3a03016 mov r3, #22 <== NOT EXECUTED 30009450: ea00000a b 30009480 <timer_create+0x84> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009454: e59f30b8 ldr r3, [pc, #184] ; 30009514 <timer_create+0x118><== NOT EXECUTED 30009458: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000945c: e2822001 add r2, r2, #1 <== NOT EXECUTED 30009460: e5832000 str r2, [r3] <== NOT EXECUTED
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{
return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
30009464: e59f00ac ldr r0, [pc, #172] ; 30009518 <timer_create+0x11c><== NOT EXECUTED 30009468: eb00073d bl 3000b164 <_Objects_Allocate> <== NOT EXECUTED
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
3000946c: e3500000 cmp r0, #0 <== NOT EXECUTED 30009470: 1a000005 bne 3000948c <timer_create+0x90> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009474: eb000b5a bl 3000c1e4 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
30009478: eb002252 bl 30011dc8 <__errno> <== NOT EXECUTED
3000947c: e3a0300b mov r3, #11 <== NOT EXECUTED
30009480: e5803000 str r3, [r0] <== NOT EXECUTED
30009484: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009488: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
3000948c: e3a03002 mov r3, #2 <== NOT EXECUTED 30009490: e5c0303c strb r3, [r0, #60] ; 0x3c <== NOT EXECUTED
ptimer->thread_id = _Thread_Executing->Object.id;
30009494: e59f3080 ldr r3, [pc, #128] ; 3000951c <timer_create+0x120><== NOT EXECUTED
if ( evp != NULL ) {
30009498: e3540000 cmp r4, #0 <== NOT EXECUTED
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ptimer->thread_id = _Thread_Executing->Object.id;
3000949c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 300094a0: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 300094a4: e5803038 str r3, [r0, #56] ; 0x38 <== NOT EXECUTED
if ( evp != NULL ) {
300094a8: 0a000005 beq 300094c4 <timer_create+0xc8> <== NOT EXECUTED
ptimer->inf.sigev_notify = evp->sigev_notify;
300094ac: e5943000 ldr r3, [r4] <== NOT EXECUTED 300094b0: e5803040 str r3, [r0, #64] ; 0x40 <== NOT EXECUTED
ptimer->inf.sigev_signo = evp->sigev_signo;
300094b4: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 300094b8: e5803044 str r3, [r0, #68] ; 0x44 <== NOT EXECUTED
ptimer->inf.sigev_value = evp->sigev_value;
300094bc: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 300094c0: e5803048 str r3, [r0, #72] ; 0x48 <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300094c4: e59f204c ldr r2, [pc, #76] ; 30009518 <timer_create+0x11c> <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
300094c8: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED 300094cc: e1d010b8 ldrh r1, [r0, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300094d0: e592201c ldr r2, [r2, #28] <== NOT EXECUTED
}
ptimer->overrun = 0;
300094d4: e3a04000 mov r4, #0 <== NOT EXECUTED 300094d8: e5804068 str r4, [r0, #104] ; 0x68 <== NOT EXECUTED
ptimer->timer_data.it_value.tv_sec = 0;
300094dc: e580405c str r4, [r0, #92] ; 0x5c <== NOT EXECUTED
ptimer->timer_data.it_value.tv_nsec = 0;
300094e0: e5804060 str r4, [r0, #96] ; 0x60 <== NOT EXECUTED
ptimer->timer_data.it_interval.tv_sec = 0;
300094e4: e5804054 str r4, [r0, #84] ; 0x54 <== NOT EXECUTED
ptimer->timer_data.it_interval.tv_nsec = 0;
300094e8: e5804058 str r4, [r0, #88] ; 0x58 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
300094ec: e5804018 str r4, [r0, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
300094f0: e580402c str r4, [r0, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
300094f4: e5804030 str r4, [r0, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
300094f8: e5804034 str r4, [r0, #52] ; 0x34 <== NOT EXECUTED 300094fc: e7820101 str r0, [r2, r1, lsl #2] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
30009500: e580400c str r4, [r0, #12] <== NOT EXECUTED
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
30009504: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
30009508: eb000b35 bl 3000c1e4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000950c: e1a00004 mov r0, r4 <== NOT EXECUTED
}
30009510: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30009aa4 <timer_delete>:
int timer_delete(
timer_t timerid
)
{
30009aa4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
30009aa8: e1a01000 mov r1, r0 <== NOT EXECUTED
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
30009aac: e1a0200d mov r2, sp <== NOT EXECUTED 30009ab0: e59f0058 ldr r0, [pc, #88] ; 30009b10 <timer_delete+0x6c> <== NOT EXECUTED 30009ab4: eb0007f9 bl 3000baa0 <_Objects_Get> <== NOT EXECUTED
*/
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
30009ab8: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30009abc: e1a04000 mov r4, r0 <== NOT EXECUTED 30009ac0: e3550000 cmp r5, #0 <== NOT EXECUTED 30009ac4: 1a00000c bne 30009afc <timer_delete+0x58> <== NOT EXECUTED
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Timer_Information, &ptimer->Object );
30009ac8: e1a01004 mov r1, r4 <== NOT EXECUTED 30009acc: e59f003c ldr r0, [pc, #60] ; 30009b10 <timer_delete+0x6c> <== NOT EXECUTED 30009ad0: eb0006f8 bl 3000b6b8 <_Objects_Close> <== NOT EXECUTED
ptimer->state = POSIX_TIMER_STATE_FREE;
30009ad4: e3a03001 mov r3, #1 <== NOT EXECUTED 30009ad8: e5c4303c strb r3, [r4, #60] ; 0x3c <== NOT EXECUTED
(void) _Watchdog_Remove( &ptimer->Timer );
30009adc: e2840010 add r0, r4, #16 <== NOT EXECUTED 30009ae0: eb000efc bl 3000d6d8 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free (
POSIX_Timer_Control *the_timer
)
{
_Objects_Free( &_POSIX_Timer_Information, &the_timer->Object );
30009ae4: e59f0024 ldr r0, [pc, #36] ; 30009b10 <timer_delete+0x6c> <== NOT EXECUTED 30009ae8: e1a01004 mov r1, r4 <== NOT EXECUTED 30009aec: eb000796 bl 3000b94c <_Objects_Free> <== NOT EXECUTED
_POSIX_Timer_Free( ptimer );
_Thread_Enable_dispatch();
30009af0: eb000aee bl 3000c6b0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009af4: e1a00005 mov r0, r5 <== NOT EXECUTED 30009af8: ea000003 b 30009b0c <timer_delete+0x68> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
30009afc: eb0022d7 bl 30012660 <__errno> <== NOT EXECUTED 30009b00: e3a03016 mov r3, #22 <== NOT EXECUTED 30009b04: e5803000 str r3, [r0] <== NOT EXECUTED 30009b08: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
30009b0c: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000a728 <timer_getoverrun>:
* its execution, _POSIX_Timer_TSR will have to set this counter to 0.
*/
int timer_getoverrun(
timer_t timerid
)
{
3000a728: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
3000a72c: e1a01000 mov r1, r0 <== NOT EXECUTED
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
3000a730: e1a0200d mov r2, sp <== NOT EXECUTED 3000a734: e59f0034 ldr r0, [pc, #52] ; 3000a770 <timer_getoverrun+0x48><== NOT EXECUTED 3000a738: eb0007dd bl 3000c6b4 <_Objects_Get> <== NOT EXECUTED
int overrun;
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000a73c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a740: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a744: 1a000003 bne 3000a758 <timer_getoverrun+0x30> <== NOT EXECUTED
case OBJECTS_LOCAL:
overrun = ptimer->overrun;
3000a748: e5904068 ldr r4, [r0, #104] ; 0x68 <== NOT EXECUTED
ptimer->overrun = 0;
3000a74c: e5803068 str r3, [r0, #104] ; 0x68 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a750: eb000adb bl 3000d2c4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return overrun;
3000a754: ea000003 b 3000a768 <timer_getoverrun+0x40> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000a758: eb0021ea bl 30012f08 <__errno> <== NOT EXECUTED 3000a75c: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a760: e5803000 str r3, [r0] <== NOT EXECUTED 3000a764: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
3000a768: e1a00004 mov r0, r4 <== NOT EXECUTED
3000a76c: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000a774 <timer_gettime>:
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
3000a774: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
3000a778: e2514000 subs r4, r1, #0 <== NOT EXECUTED
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
3000a77c: e1a05000 mov r5, r0 <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
3000a780: 0a000017 beq 3000a7e4 <timer_gettime+0x70> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
/* Reads the current time */
_TOD_Get( ¤t_time );
3000a784: e1a0000d mov r0, sp <== NOT EXECUTED 3000a788: eb000553 bl 3000bcdc <_TOD_Get> <== NOT EXECUTED 3000a78c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a790: e59f0060 ldr r0, [pc, #96] ; 3000a7f8 <timer_gettime+0x84> <== NOT EXECUTED 3000a794: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000a798: eb0007c5 bl 3000c6b4 <_Objects_Get> <== NOT EXECUTED
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000a79c: e59d6008 ldr r6, [sp, #8] <== NOT EXECUTED 3000a7a0: e1a05000 mov r5, r0 <== NOT EXECUTED 3000a7a4: e3560000 cmp r6, #0 <== NOT EXECUTED 3000a7a8: 1a00000d bne 3000a7e4 <timer_gettime+0x70> <== NOT EXECUTED
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
3000a7ac: e59f3048 ldr r3, [pc, #72] ; 3000a7fc <timer_gettime+0x88> <== NOT EXECUTED 3000a7b0: e5952024 ldr r2, [r5, #36] ; 0x24 <== NOT EXECUTED 3000a7b4: e590001c ldr r0, [r0, #28] <== NOT EXECUTED 3000a7b8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a7bc: e0800002 add r0, r0, r2 <== NOT EXECUTED
_Watchdog_Ticks_since_boot; /* now */
_Timespec_From_ticks( left, &value->it_value );
3000a7c0: e0630000 rsb r0, r3, r0 <== NOT EXECUTED 3000a7c4: e2841008 add r1, r4, #8 <== NOT EXECUTED 3000a7c8: eb000d75 bl 3000dda4 <_Timespec_From_ticks> <== NOT EXECUTED
value->it_interval = ptimer->timer_data.it_interval;
3000a7cc: e2853054 add r3, r5, #84 ; 0x54 <== NOT EXECUTED
3000a7d0: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000a7d4: e884000c stm r4, {r2, r3} <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a7d8: eb000ab9 bl 3000d2c4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a7dc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a7e0: ea000003 b 3000a7f4 <timer_gettime+0x80> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000a7e4: eb0021c7 bl 30012f08 <__errno> <== NOT EXECUTED 3000a7e8: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a7ec: e5803000 str r3, [r0] <== NOT EXECUTED 3000a7f0: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000a7f4: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
30009520 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
30009520: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
30009524: e2525000 subs r5, r2, #0 <== NOT EXECUTED
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
30009528: e24dd020 sub sp, sp, #32 <== NOT EXECUTED 3000952c: e1a08000 mov r8, r0 <== NOT EXECUTED 30009530: e1a07001 mov r7, r1 <== NOT EXECUTED 30009534: e1a04003 mov r4, r3 <== NOT EXECUTED
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
30009538: 0a000056 beq 30009698 <timer_settime+0x178> <== NOT EXECUTED
/*
* First, it verifies if the structure "value" is correct
* if the number of nanoseconds is not correct return EINVAL
*/
if ( !_Timespec_Is_valid( &(value->it_value) ) ) {
3000953c: e2850008 add r0, r5, #8 <== NOT EXECUTED 30009540: eb000ded bl 3000ccfc <_Timespec_Is_valid> <== NOT EXECUTED 30009544: e3500000 cmp r0, #0 <== NOT EXECUTED 30009548: 0a000052 beq 30009698 <timer_settime+0x178> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
3000954c: e1a00005 mov r0, r5 <== NOT EXECUTED 30009550: eb000de9 bl 3000ccfc <_Timespec_Is_valid> <== NOT EXECUTED 30009554: e3500000 cmp r0, #0 <== NOT EXECUTED 30009558: 0a00004e beq 30009698 <timer_settime+0x178> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
3000955c: e3570000 cmp r7, #0 <== NOT EXECUTED 30009560: 13570004 cmpne r7, #4 <== NOT EXECUTED 30009564: 1a00004b bne 30009698 <timer_settime+0x178> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
30009568: e28d6004 add r6, sp, #4 <== NOT EXECUTED
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
3000956c: e3570004 cmp r7, #4 <== NOT EXECUTED
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
30009570: e895000f ldm r5, {r0, r1, r2, r3} <== NOT EXECUTED
30009574: e886000f stm r6, {r0, r1, r2, r3} <== NOT EXECUTED
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
30009578: 1a00000c bne 300095b0 <timer_settime+0x90> <== NOT EXECUTED
struct timespec now;
_TOD_Get( &now );
3000957c: e28d7014 add r7, sp, #20 <== NOT EXECUTED 30009580: e1a00007 mov r0, r7 <== NOT EXECUTED
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
30009584: e2866008 add r6, r6, #8 <== NOT EXECUTED
normalize = *value;
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
30009588: eb0005a2 bl 3000ac18 <_TOD_Get> <== NOT EXECUTED
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
3000958c: e1a00007 mov r0, r7 <== NOT EXECUTED 30009590: e1a01006 mov r1, r6 <== NOT EXECUTED 30009594: eb000dca bl 3000ccc4 <_Timespec_Greater_than> <== NOT EXECUTED 30009598: e3500000 cmp r0, #0 <== NOT EXECUTED 3000959c: 1a00003d bne 30009698 <timer_settime+0x178> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
300095a0: e1a00007 mov r0, r7 <== NOT EXECUTED 300095a4: e1a01006 mov r1, r6 <== NOT EXECUTED 300095a8: e1a02006 mov r2, r6 <== NOT EXECUTED 300095ac: eb000de3 bl 3000cd40 <_Timespec_Subtract> <== NOT EXECUTED
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
300095b0: e59f00f8 ldr r0, [pc, #248] ; 300096b0 <timer_settime+0x190><== NOT EXECUTED 300095b4: e1a01008 mov r1, r8 <== NOT EXECUTED 300095b8: e28d201c add r2, sp, #28 <== NOT EXECUTED 300095bc: eb000804 bl 3000b5d4 <_Objects_Get> <== NOT EXECUTED
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
300095c0: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 300095c4: e1a06000 mov r6, r0 <== NOT EXECUTED 300095c8: e3530000 cmp r3, #0 <== NOT EXECUTED 300095cc: 1a000031 bne 30009698 <timer_settime+0x178> <== NOT EXECUTED
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
300095d0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 300095d4: e3530000 cmp r3, #0 <== NOT EXECUTED 300095d8: 1a00000f bne 3000961c <timer_settime+0xfc> <== NOT EXECUTED 300095dc: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 300095e0: e3530000 cmp r3, #0 <== NOT EXECUTED 300095e4: 1a00000c bne 3000961c <timer_settime+0xfc> <== NOT EXECUTED
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
300095e8: e2800010 add r0, r0, #16 <== NOT EXECUTED 300095ec: eb000ef4 bl 3000d1c4 <_Watchdog_Remove> <== NOT EXECUTED
/* The old data of the timer are returned */
if ( ovalue )
300095f0: e3540000 cmp r4, #0 <== NOT EXECUTED
*ovalue = ptimer->timer_data;
300095f4: 12863054 addne r3, r6, #84 ; 0x54 <== NOT EXECUTED
300095f8: 1893000f ldmne r3, {r0, r1, r2, r3} <== NOT EXECUTED
300095fc: 1884000f stmne r4, {r0, r1, r2, r3} <== NOT EXECUTED
/* The new data are set */
ptimer->timer_data = normalize;
30009600: e286c054 add ip, r6, #84 ; 0x54 <== NOT EXECUTED
30009604: e28d3004 add r3, sp, #4 <== NOT EXECUTED
30009608: e893000f ldm r3, {r0, r1, r2, r3} <== NOT EXECUTED
3000960c: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
30009610: e3a03004 mov r3, #4 <== NOT EXECUTED 30009614: e5c6303c strb r3, [r6, #60] ; 0x3c <== NOT EXECUTED 30009618: ea00001b b 3000968c <timer_settime+0x16c> <== NOT EXECUTED
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
3000961c: e1a00005 mov r0, r5 <== NOT EXECUTED 30009620: eb000dd8 bl 3000cd88 <_Timespec_To_ticks> <== NOT EXECUTED 30009624: e5860064 str r0, [r6, #100] ; 0x64 <== NOT EXECUTED
initial_period = _Timespec_To_ticks( &normalize.it_value );
30009628: e28d000c add r0, sp, #12 <== NOT EXECUTED 3000962c: eb000dd5 bl 3000cd88 <_Timespec_To_ticks> <== NOT EXECUTED
activated = _POSIX_Timer_Insert_helper(
30009630: e58d6000 str r6, [sp] <== NOT EXECUTED
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
initial_period = _Timespec_To_ticks( &normalize.it_value );
30009634: e1a01000 mov r1, r0 <== NOT EXECUTED
activated = _POSIX_Timer_Insert_helper(
30009638: e5962008 ldr r2, [r6, #8] <== NOT EXECUTED 3000963c: e2860010 add r0, r6, #16 <== NOT EXECUTED 30009640: e59f306c ldr r3, [pc, #108] ; 300096b4 <timer_settime+0x194><== NOT EXECUTED 30009644: eb0017be bl 3000f544 <_POSIX_Timer_Insert_helper> <== NOT EXECUTED
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
30009648: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000964c: 1a000002 bne 3000965c <timer_settime+0x13c> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009650: eb000ae3 bl 3000c1e4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009654: e1a00005 mov r0, r5 <== NOT EXECUTED 30009658: ea000012 b 300096a8 <timer_settime+0x188> <== NOT EXECUTED
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
3000965c: e3540000 cmp r4, #0 <== NOT EXECUTED
*ovalue = ptimer->timer_data;
30009660: 12863054 addne r3, r6, #84 ; 0x54 <== NOT EXECUTED
30009664: 1893000f ldmne r3, {r0, r1, r2, r3} <== NOT EXECUTED
30009668: 1884000f stmne r4, {r0, r1, r2, r3} <== NOT EXECUTED
ptimer->timer_data = normalize;
3000966c: e286c054 add ip, r6, #84 ; 0x54 <== NOT EXECUTED
30009670: e28d3004 add r3, sp, #4 <== NOT EXECUTED
30009674: e893000f ldm r3, {r0, r1, r2, r3} <== NOT EXECUTED
30009678: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
3000967c: e3a03003 mov r3, #3 <== NOT EXECUTED 30009680: e5c6303c strb r3, [r6, #60] ; 0x3c <== NOT EXECUTED
_TOD_Get( &ptimer->time );
30009684: e286006c add r0, r6, #108 ; 0x6c <== NOT EXECUTED 30009688: eb000562 bl 3000ac18 <_TOD_Get> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000968c: eb000ad4 bl 3000c1e4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009690: e3a00000 mov r0, #0 <== NOT EXECUTED 30009694: ea000003 b 300096a8 <timer_settime+0x188> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
30009698: eb0021ca bl 30011dc8 <__errno> <== NOT EXECUTED 3000969c: e3a03016 mov r3, #22 <== NOT EXECUTED 300096a0: e5803000 str r3, [r0] <== NOT EXECUTED 300096a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
300096a8: e28dd020 add sp, sp, #32 <== NOT EXECUTED
300096ac: e8bd81f0 pop {r4, r5, r6, r7, r8, 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: eb00150d bl 300119d4 <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
3000934c <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
3000934c: e92d4073 push {r0, r1, r4, r5, r6, lr} <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
30009350: e59f60d0 ldr r6, [pc, #208] ; 30009428 <ualarm+0xdc> <== NOT EXECUTED
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
30009354: e1a05000 mov r5, r0 <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
30009358: e596401c ldr r4, [r6, #28] <== NOT EXECUTED 3000935c: e3540000 cmp r4, #0 <== NOT EXECUTED 30009360: 1a000005 bne 3000937c <ualarm+0x30> <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30009364: e59f30c0 ldr r3, [pc, #192] ; 3000942c <ualarm+0xe0> <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30009368: e5864008 str r4, [r6, #8] <== NOT EXECUTED
the_watchdog->routine = routine;
3000936c: e586301c str r3, [r6, #28] <== NOT EXECUTED
the_watchdog->id = id;
30009370: e5864020 str r4, [r6, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
30009374: e5864024 str r4, [r6, #36] ; 0x24 <== NOT EXECUTED 30009378: ea000013 b 300093cc <ualarm+0x80> <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
3000937c: e1a00006 mov r0, r6 <== NOT EXECUTED 30009380: eb000e83 bl 3000cd94 <_Watchdog_Remove> <== NOT EXECUTED
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
30009384: e2400002 sub r0, r0, #2 <== NOT EXECUTED 30009388: e3500001 cmp r0, #1 <== NOT EXECUTED
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
3000938c: 83a04000 movhi r4, #0 <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
30009390: 8a00000d bhi 300093cc <ualarm+0x80> <== NOT EXECUTED
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
30009394: e596300c ldr r3, [r6, #12] <== NOT EXECUTED 30009398: e5960014 ldr r0, [r6, #20] <== NOT EXECUTED
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
3000939c: e1a0100d mov r1, sp <== NOT EXECUTED
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
300093a0: e0800003 add r0, r0, r3 <== NOT EXECUTED 300093a4: e5963018 ldr r3, [r6, #24] <== NOT EXECUTED
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
300093a8: e59f4080 ldr r4, [pc, #128] ; 30009430 <ualarm+0xe4> <== NOT EXECUTED
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
300093ac: e0630000 rsb r0, r3, r0 <== NOT EXECUTED 300093b0: eb000d1c bl 3000c828 <_Timespec_From_ticks> <== NOT EXECUTED
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
300093b4: e59d3000 ldr r3, [sp] <== NOT EXECUTED
remaining += tp.tv_nsec / 1000;
300093b8: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 300093bc: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
300093c0: e0040493 mul r4, r3, r4 <== NOT EXECUTED
remaining += tp.tv_nsec / 1000;
300093c4: eb0034b3 bl 30016698 <__aeabi_idiv> <== NOT EXECUTED 300093c8: e0804004 add r4, r0, r4 <== NOT EXECUTED
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
300093cc: e3550000 cmp r5, #0 <== NOT EXECUTED 300093d0: 0a000012 beq 30009420 <ualarm+0xd4> <== NOT EXECUTED
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
300093d4: e1a00005 mov r0, r5 <== NOT EXECUTED 300093d8: e59f1050 ldr r1, [pc, #80] ; 30009430 <ualarm+0xe4> <== NOT EXECUTED 300093dc: eb003467 bl 30016580 <__aeabi_uidiv> <== NOT EXECUTED
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
300093e0: e59f1048 ldr r1, [pc, #72] ; 30009430 <ualarm+0xe4> <== NOT EXECUTED
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
300093e4: e58d0000 str r0, [sp] <== NOT EXECUTED
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
300093e8: e1a00005 mov r0, r5 <== NOT EXECUTED 300093ec: eb0034fb bl 300167e0 <__umodsi3> <== NOT EXECUTED 300093f0: e3a03ffa mov r3, #1000 ; 0x3e8 <== NOT EXECUTED 300093f4: e0030390 mul r3, r0, r3 <== NOT EXECUTED
ticks = _Timespec_To_ticks( &tp );
300093f8: e1a0000d mov r0, sp <== NOT EXECUTED
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
300093fc: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
ticks = _Timespec_To_ticks( &tp );
30009400: eb000d2c bl 3000c8b8 <_Timespec_To_ticks> <== NOT EXECUTED
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
30009404: e1a0000d mov r0, sp <== NOT EXECUTED 30009408: eb000d2a bl 3000c8b8 <_Timespec_To_ticks> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000940c: e59f1014 ldr r1, [pc, #20] ; 30009428 <ualarm+0xdc> <== NOT EXECUTED
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ticks = _Timespec_To_ticks( &tp );
30009410: e1a0500d mov r5, sp <== NOT EXECUTED 30009414: e581000c str r0, [r1, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30009418: e59f0014 ldr r0, [pc, #20] ; 30009434 <ualarm+0xe8> <== NOT EXECUTED 3000941c: eb000e04 bl 3000cc34 <_Watchdog_Insert> <== NOT EXECUTED
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
}
return remaining;
}
30009420: e1a00004 mov r0, r4 <== NOT EXECUTED
30009424: e8bd807c pop {r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
30009420 <uname>:
*/
int uname(
struct utsname *name
)
{
30009420: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
release = 5.3
version = Generic_101318-12
machine = sun4m
*/
if ( !name )
30009424: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30009428: 1a000004 bne 30009440 <uname+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
3000942c: eb0022c9 bl 30011f58 <__errno> <== NOT EXECUTED 30009430: e3a0300e mov r3, #14 <== NOT EXECUTED 30009434: e5803000 str r3, [r0] <== NOT EXECUTED 30009438: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000943c: ea000017 b 300094a0 <uname+0x80> <== NOT EXECUTED
strncpy( name->sysname, "RTEMS", sizeof(name->sysname) );
30009440: e59f105c ldr r1, [pc, #92] ; 300094a4 <uname+0x84> <== NOT EXECUTED 30009444: e3a02020 mov r2, #32 <== NOT EXECUTED 30009448: eb0026e5 bl 30012fe4 <strncpy> <== NOT EXECUTED
snprintf( name->nodename, sizeof(name->nodename), "Node %" PRId16, _Objects_Local_node );
3000944c: e3a03001 mov r3, #1 <== NOT EXECUTED 30009450: e3a01020 mov r1, #32 <== NOT EXECUTED 30009454: e59f204c ldr r2, [pc, #76] ; 300094a8 <uname+0x88> <== NOT EXECUTED 30009458: e2840020 add r0, r4, #32 <== NOT EXECUTED 3000945c: eb002587 bl 30012a80 <snprintf> <== NOT EXECUTED
strncpy( name->release, RTEMS_VERSION, sizeof(name->release) );
30009460: e59f1044 ldr r1, [pc, #68] ; 300094ac <uname+0x8c> <== NOT EXECUTED 30009464: e3a02020 mov r2, #32 <== NOT EXECUTED 30009468: e2840040 add r0, r4, #64 ; 0x40 <== NOT EXECUTED 3000946c: eb0026dc bl 30012fe4 <strncpy> <== NOT EXECUTED
strncpy( name->version, "", sizeof(name->version) );
30009470: e59f1038 ldr r1, [pc, #56] ; 300094b0 <uname+0x90> <== NOT EXECUTED 30009474: e3a02020 mov r2, #32 <== NOT EXECUTED 30009478: e2840060 add r0, r4, #96 ; 0x60 <== NOT EXECUTED 3000947c: eb0026d8 bl 30012fe4 <strncpy> <== NOT EXECUTED
snprintf( name->machine, sizeof(name->machine), "%s/%s", CPU_NAME, CPU_MODEL_NAME );
30009480: e59f302c ldr r3, [pc, #44] ; 300094b4 <uname+0x94> <== NOT EXECUTED 30009484: e2840080 add r0, r4, #128 ; 0x80 <== NOT EXECUTED 30009488: e58d3000 str r3, [sp] <== NOT EXECUTED 3000948c: e3a01020 mov r1, #32 <== NOT EXECUTED 30009490: e59f2020 ldr r2, [pc, #32] ; 300094b8 <uname+0x98> <== NOT EXECUTED 30009494: e59f3020 ldr r3, [pc, #32] ; 300094bc <uname+0x9c> <== NOT EXECUTED 30009498: eb002578 bl 30012a80 <snprintf> <== NOT EXECUTED
return 0;
3000949c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
300094a0: e8bd8018 pop {r3, r4, 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: eb003084 bl 30016028 <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: eb00307e bl 30016028 <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: eb002ca5 bl 3001512c <__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: eb002641 bl 3001394c <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: eb0020b7 bl 3001236c <__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: eb0020a4 bl 3001236c <__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: eb0003e3 bl 3000b0c4 <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: eb0004a5 bl 3000b3e8 <_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: eb0027b3 bl 30013c94 <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: eb0027f9 bl 30013de0 <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
3000946c <vfork>:
#include <unistd.h>
pid_t vfork(void)
{
return -1;
}
3000946c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009470: e12fff1e bx lr <== NOT EXECUTED
30009474 <wait>:
#include <rtems/seterr.h>
int wait(
int *stat_loc
)
{
30009474: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009478: eb002156 bl 300119d8 <__errno> <== NOT EXECUTED 3000947c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009480: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009484: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009488: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000948c <waitpid>:
int waitpid(
pid_t pid,
int *stat_loc,
int options
)
{
3000948c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009490: eb002150 bl 300119d8 <__errno> <== NOT EXECUTED 30009494: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009498: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000949c: e3e00000 mvn r0, #0 <== NOT EXECUTED
300094a0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30016c48 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
30016c48: e92d4030 push {r4, r5, lr}
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30016c4c: e59f4098 ldr r4, [pc, #152] ; 30016cec <write+0xa4> 30016c50: e5944000 ldr r4, [r4] 30016c54: e1500004 cmp r0, r4
30016c58: 2a000006 bcs 30016c78 <write+0x30> iop = rtems_libio_iop( fd );
30016c5c: e59f408c ldr r4, [pc, #140] ; 30016cf0 <write+0xa8> 30016c60: e3a05038 mov r5, #56 ; 0x38 30016c64: e5944000 ldr r4, [r4] 30016c68: e0244095 mla r4, r5, r0, r4
rtems_libio_check_is_open( iop );
30016c6c: e5940014 ldr r0, [r4, #20] 30016c70: e3100c01 tst r0, #256 ; 0x100
30016c74: 1a000002 bne 30016c84 <write+0x3c>
30016c78: ebffe911 bl 300110c4 <__errno> 30016c7c: e3a03009 mov r3, #9 30016c80: ea000003 b 30016c94 <write+0x4c>
rtems_libio_check_buffer( buffer );
30016c84: e3510000 cmp r1, #0
30016c88: 1a000004 bne 30016ca0 <write+0x58>
30016c8c: ebffe90c bl 300110c4 <__errno> <== NOT EXECUTED 30016c90: e3a03016 mov r3, #22 <== NOT EXECUTED
30016c94: e5803000 str r3, [r0]
30016c98: e3e00000 mvn r0, #0
30016c9c: e8bd8030 pop {r4, r5, pc}
rtems_libio_check_count( count );
30016ca0: e3520000 cmp r2, #0
30016ca4: 0a00000e beq 30016ce4 <write+0x9c> rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30016ca8: e3100004 tst r0, #4
30016cac: 0afffff6 beq 30016c8c <write+0x44>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
30016cb0: e5943020 ldr r3, [r4, #32] 30016cb4: e1a00004 mov r0, r4 30016cb8: e1a0e00f mov lr, pc 30016cbc: e593f00c ldr pc, [r3, #12]
if ( rc > 0 )
30016cc0: e3500000 cmp r0, #0
30016cc4: d8bd8030 pople {r4, r5, pc}
iop->offset += rc;
30016cc8: e284300c add r3, r4, #12
30016ccc: e893000c ldm r3, {r2, r3}
30016cd0: e0922000 adds r2, r2, r0
30016cd4: e0a33fc0 adc r3, r3, r0, asr #31
30016cd8: e584200c str r2, [r4, #12]
30016cdc: e5843010 str r3, [r4, #16]
30016ce0: 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 );
30016ce4: e1a00002 mov r0, r2
if ( rc > 0 )
iop->offset += rc;
return rc;
}
30016ce8: 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: eb001fc2 bl 30012058 <__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: eb001fa1 bl 30012058 <__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