30006c78 <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 );
30006c78: e3a03000 mov r3, #0 <== NOT EXECUTED 30006c7c: e5803084 str r3, [r0, #132] ; 0x84 <== NOT EXECUTED 30006c80: e5803088 str r3, [r0, #136] ; 0x88 <== NOT EXECUTED
#else
the_thread->cpu_time_used = 0;
#endif
}
30006c84: e12fff1e bx lr <== NOT EXECUTED
3000da2c <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 ) {
3000da2c: e5903000 ldr r3, [r0]
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
3000da30: e5902010 ldr r2, [r0, #16]
switch( node->type ) {
3000da34: e593304c ldr r3, [r3, #76] ; 0x4c
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
3000da38: e5922034 ldr r2, [r2, #52] ; 0x34
switch( node->type ) {
3000da3c: e2433001 sub r3, r3, #1 3000da40: e3530006 cmp r3, #6 3000da44: 979ff103 ldrls pc, [pc, r3, lsl #2]
3000da48: ea000008 b 3000da70 <IMFS_Set_handlers+0x44> <== NOT EXECUTED 3000da4c: 3000da98 .word 0x3000da98 <== NOT EXECUTED 3000da50: 3000daa8 .word 0x3000daa8 <== NOT EXECUTED 3000da54: 3000da88 .word 0x3000da88 <== NOT EXECUTED 3000da58: 3000da88 .word 0x3000da88 <== NOT EXECUTED 3000da5c: 3000da78 .word 0x3000da78 <== NOT EXECUTED 3000da60: 3000da78 .word 0x3000da78 <== NOT EXECUTED 3000da64: 3000da68 .word 0x3000da68 <== NOT EXECUTED
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
3000da68: e5923010 ldr r3, [r2, #16] <== NOT EXECUTED 3000da6c: e5803008 str r3, [r0, #8] <== NOT EXECUTED
break;
}
return 0;
}
3000da70: e3a00000 mov r0, #0 <== NOT EXECUTED 3000da74: e12fff1e bx lr <== NOT EXECUTED
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
3000da78: e5923008 ldr r3, [r2, #8] 3000da7c: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
3000da80: e3a00000 mov r0, #0 3000da84: e12fff1e bx lr
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
3000da88: e59f3028 ldr r3, [pc, #40] ; 3000dab8 <IMFS_Set_handlers+0x8c> 3000da8c: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
3000da90: e3a00000 mov r0, #0 3000da94: e12fff1e bx lr
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
3000da98: e592300c ldr r3, [r2, #12] 3000da9c: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
3000daa0: e3a00000 mov r0, #0 3000daa4: e12fff1e bx lr
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
3000daa8: e59f300c ldr r3, [pc, #12] ; 3000dabc <IMFS_Set_handlers+0x90> 3000daac: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
3000dab0: e3a00000 mov r0, #0 3000dab4: e12fff1e bx lr
3000d7a8 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
3000d7a8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000d7ac: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
3000d7b0: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
3000d7b4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
3000d7b8: e5904000 ldr r4, [r0] <== NOT EXECUTED
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
3000d7bc: e1a07821 lsr r7, r1, #16 <== NOT EXECUTED 3000d7c0: e1a06822 lsr r6, r2, #16 <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
3000d7c4: eb0003da bl 3000e734 <geteuid> <== NOT EXECUTED
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
3000d7c8: e1d453bc ldrh r5, [r4, #60] ; 0x3c <== NOT EXECUTED 3000d7cc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d7d0: 11550000 cmpne r5, r0 <== NOT EXECUTED 3000d7d4: 03a05000 moveq r5, #0 <== NOT EXECUTED 3000d7d8: 13a05001 movne r5, #1 <== NOT EXECUTED 3000d7dc: 1a000009 bne 3000d808 <IMFS_chown+0x60> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
3000d7e0: e1c473bc strh r7, [r4, #60] ; 0x3c <== NOT EXECUTED
jnode->st_gid = group;
3000d7e4: e1c463be strh r6, [r4, #62] ; 0x3e <== NOT EXECUTED
IMFS_update_ctime( jnode );
3000d7e8: e1a0000d mov r0, sp <== NOT EXECUTED 3000d7ec: e1a01005 mov r1, r5 <== NOT EXECUTED 3000d7f0: ebffe351 bl 3000653c <gettimeofday> <== NOT EXECUTED 3000d7f4: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
3000d7f8: e1a00005 mov r0, r5 <== NOT EXECUTED
#endif
jnode->st_uid = owner;
jnode->st_gid = group;
IMFS_update_ctime( jnode );
3000d7fc: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
3000d800: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000d804: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
3000d808: eb001219 bl 30012074 <__errno> <== NOT EXECUTED 3000d80c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000d810: e5803000 str r3, [r0] <== NOT EXECUTED 3000d814: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000d818: eafffff8 b 3000d800 <IMFS_chown+0x58> <== NOT EXECUTED
3000d89c <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
3000d89c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
3000d8a0: e3500000 cmp r0, #0
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
3000d8a4: e1a04001 mov r4, r1 3000d8a8: e59d7018 ldr r7, [sp, #24]
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
3000d8ac: 01a08000 moveq r8, r0
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
3000d8b0: 0a00002b beq 3000d964 <IMFS_create_node+0xc8>
return NULL;
parent = parent_loc->node_access;
fs_info = parent_loc->mt_entry->fs_info;
3000d8b4: e5901010 ldr r1, [r0, #16]
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
3000d8b8: e3540007 cmp r4, #7
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
parent = parent_loc->node_access;
3000d8bc: e5906000 ldr r6, [r0]
fs_info = parent_loc->mt_entry->fs_info;
3000d8c0: e5915034 ldr r5, [r1, #52] ; 0x34
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
3000d8c4: 0a000028 beq 3000d96c <IMFS_create_node+0xd0>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
3000d8c8: e59f1114 ldr r1, [pc, #276] ; 3000d9e4 <IMFS_create_node+0x148> 3000d8cc: e1a00004 mov r0, r4 3000d8d0: e591c000 ldr ip, [r1] 3000d8d4: e1a01002 mov r1, r2 3000d8d8: e59c202c ldr r2, [ip, #44] ; 0x2c 3000d8dc: e1c32002 bic r2, r3, r2 3000d8e0: ebffffcd bl 3000d81c <IMFS_allocate_node>
if ( !node )
3000d8e4: e2508000 subs r8, r0, #0
3000d8e8: 0a00001d beq 3000d964 <IMFS_create_node+0xc8>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
3000d8ec: e3540001 cmp r4, #1
3000d8f0: 0a00000d beq 3000d92c <IMFS_create_node+0x90>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
3000d8f4: e3540003 cmp r4, #3
3000d8f8: 0a000026 beq 3000d998 <IMFS_create_node+0xfc>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
3000d8fc: e3540004 cmp r4, #4
3000d900: 0a000024 beq 3000d998 <IMFS_create_node+0xfc>
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
3000d904: e3540002 cmp r4, #2
3000d908: 0a00001e beq 3000d988 <IMFS_create_node+0xec>
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
3000d90c: e3540006 cmp r4, #6
3000d910: 0a000023 beq 3000d9a4 <IMFS_create_node+0x108>
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
3000d914: e3540005 cmp r4, #5
3000d918: 0a000028 beq 3000d9c0 <IMFS_create_node+0x124>
node->info.file.size = 0;
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
} else if ( type == IMFS_FIFO ) {
3000d91c: e3540007 cmp r4, #7 <== NOT EXECUTED
node->info.fifo.pipe = NULL;
3000d920: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000d924: 05883050 streq r3, [r8, #80] ; 0x50 <== NOT EXECUTED 3000d928: ea000005 b 3000d944 <IMFS_create_node+0xa8> <== 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 );
3000d92c: e2882054 add r2, r8, #84 ; 0x54
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3000d930: e2883050 add r3, r8, #80 ; 0x50
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000d934: e5882050 str r2, [r8, #80] ; 0x50
head->previous = NULL;
3000d938: e3a02000 mov r2, #0 3000d93c: e5882054 str r2, [r8, #84] ; 0x54
tail->previous = head;
3000d940: e5883058 str r3, [r8, #88] ; 0x58
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
node->st_ino = ++fs_info->ino_count;
3000d944: e5953004 ldr r3, [r5, #4] 3000d948: e2860050 add r0, r6, #80 ; 0x50 3000d94c: e2833001 add r3, r3, #1
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
3000d950: e5886008 str r6, [r8, #8] 3000d954: e1a01008 mov r1, r8
node->st_ino = ++fs_info->ino_count;
3000d958: e5853004 str r3, [r5, #4] 3000d95c: e5883038 str r3, [r8, #56] ; 0x38 3000d960: ebfff2ee bl 3000a520 <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
3000d964: e1a00008 mov r0, r8
3000d968: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
3000d96c: e5950010 ldr r0, [r5, #16] 3000d970: e59f1070 ldr r1, [pc, #112] ; 3000d9e8 <IMFS_create_node+0x14c> 3000d974: e1500001 cmp r0, r1
fs_info->fifo_handlers == &rtems_filesystem_handlers_default )
return NULL;
3000d978: 03a08000 moveq r8, #0
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
3000d97c: 1affffd1 bne 3000d8c8 <IMFS_create_node+0x2c>
node->st_ino = ++fs_info->ino_count;
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
3000d980: e1a00008 mov r0, r8
3000d984: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
} else if ( type == IMFS_HARD_LINK ) {
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
3000d988: e897000c ldm r7, {r2, r3}
3000d98c: e5882050 str r2, [r8, #80] ; 0x50
node->info.device.minor = info->device.minor;
3000d990: e5883054 str r3, [r8, #84] ; 0x54 3000d994: eaffffea b 3000d944 <IMFS_create_node+0xa8>
if ( type == IMFS_DIRECTORY ) {
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
node->info.sym_link.name = info->sym_link.name;
3000d998: e5973000 ldr r3, [r7] 3000d99c: e5883050 str r3, [r8, #80] ; 0x50 3000d9a0: eaffffe7 b 3000d944 <IMFS_create_node+0xa8>
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
3000d9a4: e3a03000 mov r3, #0 3000d9a8: e3a04000 mov r4, #0 3000d9ac: e5883050 str r3, [r8, #80] ; 0x50 3000d9b0: e5884054 str r4, [r8, #84] ; 0x54
node->info.linearfile.direct = 0;
3000d9b4: e3a03000 mov r3, #0 3000d9b8: e5883058 str r3, [r8, #88] ; 0x58 3000d9bc: eaffffe0 b 3000d944 <IMFS_create_node+0xa8>
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
node->info.file.indirect = 0;
3000d9c0: e3a03000 mov r3, #0
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
3000d9c4: e3a01000 mov r1, #0 3000d9c8: e3a02000 mov r2, #0 3000d9cc: e5881050 str r1, [r8, #80] ; 0x50 3000d9d0: e5882054 str r2, [r8, #84] ; 0x54
node->info.file.indirect = 0;
3000d9d4: e5883058 str r3, [r8, #88] ; 0x58
node->info.file.doubly_indirect = 0;
3000d9d8: e588305c str r3, [r8, #92] ; 0x5c
node->info.file.triply_indirect = 0;
3000d9dc: e5883060 str r3, [r8, #96] ; 0x60 3000d9e0: eaffffd7 b 3000d944 <IMFS_create_node+0xa8>
3000db74 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
3000db74: 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 ) ) {
3000db78: e3d25007 bics r5, r2, #7
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
3000db7c: e24dd040 sub sp, sp, #64 ; 0x40 3000db80: e58d2000 str r2, [sp] 3000db84: e1a0a000 mov sl, r0 3000db88: e1a04001 mov r4, r1 3000db8c: e1a07003 mov r7, r3
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 ) ) {
3000db90: 1a000081 bne 3000dd9c <IMFS_eval_path+0x228>
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
3000db94: e5936000 ldr r6, [r3] 3000db98: e28d8004 add r8, sp, #4 3000db9c: e28d903c add r9, sp, #60 ; 0x3c
* 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 );
3000dba0: e1a02008 mov r2, r8 3000dba4: e1a03009 mov r3, r9 3000dba8: e08a0005 add r0, sl, r5 3000dbac: e1a01004 mov r1, r4 3000dbb0: eb0001df bl 3000e334 <IMFS_get_token>
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
3000dbb4: e5973000 ldr r3, [r7]
* 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 );
3000dbb8: e1a0b000 mov fp, r0
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
3000dbbc: 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;
3000dbc0: e59d203c ldr r2, [sp, #60] ; 0x3c
i += len;
if ( !pathloc->node_access )
3000dbc4: 0a00004e beq 3000dd04 <IMFS_eval_path+0x190>
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
3000dbc8: e3500000 cmp r0, #0
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
3000dbcc: e0624004 rsb r4, r2, r4
i += len;
3000dbd0: e0855002 add r5, r5, r2
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
3000dbd4: 1a00000f bne 3000dc18 <IMFS_eval_path+0xa4>
* 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 ) {
3000dbd8: e593204c ldr r2, [r3, #76] ; 0x4c 3000dbdc: e3520001 cmp r2, #1
3000dbe0: 0a000068 beq 3000dd88 <IMFS_eval_path+0x214>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
3000dbe4: e1a00007 mov r0, r7 3000dbe8: ebffff8f bl 3000da2c <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
3000dbec: e59d1000 ldr r1, [sp]
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
3000dbf0: e1a06000 mov r6, r0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
3000dbf4: e1a00007 mov r0, r7 3000dbf8: ebffffb0 bl 3000dac0 <IMFS_evaluate_permission> 3000dbfc: e3500000 cmp r0, #0
3000dc00: 1a000036 bne 3000dce0 <IMFS_eval_path+0x16c>
rtems_set_errno_and_return_minus_one( EACCES );
3000dc04: eb00111a bl 30012074 <__errno> <== NOT EXECUTED 3000dc08: e3a0300d mov r3, #13 <== NOT EXECUTED 3000dc0c: e5803000 str r3, [r0] <== NOT EXECUTED 3000dc10: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000dc14: ea000031 b 3000dce0 <IMFS_eval_path+0x16c> <== NOT EXECUTED
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
3000dc18: e596104c ldr r1, [r6, #76] ; 0x4c 3000dc1c: e3510001 cmp r1, #1
3000dc20: 0a000031 beq 3000dcec <IMFS_eval_path+0x178>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
3000dc24: e35b0003 cmp fp, #3
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;
3000dc28: e1a06003 mov r6, r3
switch( type ) {
3000dc2c: 0a000006 beq 3000dc4c <IMFS_eval_path+0xd8>
3000dc30: e35b0004 cmp fp, #4
3000dc34: 0a000025 beq 3000dcd0 <IMFS_eval_path+0x15c>
3000dc38: e35b0002 cmp fp, #2
3000dc3c: 0a000013 beq 3000dc90 <IMFS_eval_path+0x11c>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
3000dc40: e35b0004 cmp fp, #4
3000dc44: 1affffd5 bne 3000dba0 <IMFS_eval_path+0x2c>
3000dc48: eaffffe2 b 3000dbd8 <IMFS_eval_path+0x64> <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
3000dc4c: e593304c ldr r3, [r3, #76] ; 0x4c 3000dc50: e3530003 cmp r3, #3
3000dc54: 0a00002f beq 3000dd18 <IMFS_eval_path+0x1a4>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
3000dc58: e3530004 cmp r3, #4
3000dc5c: 0a000058 beq 3000ddc4 <IMFS_eval_path+0x250>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
3000dc60: e3530001 cmp r3, #1
3000dc64: 1a000051 bne 3000ddb0 <IMFS_eval_path+0x23c>
/*
* 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 ) {
3000dc68: e596e05c ldr lr, [r6, #92] ; 0x5c 3000dc6c: e35e0000 cmp lr, #0
3000dc70: 1a000047 bne 3000dd94 <IMFS_eval_path+0x220>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
3000dc74: e1a00006 mov r0, r6 3000dc78: e1a01008 mov r1, r8 3000dc7c: eb00018b bl 3000e2b0 <IMFS_find_match_in_dir>
if ( !node )
3000dc80: e2506000 subs r6, r0, #0
3000dc84: 0a00001e beq 3000dd04 <IMFS_eval_path+0x190>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
3000dc88: e5876000 str r6, [r7] 3000dc8c: eaffffc3 b 3000dba0 <IMFS_eval_path+0x2c>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
3000dc90: e59f1154 ldr r1, [pc, #340] ; 3000ddec <IMFS_eval_path+0x278> 3000dc94: e5912000 ldr r2, [r1] 3000dc98: e5922018 ldr r2, [r2, #24] 3000dc9c: e1520003 cmp r2, r3
3000dca0: 0affffbe beq 3000dba0 <IMFS_eval_path+0x2c>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
3000dca4: e597e010 ldr lr, [r7, #16]
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
3000dca8: e59e201c ldr r2, [lr, #28] 3000dcac: e1520003 cmp r2, r3
3000dcb0: 0a00001e beq 3000dd30 <IMFS_eval_path+0x1bc>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
3000dcb4: e5936008 ldr r6, [r3, #8] 3000dcb8: e3560000 cmp r6, #0
3000dcbc: 1afffff1 bne 3000dc88 <IMFS_eval_path+0x114>
rtems_set_errno_and_return_minus_one( ENOENT );
3000dcc0: eb0010eb bl 30012074 <__errno> <== NOT EXECUTED 3000dcc4: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000dcc8: e580b000 str fp, [r0] <== NOT EXECUTED 3000dccc: ea000003 b 3000dce0 <IMFS_eval_path+0x16c> <== NOT EXECUTED
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
3000dcd0: eb0010e7 bl 30012074 <__errno> <== NOT EXECUTED 3000dcd4: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 3000dcd8: e5803000 str r3, [r0] <== NOT EXECUTED 3000dcdc: e3e06000 mvn r6, #0 <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
3000dce0: e1a00006 mov r0, r6
3000dce4: e28dd040 add sp, sp, #64 ; 0x40
3000dce8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
3000dcec: e1a00007 mov r0, r7 3000dcf0: ebffff72 bl 3000dac0 <IMFS_evaluate_permission> 3000dcf4: e3500000 cmp r0, #0
3000dcf8: 0affffc1 beq 3000dc04 <IMFS_eval_path+0x90>
3000dcfc: e5973000 ldr r3, [r7] 3000dd00: eaffffc7 b 3000dc24 <IMFS_eval_path+0xb0>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
if ( !node )
rtems_set_errno_and_return_minus_one( ENOENT );
3000dd04: eb0010da bl 30012074 <__errno> 3000dd08: e3a03002 mov r3, #2 3000dd0c: e5803000 str r3, [r0] 3000dd10: e3e06000 mvn r6, #0 3000dd14: eafffff1 b 3000dce0 <IMFS_eval_path+0x16c>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
IMFS_evaluate_hard_link( pathloc, 0 );
3000dd18: e1a00007 mov r0, r7 <== NOT EXECUTED 3000dd1c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000dd20: ebffff80 bl 3000db28 <IMFS_evaluate_hard_link> <== NOT EXECUTED
node = pathloc->node_access;
3000dd24: e5976000 ldr r6, [r7] <== NOT EXECUTED 3000dd28: e596304c ldr r3, [r6, #76] ; 0x4c <== NOT EXECUTED 3000dd2c: eaffffcb b 3000dc60 <IMFS_eval_path+0xec> <== NOT EXECUTED
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
3000dd30: e28ee008 add lr, lr, #8
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dd34: e28d6028 add r6, sp, #40 ; 0x28
3000dd38: e8be000f ldm lr!, {r0, r1, r2, r3}
3000dd3c: e8a6000f stmia r6!, {r0, r1, r2, r3}
*pathloc = newloc;
3000dd40: e28dc028 add ip, sp, #40 ; 0x28
3000dd44: e8bc000f ldm ip!, {r0, r1, r2, r3}
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dd48: e59ec000 ldr ip, [lr]
*pathloc = newloc;
3000dd4c: e1a0e007 mov lr, r7
3000dd50: e8ae000f stmia lr!, {r0, r1, r2, r3}
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
3000dd54: e59d103c ldr r1, [sp, #60] ; 0x3c
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
3000dd58: e58ec000 str ip, [lr]
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
3000dd5c: e0610005 rsb r0, r1, r5
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dd60: e586c000 str ip, [r6]
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
3000dd64: e08a0000 add r0, sl, r0 3000dd68: e597c00c ldr ip, [r7, #12] 3000dd6c: e0841001 add r1, r4, r1 3000dd70: e59d2000 ldr r2, [sp] 3000dd74: e1a03007 mov r3, r7 3000dd78: e1a0e00f mov lr, pc 3000dd7c: e59cf000 ldr pc, [ip] 3000dd80: e1a06000 mov r6, r0 3000dd84: eaffffd5 b 3000dce0 <IMFS_eval_path+0x16c>
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
3000dd88: e593e05c ldr lr, [r3, #92] ; 0x5c 3000dd8c: e35e0000 cmp lr, #0
3000dd90: 0affff93 beq 3000dbe4 <IMFS_eval_path+0x70>
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dd94: e28ee01c add lr, lr, #28 3000dd98: eaffffe5 b 3000dd34 <IMFS_eval_path+0x1c0>
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
rtems_set_errno_and_return_minus_one( EIO );
3000dd9c: eb0010b4 bl 30012074 <__errno> <== NOT EXECUTED 3000dda0: e3a03005 mov r3, #5 <== NOT EXECUTED 3000dda4: e5803000 str r3, [r0] <== NOT EXECUTED 3000dda8: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000ddac: eaffffcb b 3000dce0 <IMFS_eval_path+0x16c> <== NOT EXECUTED
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000ddb0: eb0010af bl 30012074 <__errno> <== NOT EXECUTED 3000ddb4: e3a03014 mov r3, #20 <== NOT EXECUTED 3000ddb8: e5803000 str r3, [r0] <== NOT EXECUTED 3000ddbc: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000ddc0: eaffffc6 b 3000dce0 <IMFS_eval_path+0x16c> <== NOT EXECUTED
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
3000ddc4: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ddc8: e3a01000 mov r1, #0 <== NOT EXECUTED 3000ddcc: eb000007 bl 3000ddf0 <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 )
3000ddd0: 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 );
3000ddd4: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
3000ddd8: e5973000 ldr r3, [r7] <== NOT EXECUTED
if ( result == -1 )
3000dddc: 0affffbf beq 3000dce0 <IMFS_eval_path+0x16c> <== NOT EXECUTED
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
3000dde0: e1a06003 mov r6, r3 <== NOT EXECUTED 3000dde4: e593304c ldr r3, [r3, #76] ; 0x4c <== NOT EXECUTED 3000dde8: eaffff9c b 3000dc60 <IMFS_eval_path+0xec> <== NOT EXECUTED
3000df58 <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 */
)
{
3000df58: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000df5c: e24dd040 sub sp, sp, #64 ; 0x40
3000df60: e1a06001 mov r6, r1
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
3000df64: e5915000 ldr r5, [r1]
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
3000df68: e1a0a000 mov sl, r0 3000df6c: e58d2000 str r2, [sp]
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
3000df70: eb001429 bl 3001301c <strlen>
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
3000df74: e3a07000 mov r7, #0
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
3000df78: e1a04000 mov r4, r0 3000df7c: e28d8004 add r8, sp, #4
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
3000df80: e1a01004 mov r1, r4 3000df84: e28d303c add r3, sp, #60 ; 0x3c 3000df88: e08a0007 add r0, sl, r7 3000df8c: e1a02008 mov r2, r8 3000df90: eb0000e7 bl 3000e334 <IMFS_get_token>
pathlen -= len;
i += len;
if ( !pathloc->node_access )
3000df94: e5963000 ldr r3, [r6]
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
3000df98: e59db03c ldr fp, [sp, #60] ; 0x3c
i += len;
if ( !pathloc->node_access )
3000df9c: 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 );
3000dfa0: e1a09000 mov r9, r0
pathlen -= len;
3000dfa4: e06b4004 rsb r4, fp, r4
i += len;
if ( !pathloc->node_access )
3000dfa8: 0a000035 beq 3000e084 <IMFS_evaluate_for_make+0x12c>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
3000dfac: e3500000 cmp r0, #0
3000dfb0: 1a000006 bne 3000dfd0 <IMFS_evaluate_for_make+0x78>
pathloc->node_access = node;
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
3000dfb4: eb00102e bl 30012074 <__errno> 3000dfb8: e3a03011 mov r3, #17 3000dfbc: e5803000 str r3, [r0] 3000dfc0: e3e05000 mvn r5, #0
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
3000dfc4: e1a00005 mov r0, r5
3000dfc8: e28dd040 add sp, sp, #64 ; 0x40
3000dfcc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
3000dfd0: e595104c ldr r1, [r5, #76] ; 0x4c 3000dfd4: e3510001 cmp r1, #1
3000dfd8: 0a000044 beq 3000e0f0 <IMFS_evaluate_for_make+0x198>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
3000dfdc: 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;
3000dfe0: e1a05003 mov r5, r3
switch( type ) {
3000dfe4: e3590004 cmp r9, #4 3000dfe8: 979ff109 ldrls pc, [pc, r9, lsl #2]
3000dfec: eaffffe3 b 3000df80 <IMFS_evaluate_for_make+0x28> <== NOT EXECUTED 3000dff0: 3000dfb4 .word 0x3000dfb4 <== NOT EXECUTED 3000dff4: 3000df80 .word 0x3000df80 <== NOT EXECUTED 3000dff8: 3000e054 .word 0x3000e054 <== NOT EXECUTED 3000dffc: 3000e004 .word 0x3000e004 <== NOT EXECUTED 3000e000: 3000e098 .word 0x3000e098 <== NOT EXECUTED
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
3000e004: e593304c ldr r3, [r3, #76] ; 0x4c 3000e008: e3530003 cmp r3, #3
3000e00c: 0a00006a beq 3000e1bc <IMFS_evaluate_for_make+0x264>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
3000e010: e3530004 cmp r3, #4
3000e014: 0a000068 beq 3000e1bc <IMFS_evaluate_for_make+0x264>
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
3000e018: e3550000 cmp r5, #0
3000e01c: 0a00005f beq 3000e1a0 <IMFS_evaluate_for_make+0x248>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
3000e020: e595304c ldr r3, [r5, #76] ; 0x4c 3000e024: e3530001 cmp r3, #1
3000e028: 1a00005c bne 3000e1a0 <IMFS_evaluate_for_make+0x248>
/*
* 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 ) {
3000e02c: e595c05c ldr ip, [r5, #92] ; 0x5c 3000e030: e35c0000 cmp ip, #0
3000e034: 1a00005e bne 3000e1b4 <IMFS_evaluate_for_make+0x25c>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
3000e038: e1a00005 mov r0, r5 3000e03c: e1a01008 mov r1, r8 3000e040: eb00009a bl 3000e2b0 <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
3000e044: e2505000 subs r5, r0, #0
3000e048: 0a000017 beq 3000e0ac <IMFS_evaluate_for_make+0x154>
done = true;
else
pathloc->node_access = node;
3000e04c: e5865000 str r5, [r6] 3000e050: eaffffca b 3000df80 <IMFS_evaluate_for_make+0x28>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
3000e054: e59f1180 ldr r1, [pc, #384] ; 3000e1dc <IMFS_evaluate_for_make+0x284> 3000e058: e5912000 ldr r2, [r1] 3000e05c: e5922018 ldr r2, [r2, #24] 3000e060: e1530002 cmp r3, r2
3000e064: 0affffc5 beq 3000df80 <IMFS_evaluate_for_make+0x28>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
3000e068: e596c010 ldr ip, [r6, #16] 3000e06c: e59c201c ldr r2, [ip, #28] 3000e070: e1530002 cmp r3, r2
3000e074: 0a000023 beq 3000e108 <IMFS_evaluate_for_make+0x1b0>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
3000e078: e5935008 ldr r5, [r3, #8] 3000e07c: e3550000 cmp r5, #0
3000e080: 1afffff1 bne 3000e04c <IMFS_evaluate_for_make+0xf4>
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
if ( !IMFS_is_separator( path[ i ] ) )
rtems_set_errno_and_return_minus_one( ENOENT );
3000e084: eb000ffa bl 30012074 <__errno> <== NOT EXECUTED 3000e088: e3a03002 mov r3, #2 <== NOT EXECUTED 3000e08c: e5803000 str r3, [r0] <== NOT EXECUTED 3000e090: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000e094: eaffffca b 3000dfc4 <IMFS_evaluate_for_make+0x6c> <== NOT EXECUTED
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
3000e098: eb000ff5 bl 30012074 <__errno> <== NOT EXECUTED 3000e09c: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 3000e0a0: e5803000 str r3, [r0] <== NOT EXECUTED 3000e0a4: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000e0a8: eaffffc5 b 3000dfc4 <IMFS_evaluate_for_make+0x6c> <== NOT EXECUTED
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
3000e0ac: e59d303c ldr r3, [sp, #60] ; 0x3c 3000e0b0: e59d1000 ldr r1, [sp] 3000e0b4: e0633007 rsb r3, r3, r7 3000e0b8: e08a3003 add r3, sl, r3 3000e0bc: e5813000 str r3, [r1]
/*
* 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++) {
3000e0c0: e7da0007 ldrb r0, [sl, r7] 3000e0c4: e08a4007 add r4, sl, r7 3000e0c8: e3500000 cmp r0, #0
3000e0cc: 1a000003 bne 3000e0e0 <IMFS_evaluate_for_make+0x188>
3000e0d0: ea000021 b 3000e15c <IMFS_evaluate_for_make+0x204>
3000e0d4: e5f40001 ldrb r0, [r4, #1]! <== NOT EXECUTED 3000e0d8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e0dc: 0a00001e beq 3000e15c <IMFS_evaluate_for_make+0x204> <== NOT EXECUTED
if ( !IMFS_is_separator( path[ i ] ) )
3000e0e0: ebffe4ad bl 3000739c <rtems_filesystem_is_separator> <== NOT EXECUTED 3000e0e4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000e0e8: 1afffff9 bne 3000e0d4 <IMFS_evaluate_for_make+0x17c> <== NOT EXECUTED 3000e0ec: eaffffe4 b 3000e084 <IMFS_evaluate_for_make+0x12c> <== NOT EXECUTED
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
3000e0f0: e1a00006 mov r0, r6 3000e0f4: ebfffe71 bl 3000dac0 <IMFS_evaluate_permission> 3000e0f8: e3500000 cmp r0, #0
3000e0fc: 0a000022 beq 3000e18c <IMFS_evaluate_for_make+0x234>
3000e100: e5963000 ldr r3, [r6] 3000e104: eaffffb4 b 3000dfdc <IMFS_evaluate_for_make+0x84>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
3000e108: e28cc008 add ip, ip, #8
* 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 ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000e10c: e28d4028 add r4, sp, #40 ; 0x28
3000e110: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000e114: e8a4000f stmia r4!, {r0, r1, r2, r3}
*pathloc = newloc;
3000e118: e28de028 add lr, sp, #40 ; 0x28
3000e11c: e8be000f ldm lr!, {r0, r1, r2, r3}
3000e120: e1a0e006 mov lr, r6
* 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 ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000e124: e59cc000 ldr ip, [ip]
*pathloc = newloc;
3000e128: e8ae000f stmia lr!, {r0, r1, r2, r3}
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
3000e12c: e59d003c ldr r0, [sp, #60] ; 0x3c
* 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;
3000e130: e58ec000 str ip, [lr]
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
3000e134: e0600007 rsb r0, r0, r7
* 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 ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000e138: e584c000 str ip, [r4]
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
3000e13c: e596300c ldr r3, [r6, #12] 3000e140: e08a0000 add r0, sl, r0 3000e144: e1a01006 mov r1, r6 3000e148: e59d2000 ldr r2, [sp] 3000e14c: e1a0e00f mov lr, pc 3000e150: e593f004 ldr pc, [r3, #4] 3000e154: e1a05000 mov r5, r0 3000e158: eaffff99 b 3000dfc4 <IMFS_evaluate_for_make+0x6c>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
3000e15c: e1a00006 mov r0, r6 3000e160: ebfffe31 bl 3000da2c <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
3000e164: e5963000 ldr r3, [r6]
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
3000e168: e1a05000 mov r5, r0
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
3000e16c: e593304c ldr r3, [r3, #76] ; 0x4c 3000e170: e3530001 cmp r3, #1
3000e174: 1a000009 bne 3000e1a0 <IMFS_evaluate_for_make+0x248>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
3000e178: e1a00006 mov r0, r6 3000e17c: e3a01003 mov r1, #3 3000e180: ebfffe4e bl 3000dac0 <IMFS_evaluate_permission> 3000e184: e3500000 cmp r0, #0
3000e188: 1affff8d bne 3000dfc4 <IMFS_evaluate_for_make+0x6c>
rtems_set_errno_and_return_minus_one( EACCES );
3000e18c: eb000fb8 bl 30012074 <__errno> 3000e190: e3a0300d mov r3, #13 3000e194: e5803000 str r3, [r0] 3000e198: e3e05000 mvn r5, #0 3000e19c: eaffff88 b 3000dfc4 <IMFS_evaluate_for_make+0x6c>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000e1a0: eb000fb3 bl 30012074 <__errno> <== NOT EXECUTED 3000e1a4: e3a03014 mov r3, #20 <== NOT EXECUTED 3000e1a8: e5803000 str r3, [r0] <== NOT EXECUTED 3000e1ac: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000e1b0: eaffff83 b 3000dfc4 <IMFS_evaluate_for_make+0x6c> <== 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 ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000e1b4: e28cc01c add ip, ip, #28 3000e1b8: eaffffd3 b 3000e10c <IMFS_evaluate_for_make+0x1b4>
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
3000e1bc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000e1c0: e3a01000 mov r1, #0 <== NOT EXECUTED 3000e1c4: ebffff2e bl 3000de84 <IMFS_evaluate_link> <== NOT EXECUTED
if ( result == -1 )
3000e1c8: e3700001 cmn r0, #1 <== NOT EXECUTED
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
3000e1cc: e1a05000 mov r5, r0 <== NOT EXECUTED
if ( result == -1 )
3000e1d0: 0affff7b beq 3000dfc4 <IMFS_evaluate_for_make+0x6c> <== NOT EXECUTED 3000e1d4: e5965000 ldr r5, [r6] <== NOT EXECUTED 3000e1d8: eaffff8e b 3000e018 <IMFS_evaluate_for_make+0xc0> <== NOT EXECUTED
3000db28 <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000db28: 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;
3000db2c: e5903000 ldr r3, [r0] <== NOT EXECUTED
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000db30: 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;
3000db34: e5933050 ldr r3, [r3, #80] ; 0x50 <== NOT EXECUTED
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000db38: 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;
3000db3c: e5803000 str r3, [r0] <== NOT EXECUTED
IMFS_Set_handlers( node );
3000db40: ebffffb9 bl 3000da2c <IMFS_Set_handlers> <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
3000db44: e1a00004 mov r0, r4 <== NOT EXECUTED 3000db48: e1a01005 mov r1, r5 <== NOT EXECUTED 3000db4c: ebffffdb bl 3000dac0 <IMFS_evaluate_permission> <== NOT EXECUTED 3000db50: e3500000 cmp r0, #0 <== NOT EXECUTED 3000db54: 0a000001 beq 3000db60 <IMFS_evaluate_hard_link+0x38> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
3000db58: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000db5c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
3000db60: eb001143 bl 30012074 <__errno> <== NOT EXECUTED
3000db64: e3a0300d mov r3, #13 <== NOT EXECUTED
3000db68: e5803000 str r3, [r0] <== NOT EXECUTED
3000db6c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000db70: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000de84 <IMFS_evaluate_link>:
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000de84: e92d40f0 push {r4, r5, r6, r7, lr}
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
rtems_set_errno_and_return_minus_one( ELOOP );
3000de88: e59f60c4 ldr r6, [pc, #196] ; 3000df54 <IMFS_evaluate_link+0xd0>
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000de8c: e1a05000 mov r5, r0
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
rtems_set_errno_and_return_minus_one( ELOOP );
3000de90: e5963000 ldr r3, [r6]
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000de94: e1a07001 mov r7, r1 3000de98: ea000004 b 3000deb0 <IMFS_evaluate_link+0x2c>
*/
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
3000de9c: e3520004 cmp r2, #4
3000dea0: 0a00001b beq 3000df14 <IMFS_evaluate_link+0x90>
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
3000dea4: e2422003 sub r2, r2, #3 3000dea8: e3520001 cmp r2, #1
3000deac: 8a000014 bhi 3000df04 <IMFS_evaluate_link+0x80>
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000deb0: e1d323b0 ldrh r2, [r3, #48] ; 0x30
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
3000deb4: e5954000 ldr r4, [r5]
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000deb8: e2822001 add r2, r2, #1 3000debc: e1a02802 lsl r2, r2, #16 3000dec0: e1a02822 lsr r2, r2, #16
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
3000dec4: e3520005 cmp r2, #5
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000dec8: e1c323b0 strh r2, [r3, #48] ; 0x30
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
3000decc: 8a000019 bhi 3000df38 <IMFS_evaluate_link+0xb4>
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
3000ded0: e594204c ldr r2, [r4, #76] ; 0x4c 3000ded4: e3520003 cmp r2, #3
3000ded8: 1affffef bne 3000de9c <IMFS_evaluate_link+0x18>
result = IMFS_evaluate_hard_link( node, flags );
3000dedc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000dee0: e1a01007 mov r1, r7 <== NOT EXECUTED 3000dee4: ebffff0f bl 3000db28 <IMFS_evaluate_hard_link> <== NOT EXECUTED
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
3000dee8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000deec: 1a00000d bne 3000df28 <IMFS_evaluate_link+0xa4> <== NOT EXECUTED
3000def0: e594204c ldr r2, [r4, #76] ; 0x4c 3000def4: e5963000 ldr r3, [r6]
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 ) ||
3000def8: e2422003 sub r2, r2, #3 3000defc: e3520001 cmp r2, #1
3000df00: 9affffea bls 3000deb0 <IMFS_evaluate_link+0x2c>
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
3000df04: e3a02000 mov r2, #0
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 ) ||
3000df08: e3a00000 mov r0, #0
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
3000df0c: e1c323b0 strh r2, [r3, #48] ; 0x30
return result;
}
3000df10: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
3000df14: e1a00005 mov r0, r5 3000df18: e1a01007 mov r1, r7 3000df1c: ebffffb3 bl 3000ddf0 <IMFS_evaluate_sym_link>
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
3000df20: e3500000 cmp r0, #0
3000df24: 0afffff1 beq 3000def0 <IMFS_evaluate_link+0x6c>
3000df28: e5963000 ldr r3, [r6] <== NOT EXECUTED
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
3000df2c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000df30: e1c323b0 strh r2, [r3, #48] ; 0x30 <== NOT EXECUTED
return result;
}
3000df34: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
3000df38: e3a02000 mov r2, #0 <== NOT EXECUTED 3000df3c: e1c323b0 strh r2, [r3, #48] ; 0x30 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ELOOP );
3000df40: eb00104b bl 30012074 <__errno> <== NOT EXECUTED
3000df44: e3a0305c mov r3, #92 ; 0x5c <== NOT EXECUTED
3000df48: e5803000 str r3, [r0] <== NOT EXECUTED
3000df4c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000df50: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000dac0 <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 ) )
3000dac0: e3d13007 bics r3, r1, #7
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
3000dac4: e92d4070 push {r4, r5, r6, lr}
3000dac8: e1a05001 mov r5, r1
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
3000dacc: 1a000010 bne 3000db14 <IMFS_evaluate_permission+0x54>
rtems_set_errno_and_return_minus_one( EPERM );
jnode = node->node_access;
3000dad0: e5904000 ldr r4, [r0]
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
3000dad4: eb000316 bl 3000e734 <geteuid> 3000dad8: e1a06000 mov r6, r0
st_gid = getegid();
3000dadc: eb00030f bl 3000e720 <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
3000dae0: e1d433bc ldrh r3, [r4, #60] ; 0x3c 3000dae4: e1530006 cmp r3, r6
flags_to_test <<= 6;
3000dae8: 01a05305 lsleq r5, r5, #6
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
3000daec: 0a000002 beq 3000dafc <IMFS_evaluate_permission+0x3c>
flags_to_test <<= 6;
else if ( st_gid == jnode->st_gid )
3000daf0: e1d433be ldrh r3, [r4, #62] ; 0x3e <== NOT EXECUTED 3000daf4: e1530000 cmp r3, r0 <== NOT EXECUTED
flags_to_test <<= 3;
3000daf8: 01a05185 lsleq r5, r5, #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 )
3000dafc: e5940030 ldr r0, [r4, #48] ; 0x30 3000db00: e0050000 and r0, r5, 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 );
3000db04: e1550000 cmp r5, r0 3000db08: 13a00000 movne r0, #0 3000db0c: 03a00001 moveq r0, #1
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
3000db10: e8bd8070 pop {r4, r5, r6, pc}
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 );
3000db14: eb001156 bl 30012074 <__errno> <== NOT EXECUTED
3000db18: e3a03001 mov r3, #1 <== NOT EXECUTED
3000db1c: e5803000 str r3, [r0] <== NOT EXECUTED
3000db20: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000db24: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000ddf0 <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000ddf0: e92d4070 push {r4, r5, r6, lr}
IMFS_jnode_t *jnode = node->node_access;
3000ddf4: e5906000 ldr r6, [r0]
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000ddf8: e24dd004 sub sp, sp, #4
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
3000ddfc: e5963008 ldr r3, [r6, #8]
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000de00: 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;
3000de04: e5803000 str r3, [r0]
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000de08: 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;
rtems_filesystem_get_sym_start_loc(
3000de0c: e5960050 ldr r0, [r6, #80] ; 0x50 3000de10: e1a0100d mov r1, sp 3000de14: e1a02004 mov r2, r4 3000de18: eb0003b5 bl 3000ecf4 <rtems_filesystem_get_sym_start_loc>
);
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
3000de1c: e59d3000 ldr r3, [sp] 3000de20: e5966050 ldr r6, [r6, #80] ; 0x50 3000de24: e0866003 add r6, r6, r3 3000de28: e1a00006 mov r0, r6 3000de2c: eb00147a bl 3001301c <strlen> 3000de30: e1a02005 mov r2, r5 3000de34: e1a01000 mov r1, r0 3000de38: e1a03004 mov r3, r4 3000de3c: e1a00006 mov r0, r6 3000de40: ebffff4b bl 3000db74 <IMFS_eval_path> 3000de44: e1a06000 mov r6, r0
strlen( &jnode->info.sym_link.name[i] ),
flags,
node
);
IMFS_Set_handlers( node );
3000de48: e1a00004 mov r0, r4 3000de4c: ebfffef6 bl 3000da2c <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
3000de50: e1a00004 mov r0, r4 3000de54: e1a01005 mov r1, r5 3000de58: ebffff18 bl 3000dac0 <IMFS_evaluate_permission> 3000de5c: e3500000 cmp r0, #0
3000de60: 0a000002 beq 3000de70 <IMFS_evaluate_sym_link+0x80>
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
3000de64: e1a00006 mov r0, r6
3000de68: e28dd004 add sp, sp, #4
3000de6c: e8bd8070 pop {r4, r5, r6, pc}
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
3000de70: eb00107f bl 30012074 <__errno> <== NOT EXECUTED 3000de74: e3a0300d mov r3, #13 <== NOT EXECUTED 3000de78: e5803000 str r3, [r0] <== NOT EXECUTED 3000de7c: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000de80: eafffff7 b 3000de64 <IMFS_evaluate_sym_link+0x74> <== NOT EXECUTED
3001163c <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
3001163c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30011640: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
30011644: e5904000 ldr r4, [r0] <== NOT EXECUTED
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
30011648: 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();
3001164c: ebfff438 bl 3000e734 <geteuid> <== NOT EXECUTED
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
30011650: e1d453bc ldrh r5, [r4, #60] ; 0x3c <== NOT EXECUTED 30011654: e3500000 cmp r0, #0 <== NOT EXECUTED 30011658: 11550000 cmpne r5, r0 <== NOT EXECUTED 3001165c: 03a05000 moveq r5, #0 <== NOT EXECUTED 30011660: 13a05001 movne r5, #1 <== NOT EXECUTED 30011664: 1a00000d bne 300116a0 <IMFS_fchmod+0x64> <== 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);
30011668: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
3001166c: 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);
30011670: e3c33eff bic r3, r3, #4080 ; 0xff0 <== NOT EXECUTED 30011674: e3c3300f bic r3, r3, #15 <== NOT EXECUTED
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
30011678: e1836a26 orr r6, r3, r6, lsr #20 <== NOT EXECUTED 3001167c: e5846030 str r6, [r4, #48] ; 0x30 <== NOT EXECUTED
IMFS_update_ctime( jnode );
30011680: e1a0000d mov r0, sp <== NOT EXECUTED 30011684: e1a01005 mov r1, r5 <== NOT EXECUTED 30011688: ebffd3ab bl 3000653c <gettimeofday> <== NOT EXECUTED 3001168c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
30011690: 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 );
30011694: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
30011698: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3001169c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
300116a0: eb000273 bl 30012074 <__errno> <== NOT EXECUTED 300116a4: e3a03001 mov r3, #1 <== NOT EXECUTED 300116a8: e5803000 str r3, [r0] <== NOT EXECUTED 300116ac: e3e00000 mvn r0, #0 <== NOT EXECUTED 300116b0: eafffff8 b 30011698 <IMFS_fchmod+0x5c> <== NOT EXECUTED
300116b4 <IMFS_fdatasync>:
int IMFS_fdatasync(
rtems_libio_t *iop
)
{
return 0;
}
300116b4: e3a00000 mov r0, #0 <== NOT EXECUTED 300116b8: e12fff1e bx lr <== NOT EXECUTED
300072d8 <IMFS_fifo_close>:
}
int IMFS_fifo_close(
rtems_libio_t *iop
)
{
300072d8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int err = 0; IMFS_jnode_t *jnode = iop->pathinfo.node_access;
300072dc: e5905018 ldr r5, [r0, #24] <== NOT EXECUTED
}
int IMFS_fifo_close(
rtems_libio_t *iop
)
{
300072e0: e1a04000 mov r4, r0 <== NOT EXECUTED
int err = 0;
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
pipe_release(&JNODE2PIPE(jnode), iop);
300072e4: e1a01000 mov r1, r0 <== NOT EXECUTED 300072e8: e2850050 add r0, r5, #80 ; 0x50 <== NOT EXECUTED 300072ec: eb002549 bl 30010818 <pipe_release> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_OPEN;
300072f0: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
IMFS_check_node_remove(jnode);
300072f4: e1a00005 mov r0, r5 <== NOT EXECUTED
int err = 0;
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
pipe_release(&JNODE2PIPE(jnode), iop);
iop->flags &= ~LIBIO_FLAGS_OPEN;
300072f8: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED 300072fc: e5843014 str r3, [r4, #20] <== NOT EXECUTED
IMFS_check_node_remove(jnode);
30007300: eb00018b bl 30007934 <IMFS_check_node_remove> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
}
30007304: e3a00000 mov r0, #0 <== NOT EXECUTED
30007308: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000719c <IMFS_fifo_ioctl>:
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
3000719c: e1a03000 mov r3, r0 <== NOT EXECUTED
int err;
if (command == FIONBIO) {
300071a0: e59f0070 ldr r0, [pc, #112] ; 30007218 <IMFS_fifo_ioctl+0x7c><== NOT EXECUTED
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
300071a4: e92d4010 push {r4, lr} <== NOT EXECUTED
int err;
if (command == FIONBIO) {
300071a8: e1510000 cmp r1, r0 <== NOT EXECUTED 300071ac: 0a000007 beq 300071d0 <IMFS_fifo_ioctl+0x34> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
return 0;
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
300071b0: e5930018 ldr r0, [r3, #24] <== NOT EXECUTED 300071b4: e5900050 ldr r0, [r0, #80] ; 0x50 <== NOT EXECUTED 300071b8: eb0027e2 bl 30011148 <pipe_ioctl> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
300071bc: e2502000 subs r2, r0, #0 <== NOT EXECUTED 300071c0: b2624000 rsblt r4, r2, #0 <== NOT EXECUTED 300071c4: ba00000f blt 30007208 <IMFS_fifo_ioctl+0x6c> <== NOT EXECUTED
}
300071c8: e1a00002 mov r0, r2 <== NOT EXECUTED
300071cc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
)
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
300071d0: e3520000 cmp r2, #0 <== NOT EXECUTED 300071d4: 0a00000a beq 30007204 <IMFS_fifo_ioctl+0x68> <== NOT EXECUTED
err = -EFAULT;
else {
if (*(int *)buffer)
300071d8: e5922000 ldr r2, [r2] <== NOT EXECUTED 300071dc: e3520000 cmp r2, #0 <== NOT EXECUTED
iop->flags |= LIBIO_FLAGS_NO_DELAY;
300071e0: 15931014 ldrne r1, [r3, #20] <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
300071e4: 05931014 ldreq r1, [r3, #20] <== NOT EXECUTED
return 0;
300071e8: 13a02000 movne r2, #0 <== NOT EXECUTED
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
300071ec: 13811001 orrne r1, r1, #1 <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
300071f0: 03c11001 biceq r1, r1, #1 <== NOT EXECUTED
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
300071f4: 15831014 strne r1, [r3, #20] <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
300071f8: 05831014 streq r1, [r3, #20] <== NOT EXECUTED
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
}
300071fc: e1a00002 mov r0, r2 <== NOT EXECUTED
30007200: e8bd8010 pop {r4, pc} <== NOT EXECUTED
)
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
30007204: e3a0400e mov r4, #14 <== NOT EXECUTED
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
30007208: eb0034e7 bl 300145ac <__errno> <== NOT EXECUTED 3000720c: e3e02000 mvn r2, #0 <== NOT EXECUTED 30007210: e5804000 str r4, [r0] <== NOT EXECUTED 30007214: eaffffeb b 300071c8 <IMFS_fifo_ioctl+0x2c> <== NOT EXECUTED
3000713c <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
3000713c: e92d4010 push {r4, lr} <== NOT EXECUTED
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
30007140: e590c018 ldr ip, [r0, #24] <== NOT EXECUTED
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
30007144: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
30007148: e59cc050 ldr ip, [ip, #80] ; 0x50 <== NOT EXECUTED 3000714c: e58d0000 str r0, [sp] <== NOT EXECUTED 30007150: e1a0000c mov r0, ip <== NOT EXECUTED 30007154: eb002814 bl 300111ac <pipe_lseek> <== NOT EXECUTED 30007158: e1a02000 mov r2, r0 <== NOT EXECUTED 3000715c: e1a03fc2 asr r3, r2, #31 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30007160: 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);
30007164: e1a04000 mov r4, r0 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30007168: a1a04003 movge r4, r3 <== NOT EXECUTED 3000716c: a1a03002 movge r3, r2 <== NOT EXECUTED 30007170: ba000003 blt 30007184 <IMFS_fifo_lseek+0x48> <== NOT EXECUTED
}
30007174: e1a00003 mov r0, r3 <== NOT EXECUTED
30007178: e1a01004 mov r1, r4 <== NOT EXECUTED
3000717c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30007180: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
IMFS_FIFO_RETURN(err);
30007184: eb003508 bl 300145ac <__errno> <== NOT EXECUTED 30007188: e2644000 rsb r4, r4, #0 <== NOT EXECUTED 3000718c: e5804000 str r4, [r0] <== NOT EXECUTED 30007190: e3e03000 mvn r3, #0 <== NOT EXECUTED 30007194: e3e04000 mvn r4, #0 <== NOT EXECUTED 30007198: eafffff5 b 30007174 <IMFS_fifo_lseek+0x38> <== NOT EXECUTED
3000730c <IMFS_fifo_open>:
uint32_t mode
)
{
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = fifo_open(&JNODE2PIPE(jnode), iop);
3000730c: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
30007310: e92d4010 push {r4, lr} <== NOT EXECUTED
30007314: e1a01000 mov r1, r0 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = fifo_open(&JNODE2PIPE(jnode), iop);
30007318: e2830050 add r0, r3, #80 ; 0x50 <== NOT EXECUTED 3000731c: eb002573 bl 300108f0 <fifo_open> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30007320: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30007324: ba000001 blt 30007330 <IMFS_fifo_open+0x24> <== NOT EXECUTED
}
30007328: e1a00004 mov r0, r4 <== NOT EXECUTED
3000732c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
)
{
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = fifo_open(&JNODE2PIPE(jnode), iop);
IMFS_FIFO_RETURN(err);
30007330: eb00349d bl 300145ac <__errno> <== NOT EXECUTED 30007334: e2644000 rsb r4, r4, #0 <== NOT EXECUTED 30007338: e5804000 str r4, [r0] <== NOT EXECUTED 3000733c: e3e04000 mvn r4, #0 <== NOT EXECUTED 30007340: eafffff8 b 30007328 <IMFS_fifo_open+0x1c> <== NOT EXECUTED
3000727c <IMFS_fifo_read>:
ssize_t IMFS_fifo_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
3000727c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
30007280: e5904018 ldr r4, [r0, #24] <== NOT EXECUTED
ssize_t IMFS_fifo_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
30007284: e1a03000 mov r3, r0 <== NOT EXECUTED 30007288: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop);
3000728c: e5940050 ldr r0, [r4, #80] ; 0x50 <== NOT EXECUTED 30007290: eb0026b9 bl 30010d7c <pipe_read> <== NOT EXECUTED
if (err > 0)
30007294: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30007298: da000007 ble 300072bc <IMFS_fifo_read+0x40> <== NOT EXECUTED
IMFS_update_atime(jnode);
3000729c: e1a0000d mov r0, sp <== NOT EXECUTED 300072a0: e3a01000 mov r1, #0 <== NOT EXECUTED 300072a4: eb000404 bl 300082bc <gettimeofday> <== NOT EXECUTED 300072a8: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300072ac: e1a00005 mov r0, r5 <== NOT EXECUTED 300072b0: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
}
300072b4: e28dd008 add sp, sp, #8 <== NOT EXECUTED
300072b8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0)
IMFS_update_atime(jnode);
IMFS_FIFO_RETURN(err);
300072bc: 01a00005 moveq r0, r5 <== NOT EXECUTED 300072c0: 0afffffb beq 300072b4 <IMFS_fifo_read+0x38> <== NOT EXECUTED 300072c4: eb0034b8 bl 300145ac <__errno> <== NOT EXECUTED 300072c8: e2655000 rsb r5, r5, #0 <== NOT EXECUTED 300072cc: e5805000 str r5, [r0] <== NOT EXECUTED 300072d0: e3e00000 mvn r0, #0 <== NOT EXECUTED 300072d4: eafffff6 b 300072b4 <IMFS_fifo_read+0x38> <== NOT EXECUTED
3000721c <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
3000721c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
30007220: e5904018 ldr r4, [r0, #24] <== NOT EXECUTED
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
30007224: e1a03000 mov r3, r0 <== NOT EXECUTED 30007228: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
3000722c: e5940050 ldr r0, [r4, #80] ; 0x50 <== NOT EXECUTED 30007230: eb00273e bl 30010f30 <pipe_write> <== NOT EXECUTED
if (err > 0) {
30007234: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30007238: da000008 ble 30007260 <IMFS_fifo_write+0x44> <== NOT EXECUTED
IMFS_mtime_ctime_update(jnode);
3000723c: e1a0000d mov r0, sp <== NOT EXECUTED 30007240: e3a01000 mov r1, #0 <== NOT EXECUTED 30007244: eb00041c bl 300082bc <gettimeofday> <== NOT EXECUTED 30007248: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000724c: e1a00005 mov r0, r5 <== NOT EXECUTED 30007250: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED 30007254: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
}
IMFS_FIFO_RETURN(err);
}
30007258: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000725c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0) {
IMFS_mtime_ctime_update(jnode);
}
IMFS_FIFO_RETURN(err);
30007260: 01a00005 moveq r0, r5 <== NOT EXECUTED 30007264: 0afffffb beq 30007258 <IMFS_fifo_write+0x3c> <== NOT EXECUTED 30007268: eb0034cf bl 300145ac <__errno> <== NOT EXECUTED 3000726c: e2655000 rsb r5, r5, #0 <== NOT EXECUTED 30007270: e5805000 str r5, [r0] <== NOT EXECUTED 30007274: e3e00000 mvn r0, #0 <== NOT EXECUTED 30007278: eafffff6 b 30007258 <IMFS_fifo_write+0x3c> <== NOT EXECUTED
3000e1e0 <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
)
{
3000e1e0: 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;
3000e1e4: 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
)
{
3000e1e8: 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;
3000e1ec: e5bc401c ldr r4, [ip, #28]!
loc = temp_mt_entry->mt_fs_root;
3000e1f0: e1a0600d mov r6, sp
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
3000e1f4: e1a0e000 mov lr, 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;
3000e1f8: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000e1fc: e8a6000f stmia r6!, {r0, r1, r2, r3}
3000e200: e59c2000 ldr r2, [ip]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
3000e204: e3a03000 mov r3, #0
* 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;
3000e208: e1a0500d mov r5, sp 3000e20c: e5862000 str r2, [r6]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
3000e210: e58e301c str r3, [lr, #28]
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
3000e214: e1a0000d mov r0, sp
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
3000e218: e5946008 ldr r6, [r4, #8]
loc.node_access = (void *)jnode;
3000e21c: e58d4000 str r4, [sp]
IMFS_Set_handlers( &loc );
3000e220: ebfffe01 bl 3000da2c <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
3000e224: e594304c ldr r3, [r4, #76] ; 0x4c
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000e228: e2842054 add r2, r4, #84 ; 0x54 3000e22c: e3530001 cmp r3, #1
3000e230: 1a000010 bne 3000e278 <IMFS_fsunmount+0x98>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
3000e234: e5943050 ldr r3, [r4, #80] ; 0x50 3000e238: e1530002 cmp r3, r2
3000e23c: 0a000014 beq 3000e294 <IMFS_fsunmount+0xb4>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
}
if ( jnode != NULL ) {
3000e240: e3540000 cmp r4, #0
3000e244: 0a000008 beq 3000e26c <IMFS_fsunmount+0x8c>
if ( jnode->type == IMFS_DIRECTORY ) {
3000e248: e594304c ldr r3, [r4, #76] ; 0x4c 3000e24c: e3530001 cmp r3, #1
3000e250: 1affffef bne 3000e214 <IMFS_fsunmount+0x34>
}
}
} while (jnode != NULL);
return 0;
}
3000e254: e5943050 ldr r3, [r4, #80] ; 0x50 3000e258: e2842054 add r2, r4, #84 ; 0x54
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
3000e25c: e1530002 cmp r3, r2
3000e260: 0affffeb beq 3000e214 <IMFS_fsunmount+0x34>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
3000e264: e2534000 subs r4, r3, #0
3000e268: 1affffe9 bne 3000e214 <IMFS_fsunmount+0x34>
return 0;
3000e26c: e1a00004 mov r0, r4
}
3000e270: e28dd014 add sp, sp, #20
3000e274: e8bd8070 pop {r4, r5, r6, pc}
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( jnode->type != IMFS_DIRECTORY ) {
result = IMFS_unlink( NULL, &loc );
3000e278: e1a0100d mov r1, sp 3000e27c: e3a00000 mov r0, #0 3000e280: ebffdf48 bl 30005fa8 <IMFS_unlink>
if (result != 0)
3000e284: e3500000 cmp r0, #0
3000e288: 1a000006 bne 3000e2a8 <IMFS_fsunmount+0xc8>
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
3000e28c: e1a04006 mov r4, r6 3000e290: eaffffea b 3000e240 <IMFS_fsunmount+0x60>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
3000e294: e3a00000 mov r0, #0 3000e298: e1a0100d mov r1, sp 3000e29c: ebffdf41 bl 30005fa8 <IMFS_unlink>
if (result != 0)
3000e2a0: e3500000 cmp r0, #0
3000e2a4: 0afffff8 beq 3000e28c <IMFS_fsunmount+0xac>
return -1;
3000e2a8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000e2ac: eaffffef b 3000e270 <IMFS_fsunmount+0x90> <== NOT EXECUTED
3000e334 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
3000e334: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3000e338: e1a05001 mov r5, r1
3000e33c: e1a04002 mov r4, r2
3000e340: e1a0a003 mov sl, r3
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
3000e344: e5d07000 ldrb r7, [r0] 3000e348: e1a08000 mov r8, r0
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
3000e34c: 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) ) {
3000e350: ea000006 b 3000e370 <IMFS_get_token+0x3c> 3000e354: e1560005 cmp r6, r5
3000e358: aa000008 bge 3000e380 <IMFS_get_token+0x4c>
token[i] = c;
if ( i == IMFS_NAME_MAX )
3000e35c: 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;
3000e360: e7c47006 strb r7, [r4, r6]
if ( i == IMFS_NAME_MAX )
3000e364: 0a00001b beq 3000e3d8 <IMFS_get_token+0xa4>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
3000e368: e5f87001 ldrb r7, [r8, #1]! 3000e36c: 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) ) {
3000e370: e1a00007 mov r0, r7 3000e374: ebffe408 bl 3000739c <rtems_filesystem_is_separator> 3000e378: e3500000 cmp r0, #0
3000e37c: 0afffff4 beq 3000e354 <IMFS_get_token+0x20>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
3000e380: e3560000 cmp r6, #0
3000e384: 1a000006 bne 3000e3a4 <IMFS_get_token+0x70>
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
3000e388: e3570000 cmp r7, #0 3000e38c: 13550000 cmpne r5, #0
i++;
type = IMFS_CURRENT_DIR;
3000e390: 13a06001 movne r6, #1
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
token[i] = c;
3000e394: e5c47000 strb r7, [r4]
if ( (token[i] != '\0') && pathlen ) {
i++;
3000e398: e1a00006 mov r0, r6
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
3000e39c: e58a6000 str r6, [sl]
3000e3a0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
3000e3a4: e0843006 add r3, r4, r6 3000e3a8: e5533001 ldrb r3, [r3, #-1]
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
3000e3ac: e1a00004 mov r0, r4
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
3000e3b0: e3530000 cmp r3, #0
token[i] = '\0';
3000e3b4: 13a03000 movne r3, #0 3000e3b8: 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 ) {
if ( strcmp( token, "..") == 0 )
3000e3bc: e59f1038 ldr r1, [pc, #56] ; 3000e3fc <IMFS_get_token+0xc8>
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
3000e3c0: e58a6000 str r6, [sl]
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
3000e3c4: eb001238 bl 30012cac <strcmp> 3000e3c8: e3500000 cmp r0, #0
3000e3cc: 1a000003 bne 3000e3e0 <IMFS_get_token+0xac>
type = IMFS_UP_DIR;
3000e3d0: e3a00002 mov r0, #2
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
3000e3d4: 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;
3000e3d8: e3a00004 mov r0, #4 <== NOT EXECUTED
3000e3dc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
3000e3e0: e1a00004 mov r0, r4
3000e3e4: e59f1014 ldr r1, [pc, #20] ; 3000e400 <IMFS_get_token+0xcc>
3000e3e8: eb00122f bl 30012cac <strcmp>
3000e3ec: e3500000 cmp r0, #0
3000e3f0: 03a00001 moveq r0, #1
3000e3f4: 13a00003 movne r0, #3
3000e3f8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
30005b90 <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
)
{
30005b90: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30005b94: 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,
30005b98: e59f00e0 ldr r0, [pc, #224] ; 30005c80 <IMFS_initialize_support+0xf0>
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
)
{
30005b9c: e1a08001 mov r8, r1
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
30005ba0: e5900000 ldr r0, [r0]
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
)
{
30005ba4: e1a0a002 mov sl, r2
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
30005ba8: e3500010 cmp r0, #16
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
)
{
30005bac: e1a07003 mov r7, r3
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
30005bb0: 0a00000a beq 30005be0 <IMFS_initialize_support+0x50>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
30005bb4: e350000f cmp r0, #15 30005bb8: c3a02005 movgt r2, #5 30005bbc: c3a03020 movgt r3, #32
30005bc0: da000005 ble 30005bdc <IMFS_initialize_support+0x4c>
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
30005bc4: e1500003 cmp r0, r3
30005bc8: 0a000004 beq 30005be0 <IMFS_initialize_support+0x50>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
30005bcc: ba000002 blt 30005bdc <IMFS_initialize_support+0x4c>
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
30005bd0: e2522001 subs r2, r2, #1 30005bd4: e1a03083 lsl r3, r3, #1
30005bd8: 1afffff9 bne 30005bc4 <IMFS_initialize_support+0x34>
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
30005bdc: e3a00080 mov r0, #128 ; 0x80
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
30005be0: e59f509c ldr r5, [pc, #156] ; 30005c84 <IMFS_initialize_support+0xf4> 30005be4: e5850000 str r0, [r5]
/* * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
30005be8: eb001f7f bl 3000d9ec <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;
30005bec: e59fe094 ldr lr, [pc, #148] ; 30005c88 <IMFS_initialize_support+0xf8> 30005bf0: 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();
30005bf4: e1a06000 mov r6, 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;
30005bf8: e8be000f ldm lr!, {r0, r1, r2, r3}
30005bfc: e8ac000f stmia ip!, {r0, r1, r2, r3}
30005c00: e8be000f ldm lr!, {r0, r1, r2, r3}
30005c04: e8ac000f stmia ip!, {r0, r1, r2, r3}
30005c08: 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();
30005c0c: e584601c str r6, [r4, #28]
temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table; temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
30005c10: e88c000f stm ip, {r0, r1, r2, r3}
* Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node(); temp_mt_entry->mt_fs_root.handlers = directory_handlers;
30005c14: e5847024 str r7, [r4, #36] ; 0x24
temp_mt_entry->mt_fs_root.ops = op_table;
30005c18: e5848028 str r8, [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 ) );
30005c1c: e3a00001 mov r0, #1 30005c20: e3a01014 mov r1, #20 30005c24: eb0001ae bl 300062e4 <calloc>
if ( !fs_info ) {
30005c28: e3500000 cmp r0, #0
30005c2c: 0a00000c beq 30005c64 <IMFS_initialize_support+0xd4>
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
30005c30: e5952004 ldr r2, [r5, #4]
fs_info->ino_count = 1;
30005c34: e3a03001 mov r3, #1
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;
30005c38: e5840034 str r0, [r4, #52] ; 0x34
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
30005c3c: e0821003 add r1, r2, r3 30005c40: e5802000 str r2, [r0]
fs_info->ino_count = 1; fs_info->memfile_handlers = memfile_handlers; fs_info->directory_handlers = directory_handlers; fs_info->fifo_handlers = fifo_handlers;
30005c44: e59d201c ldr r2, [sp, #28]
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
fs_info->ino_count = 1;
30005c48: e9800408 stmib r0, {r3, sl}
fs_info->memfile_handlers = memfile_handlers; fs_info->directory_handlers = directory_handlers;
30005c4c: e580700c str r7, [r0, #12]
fs_info->fifo_handlers = fifo_handlers;
30005c50: e5802010 str r2, [r0, #16]
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
30005c54: e5851004 str r1, [r5, #4]
fs_info->fifo_handlers = fifo_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
return 0;
30005c58: e3a00000 mov r0, #0
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
fs_info->fifo_handlers = fifo_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
30005c5c: e5863038 str r3, [r6, #56] ; 0x38
return 0;
}
30005c60: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ) {
free(temp_mt_entry->mt_fs_root.node_access);
30005c64: e1a00006 mov r0, r6 <== NOT EXECUTED 30005c68: eb00020a bl 30006498 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
30005c6c: eb003100 bl 30012074 <__errno> <== NOT EXECUTED
30005c70: e3a0300c mov r3, #12 <== NOT EXECUTED
30005c74: e5803000 str r3, [r0] <== NOT EXECUTED
30005c78: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005c7c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30005c8c <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 */
)
{
30005c8c: 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;
30005c90: 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 */
)
{
30005c94: 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 )
30005c98: e1d313b4 ldrh r1, [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 */
)
{
30005c9c: e24dd048 sub sp, sp, #72 ; 0x48 <== 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 )
30005ca0: e3510007 cmp r1, #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 */
)
{
30005ca4: e1a06002 mov r6, r2 <== NOT EXECUTED
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
30005ca8: e58d3028 str r3, [sp, #40] ; 0x28 <== NOT EXECUTED
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
30005cac: 8a00001d bhi 30005d28 <IMFS_link+0x9c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMLINK );
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( token, strlen( token ), new_name, &i );
30005cb0: e1a00002 mov r0, r2 <== NOT EXECUTED 30005cb4: eb0034d8 bl 3001301c <strlen> <== NOT EXECUTED 30005cb8: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30005cbc: e1a01000 mov r1, r0 <== NOT EXECUTED 30005cc0: e1a02004 mov r2, r4 <== NOT EXECUTED 30005cc4: e28d3044 add r3, sp, #68 ; 0x44 <== NOT EXECUTED 30005cc8: e1a00006 mov r0, r6 <== NOT EXECUTED 30005ccc: eb002198 bl 3000e334 <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
30005cd0: 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(
30005cd4: e58d3000 str r3, [sp] <== NOT EXECUTED 30005cd8: e3a01003 mov r1, #3 <== NOT EXECUTED 30005cdc: e1a00005 mov r0, r5 <== NOT EXECUTED 30005ce0: e1a02004 mov r2, r4 <== NOT EXECUTED 30005ce4: e59f3064 ldr r3, [pc, #100] ; 30005d50 <IMFS_link+0xc4> <== NOT EXECUTED 30005ce8: eb001eeb bl 3000d89c <IMFS_create_node> <== NOT EXECUTED
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
30005cec: e3500000 cmp r0, #0 <== NOT EXECUTED 30005cf0: 0a000011 beq 30005d3c <IMFS_link+0xb0> <== 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++;
30005cf4: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
IMFS_update_ctime( info.hard_link.link_node );
30005cf8: 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++;
30005cfc: e1d323b4 ldrh r2, [r3, #52] ; 0x34 <== NOT EXECUTED
IMFS_update_ctime( info.hard_link.link_node );
30005d00: 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++;
30005d04: e2822001 add r2, r2, #1 <== NOT EXECUTED 30005d08: e1c323b4 strh r2, [r3, #52] ; 0x34 <== NOT EXECUTED
IMFS_update_ctime( info.hard_link.link_node );
30005d0c: eb00020a bl 3000653c <gettimeofday> <== NOT EXECUTED 30005d10: e59d203c ldr r2, [sp, #60] ; 0x3c <== NOT EXECUTED 30005d14: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
return 0;
30005d18: 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 );
30005d1c: e5832048 str r2, [r3, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
30005d20: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
30005d24: e8bd8070 pop {r4, r5, r6, pc} <== 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 )
rtems_set_errno_and_return_minus_one( EMLINK );
30005d28: eb0030d1 bl 30012074 <__errno> <== NOT EXECUTED 30005d2c: e3a0301f mov r3, #31 <== NOT EXECUTED 30005d30: e5803000 str r3, [r0] <== NOT EXECUTED 30005d34: e3e00000 mvn r0, #0 <== NOT EXECUTED 30005d38: eafffff8 b 30005d20 <IMFS_link+0x94> <== NOT EXECUTED
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
30005d3c: eb0030cc bl 30012074 <__errno> <== NOT EXECUTED 30005d40: e3a0300c mov r3, #12 <== NOT EXECUTED 30005d44: e5803000 str r3, [r0] <== NOT EXECUTED 30005d48: e3e00000 mvn r0, #0 <== NOT EXECUTED 30005d4c: eafffff3 b 30005d20 <IMFS_link+0x94> <== NOT EXECUTED
30010c1c <IMFS_memfile_extend>:
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
30010c1c: e59f3128 ldr r3, [pc, #296] ; 30010d4c <IMFS_memfile_extend+0x130>
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
30010c20: e92d4df0 push {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 )
30010c24: e593b000 ldr fp, [r3]
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
30010c28: e1a06002 mov r6, r2
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
30010c2c: e1a0312b lsr r3, fp, #2 30010c30: e0223393 mla r2, r3, r3, r3 30010c34: e0233392 mla r3, r2, r3, r3 30010c38: e3a02000 mov r2, #0 30010c3c: e2433001 sub r3, r3, #1 30010c40: e1520006 cmp r2, r6
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
30010c44: e24dd004 sub sp, sp, #4 30010c48: e1a04000 mov r4, r0 30010c4c: e1a08001 mov r8, r1
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
30010c50: e003039b mul r3, fp, r3
30010c54: da000034 ble 30010d2c <IMFS_memfile_extend+0x110>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
30010c58: e5947054 ldr r7, [r4, #84] ; 0x54 30010c5c: e594a050 ldr sl, [r4, #80] ; 0x50 30010c60: e1560007 cmp r6, r7
30010c64: da000027 ble 30010d08 <IMFS_memfile_extend+0xec>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010c68: e1a0cfcb asr ip, fp, #31 30010c6c: e1a0300c mov r3, ip 30010c70: e1a0200b mov r2, fp 30010c74: e1a00008 mov r0, r8 30010c78: e1a01006 mov r1, r6 30010c7c: e58dc000 str ip, [sp] 30010c80: eb001564 bl 30016218 <__divdi3>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010c84: e59dc000 ldr ip, [sp]
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010c88: e1a05000 mov r5, r0
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010c8c: e1a01007 mov r1, r7 30010c90: e1a0000a mov r0, sl 30010c94: e1a0200b mov r2, fp 30010c98: e1a0300c mov r3, ip 30010c9c: eb00155d bl 30016218 <__divdi3>
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
30010ca0: e1550000 cmp r5, r0
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010ca4: e1a0a000 mov sl, r0
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
30010ca8: 3a00001b bcc 30010d1c <IMFS_memfile_extend+0x100>
30010cac: e1a07000 mov r7, r0 30010cb0: ea000002 b 30010cc0 <IMFS_memfile_extend+0xa4> 30010cb4: e2877001 add r7, r7, #1 30010cb8: e1550007 cmp r5, r7
30010cbc: 3a000016 bcc 30010d1c <IMFS_memfile_extend+0x100>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
30010cc0: e1a01007 mov r1, r7 30010cc4: e1a00004 mov r0, r4 30010cc8: ebffff4e bl 30010a08 <IMFS_memfile_addblock> 30010ccc: e3500000 cmp r0, #0
30010cd0: 0afffff7 beq 30010cb4 <IMFS_memfile_extend+0x98>
30010cd4: ea000003 b 30010ce8 <IMFS_memfile_extend+0xcc> <== NOT EXECUTED
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
30010cd8: e1a01007 mov r1, r7 <== NOT EXECUTED 30010cdc: e1a00004 mov r0, r4 <== 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-- ) {
30010ce0: e2477001 sub r7, r7, #1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
30010ce4: ebffffc2 bl 30010bf4 <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-- ) {
30010ce8: e15a0007 cmp sl, r7 <== NOT EXECUTED 30010cec: 9afffff9 bls 30010cd8 <IMFS_memfile_extend+0xbc> <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
30010cf0: eb0004df bl 30012074 <__errno> <== NOT EXECUTED 30010cf4: e3a0301c mov r3, #28 <== NOT EXECUTED 30010cf8: e5803000 str r3, [r0] <== NOT EXECUTED 30010cfc: e3e00000 mvn r0, #0 <== NOT EXECUTED
/* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; }
30010d00: e28dd004 add sp, sp, #4
30010d04: e8bd8df0 pop {r4, r5, r6, r7, r8, sl, fp, pc}
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
30010d08: 1a000001 bne 30010d14 <IMFS_memfile_extend+0xf8>
30010d0c: e158000a cmp r8, sl
30010d10: 8affffd4 bhi 30010c68 <IMFS_memfile_extend+0x4c>
return 0;
30010d14: e3a00000 mov r0, #0 30010d18: eafffff8 b 30010d00 <IMFS_memfile_extend+0xe4>
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
30010d1c: e5848050 str r8, [r4, #80] ; 0x50 30010d20: e5846054 str r6, [r4, #84] ; 0x54
return 0;
30010d24: e3a00000 mov r0, #0 30010d28: eafffff4 b 30010d00 <IMFS_memfile_extend+0xe4>
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
30010d2c: 1a000001 bne 30010d38 <IMFS_memfile_extend+0x11c>
30010d30: e1530001 cmp r3, r1
30010d34: 8affffc7 bhi 30010c58 <IMFS_memfile_extend+0x3c>
rtems_set_errno_and_return_minus_one( EINVAL );
30010d38: eb0004cd bl 30012074 <__errno> <== NOT EXECUTED 30010d3c: e3a03016 mov r3, #22 <== NOT EXECUTED 30010d40: e5803000 str r3, [r0] <== NOT EXECUTED 30010d44: e3e00000 mvn r0, #0 <== NOT EXECUTED 30010d48: eaffffec b 30010d00 <IMFS_memfile_extend+0xe4> <== NOT EXECUTED
300105bc <IMFS_memfile_get_block_pointer>:
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
300105bc: e59f3200 ldr r3, [pc, #512] ; 300107c4 <IMFS_memfile_get_block_pointer+0x208>
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
300105c0: 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 ) {
300105c4: e5934000 ldr r4, [r3]
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
300105c8: e24dd004 sub sp, sp, #4
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
300105cc: e1a04124 lsr r4, r4, #2 300105d0: e2443001 sub r3, r4, #1 300105d4: e1510003 cmp r1, r3
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
300105d8: e1a05000 mov r5, r0 300105dc: e1a06002 mov r6, r2
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
300105e0: 8a000007 bhi 30010604 <IMFS_memfile_get_block_pointer+0x48>
p = info->indirect;
if ( malloc_it ) {
300105e4: e3520000 cmp r2, #0
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
300105e8: e5900058 ldr r0, [r0, #88] ; 0x58
if ( malloc_it ) {
300105ec: 0a00001c beq 30010664 <IMFS_memfile_get_block_pointer+0xa8>
if ( !p ) {
300105f0: e3500000 cmp r0, #0
300105f4: 0a000041 beq 30010700 <IMFS_memfile_get_block_pointer+0x144>
}
if ( !p )
return 0;
return &info->indirect[ my_block ];
300105f8: e0800101 add r0, r0, r1, lsl #2
/*
* This means the requested block number is out of range.
*/
return 0;
}
300105fc: e28dd004 add sp, sp, #4
30010600: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
30010604: e0274494 mla r7, r4, r4, r4 30010608: e2473001 sub r3, r7, #1 3001060c: e1510003 cmp r1, r3
30010610: 8a000016 bhi 30010670 <IMFS_memfile_get_block_pointer+0xb4>
my_block -= FIRST_DOUBLY_INDIRECT;
30010614: e0647001 rsb r7, r4, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
30010618: e1a00007 mov r0, r7 3001061c: e1a01004 mov r1, r4 30010620: eb00149c bl 30015898 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
30010624: e1a01004 mov r1, r4
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
30010628: e1a08000 mov r8, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3001062c: e1a00007 mov r0, r7 30010630: eb001452 bl 30015780 <__aeabi_uidiv>
p = info->doubly_indirect;
if ( malloc_it ) {
30010634: e3560000 cmp r6, #0
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
30010638: e1a04000 mov r4, r0
p = info->doubly_indirect;
3001063c: e595305c ldr r3, [r5, #92] ; 0x5c
if ( malloc_it ) {
30010640: 0a00003f beq 30010744 <IMFS_memfile_get_block_pointer+0x188>
if ( !p ) {
30010644: e3530000 cmp r3, #0
30010648: 0a000045 beq 30010764 <IMFS_memfile_get_block_pointer+0x1a8>
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
3001064c: e7930104 ldr r0, [r3, r4, lsl #2] 30010650: e0834104 add r4, r3, r4, lsl #2
if ( !p1 ) {
30010654: e3500000 cmp r0, #0
30010658: 0a00002f beq 3001071c <IMFS_memfile_get_block_pointer+0x160>
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
3001065c: e0800108 add r0, r0, r8, lsl #2 30010660: eaffffe5 b 300105fc <IMFS_memfile_get_block_pointer+0x40>
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
30010664: e3500000 cmp r0, #0
30010668: 1affffe2 bne 300105f8 <IMFS_memfile_get_block_pointer+0x3c>
3001066c: eaffffe2 b 300105fc <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
30010670: e0234497 mla r3, r7, r4, r4 <== NOT EXECUTED 30010674: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30010678: e1510003 cmp r1, r3 <== NOT EXECUTED
}
/*
* This means the requested block number is out of range.
*/
return 0;
3001067c: 83a00000 movhi r0, #0 <== NOT EXECUTED
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
30010680: 8affffdd bhi 300105fc <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
my_block -= FIRST_TRIPLY_INDIRECT;
30010684: e0677001 rsb r7, r7, r1 <== NOT EXECUTED
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
30010688: e1a00007 mov r0, r7 <== NOT EXECUTED 3001068c: e1a01004 mov r1, r4 <== NOT EXECUTED 30010690: eb001480 bl 30015898 <__umodsi3> <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
30010694: e1a01004 mov r1, r4 <== 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;
30010698: e1a0a000 mov sl, r0 <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3001069c: e1a00007 mov r0, r7 <== NOT EXECUTED 300106a0: eb001436 bl 30015780 <__aeabi_uidiv> <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
300106a4: e1a01004 mov r1, r4 <== 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;
300106a8: e1a08000 mov r8, r0 <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
300106ac: eb001433 bl 30015780 <__aeabi_uidiv> <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
300106b0: e1a01004 mov r1, r4 <== 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;
300106b4: e1a07000 mov r7, r0 <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
300106b8: e1a00008 mov r0, r8 <== NOT EXECUTED 300106bc: eb001475 bl 30015898 <__umodsi3> <== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
300106c0: e3560000 cmp r6, #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;
300106c4: e1a04000 mov r4, r0 <== NOT EXECUTED
p = info->triply_indirect;
300106c8: e5950060 ldr r0, [r5, #96] ; 0x60 <== NOT EXECUTED
if ( malloc_it ) {
300106cc: 0a000029 beq 30010778 <IMFS_memfile_get_block_pointer+0x1bc><== NOT EXECUTED
if ( !p ) {
300106d0: e3500000 cmp r0, #0 <== NOT EXECUTED 300106d4: 0a000035 beq 300107b0 <IMFS_memfile_get_block_pointer+0x1f4><== NOT EXECUTED
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
300106d8: e7903107 ldr r3, [r0, r7, lsl #2] <== NOT EXECUTED 300106dc: e0807107 add r7, r0, r7, lsl #2 <== NOT EXECUTED
if ( !p1 ) {
300106e0: e3530000 cmp r3, #0 <== NOT EXECUTED 300106e4: 0a00002c beq 3001079c <IMFS_memfile_get_block_pointer+0x1e0><== NOT EXECUTED
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
300106e8: e7930104 ldr r0, [r3, r4, lsl #2] <== NOT EXECUTED 300106ec: e0834104 add r4, r3, r4, lsl #2 <== NOT EXECUTED
if ( !p2 ) {
300106f0: e3500000 cmp r0, #0 <== NOT EXECUTED 300106f4: 0a00000d beq 30010730 <IMFS_memfile_get_block_pointer+0x174><== NOT EXECUTED
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
300106f8: e080010a add r0, r0, sl, lsl #2 <== NOT EXECUTED 300106fc: eaffffbe b 300105fc <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
30010700: e58d1000 str r1, [sp] 30010704: ebffff9f bl 30010588 <memfile_alloc_block>
if ( !p )
30010708: e3500000 cmp r0, #0 3001070c: e59d1000 ldr r1, [sp]
return 0;
info->indirect = p;
30010710: 15850058 strne r0, [r5, #88] ; 0x58
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
30010714: 1affffb7 bne 300105f8 <IMFS_memfile_get_block_pointer+0x3c>
30010718: eaffffb7 b 300105fc <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
3001071c: ebffff99 bl 30010588 <memfile_alloc_block>
if ( !p1 )
30010720: e3500000 cmp r0, #0
return 0;
p[ doubly ] = (block_p) p1;
30010724: 15840000 strne r0, [r4]
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
30010728: 10800108 addne r0, r0, r8, lsl #2 3001072c: eaffffb2 b 300105fc <IMFS_memfile_get_block_pointer+0x40>
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
30010730: ebffff94 bl 30010588 <memfile_alloc_block> <== NOT EXECUTED
if ( !p2 )
30010734: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
p1[ doubly ] = (block_p) p2;
30010738: 15840000 strne r0, [r4] <== NOT EXECUTED
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
3001073c: 1080010a addne r0, r0, sl, lsl #2 <== NOT EXECUTED 30010740: eaffffad b 300105fc <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
return (block_p *)&p1[ singly ];
}
if ( !p )
30010744: e3530000 cmp r3, #0
30010748: 1a000001 bne 30010754 <IMFS_memfile_get_block_pointer+0x198>
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
return 0;
3001074c: e1a00003 mov r0, r3 <== NOT EXECUTED 30010750: eaffffa9 b 300105fc <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
if ( !p )
return 0;
p = (block_p *)p[ doubly ];
30010754: e7930100 ldr r0, [r3, r0, lsl #2]
if ( !p )
30010758: e3500000 cmp r0, #0
return 0;
return (block_p *)&p[ singly ];
3001075c: 10800108 addne r0, r0, r8, lsl #2 30010760: eaffffa5 b 300105fc <IMFS_memfile_get_block_pointer+0x40>
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
30010764: ebffff87 bl 30010588 <memfile_alloc_block>
if ( !p )
30010768: e2503000 subs r3, r0, #0
3001076c: 0afffff6 beq 3001074c <IMFS_memfile_get_block_pointer+0x190>
return 0;
info->doubly_indirect = p;
30010770: e585305c str r3, [r5, #92] ; 0x5c 30010774: eaffffb4 b 3001064c <IMFS_memfile_get_block_pointer+0x90>
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
30010778: e3500000 cmp r0, #0 <== NOT EXECUTED 3001077c: 0affff9e beq 300105fc <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
return 0;
p1 = (block_p *) p[ triply ];
30010780: e7900107 ldr r0, [r0, r7, lsl #2] <== NOT EXECUTED
if ( !p1 )
30010784: e3500000 cmp r0, #0 <== NOT EXECUTED 30010788: 0affff9b beq 300105fc <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
return 0;
p2 = (block_p *)p1[ doubly ];
3001078c: e7900104 ldr r0, [r0, r4, lsl #2] <== NOT EXECUTED
if ( !p2 )
30010790: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return (block_p *)&p2[ singly ];
30010794: 1080010a addne r0, r0, sl, lsl #2 <== NOT EXECUTED 30010798: eaffff97 b 300105fc <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
3001079c: ebffff79 bl 30010588 <memfile_alloc_block> <== NOT EXECUTED
if ( !p1 )
300107a0: e2503000 subs r3, r0, #0 <== NOT EXECUTED 300107a4: 0affffe8 beq 3001074c <IMFS_memfile_get_block_pointer+0x190><== NOT EXECUTED
return 0;
p[ triply ] = (block_p) p1;
300107a8: e5873000 str r3, [r7] <== NOT EXECUTED 300107ac: eaffffcd b 300106e8 <IMFS_memfile_get_block_pointer+0x12c> <== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
300107b0: ebffff74 bl 30010588 <memfile_alloc_block> <== NOT EXECUTED
if ( !p )
300107b4: e3500000 cmp r0, #0 <== NOT EXECUTED 300107b8: 0affff8f beq 300105fc <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
return 0;
info->triply_indirect = p;
300107bc: e5850060 str r0, [r5, #96] ; 0x60 <== NOT EXECUTED 300107c0: eaffffc4 b 300106d8 <IMFS_memfile_get_block_pointer+0x11c> <== NOT EXECUTED
300089dc <IMFS_memfile_maximum_size>:
* using the IMFS memory file type.
*
*/
int IMFS_memfile_maximum_size( void )
{
return IMFS_MEMFILE_MAXIMUM_SIZE;
300089dc: e59f3018 ldr r3, [pc, #24] ; 300089fc <IMFS_memfile_maximum_size+0x20><== NOT EXECUTED 300089e0: e5932000 ldr r2, [r3] <== NOT EXECUTED 300089e4: e1a03122 lsr r3, r2, #2 <== NOT EXECUTED 300089e8: e0203393 mla r0, r3, r3, r3 <== NOT EXECUTED 300089ec: e0233390 mla r3, r0, r3, r3 <== NOT EXECUTED 300089f0: e2430001 sub r0, r3, #1 <== NOT EXECUTED
}
300089f4: e0000092 mul r0, r2, r0 <== NOT EXECUTED 300089f8: e12fff1e bx lr <== NOT EXECUTED
300107c8 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
300107c8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
300107cc: e1a09000 mov r9, r0
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
300107d0: e590004c ldr r0, [r0, #76] ; 0x4c
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
300107d4: e24dd014 sub sp, sp, #20
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
300107d8: e3500006 cmp r0, #6
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
300107dc: e1a07001 mov r7, r1 300107e0: e1a08002 mov r8, r2 300107e4: e1a0b003 mov fp, r3 300107e8: e59d5038 ldr r5, [sp, #56] ; 0x38
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
300107ec: 0a00005c beq 30010964 <IMFS_memfile_read+0x19c>
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
300107f0: e5992054 ldr r2, [r9, #84] ; 0x54
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
300107f4: e1a03001 mov r3, r1
if ( last_byte > the_jnode->info.file.size )
300107f8: e3a01000 mov r1, #0 300107fc: e1510002 cmp r1, r2 30010800: e5992050 ldr r2, [r9, #80] ; 0x50
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
30010804: e0851007 add r1, r5, r7
if ( last_byte > the_jnode->info.file.size )
30010808: da00003d ble 30010904 <IMFS_memfile_read+0x13c>
my_length = the_jnode->info.file.size - start;
3001080c: e0635002 rsb r5, r3, r2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
30010810: e59f61b8 ldr r6, [pc, #440] ; 300109d0 <IMFS_memfile_read+0x208>
30010814: e1a00007 mov r0, r7
30010818: e5964000 ldr r4, [r6]
3001081c: e1a01008 mov r1, r8
30010820: e1a02004 mov r2, r4
30010824: e1a03fc2 asr r3, r2, #31
30010828: e98d000c stmib sp, {r2, r3}
3001082c: eb0017a6 bl 300166cc <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010830: e99d000c ldmib sp, {r2, r3}
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
30010834: e1a0a000 mov sl, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010838: e1a01008 mov r1, r8 3001083c: e1a00007 mov r0, r7 30010840: eb001674 bl 30016218 <__divdi3>
if ( start_offset ) {
30010844: e35a0000 cmp sl, #0
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010848: e1a07000 mov r7, r0
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
3001084c: 01a0800b moveq r8, fp
/*
* 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 ) {
30010850: 0a000014 beq 300108a8 <IMFS_memfile_read+0xe0>
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 );
30010854: e1a00009 mov r0, r9 30010858: e1a01007 mov r1, r7 3001085c: e3a02000 mov r2, #0 30010860: ebffff55 bl 300105bc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
30010864: e3500000 cmp r0, #0
30010868: 0a000023 beq 300108fc <IMFS_memfile_read+0x134>
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
3001086c: e5901000 ldr r1, [r0]
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
30010870: e06a3004 rsb r3, sl, r4 30010874: e1550003 cmp r5, r3 30010878: 31a03005 movcc r3, r5
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
3001087c: e081100a add r1, r1, sl 30010880: e1a02003 mov r2, r3 30010884: e1a0000b mov r0, fp 30010888: e58d3000 str r3, [sp] 3001088c: eb000826 bl 3001292c <memcpy>
dest += to_copy;
30010890: e59d3000 ldr r3, [sp]
block++;
my_length -= to_copy;
30010894: e5964000 ldr r4, [r6]
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
dest += to_copy;
30010898: e08b8003 add r8, fp, r3
block++;
3001089c: e2877001 add r7, r7, #1
my_length -= to_copy;
300108a0: e0635005 rsb r5, r3, r5
copied += to_copy;
300108a4: e1a0a003 mov sl, r3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
300108a8: e1550004 cmp r5, r4
300108ac: 2a000008 bcs 300108d4 <IMFS_memfile_read+0x10c>
300108b0: ea000017 b 30010914 <IMFS_memfile_read+0x14c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
300108b4: e5931000 ldr r1, [r3] 300108b8: eb00081b bl 3001292c <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
300108bc: e5963000 ldr r3, [r6]
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
300108c0: e0888004 add r8, r8, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
300108c4: e1530005 cmp r3, r5
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
block++;
300108c8: e2877001 add r7, r7, #1
my_length -= to_copy;
copied += to_copy;
300108cc: e08aa004 add sl, sl, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
300108d0: 8a00000f bhi 30010914 <IMFS_memfile_read+0x14c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
300108d4: e3a02000 mov r2, #0 300108d8: e1a01007 mov r1, r7 300108dc: e1a00009 mov r0, r9 300108e0: ebffff35 bl 300105bc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
300108e4: e2503000 subs r3, r0, #0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
300108e8: e1a02004 mov r2, r4
dest += to_copy;
block++;
my_length -= to_copy;
300108ec: e0645005 rsb r5, r4, r5
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
300108f0: e1a00008 mov r0, r8
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
300108f4: 1affffee bne 300108b4 <IMFS_memfile_read+0xec>
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
300108f8: e1a0000a mov r0, sl <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
300108fc: e28dd014 add sp, sp, #20
30010900: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) 30010904: 1affffc1 bne 30010810 <IMFS_memfile_read+0x48>
30010908: e1510002 cmp r1, r2
3001090c: 9affffbf bls 30010810 <IMFS_memfile_read+0x48>
30010910: eaffffbd b 3001080c <IMFS_memfile_read+0x44>
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
30010914: e3550000 cmp r5, #0
30010918: 0a00000a beq 30010948 <IMFS_memfile_read+0x180>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3001091c: e1a00009 mov r0, r9 30010920: e1a01007 mov r1, r7 30010924: e3a02000 mov r2, #0 30010928: ebffff23 bl 300105bc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
3001092c: e2503000 subs r3, r0, #0
30010930: 0afffff0 beq 300108f8 <IMFS_memfile_read+0x130>
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
30010934: e1a00008 mov r0, r8 30010938: e5931000 ldr r1, [r3] 3001093c: e1a02005 mov r2, r5 30010940: eb0007f9 bl 3001292c <memcpy>
copied += my_length;
30010944: e08aa005 add sl, sl, r5
}
IMFS_update_atime( the_jnode );
30010948: e28d000c add r0, sp, #12 3001094c: e3a01000 mov r1, #0 30010950: ebffd6f9 bl 3000653c <gettimeofday> 30010954: e59d300c ldr r3, [sp, #12]
return copied;
30010958: e1a0000a mov r0, sl
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
3001095c: e5893040 str r3, [r9, #64] ; 0x40
return copied;
30010960: eaffffe5 b 300108fc <IMFS_memfile_read+0x134>
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
30010964: e2894050 add r4, r9, #80 ; 0x50
30010968: e8940018 ldm r4, {r3, r4}
3001096c: e1a00003 mov r0, r3
30010970: e1a01004 mov r1, r4
30010974: e3a02000 mov r2, #0
30010978: e0500007 subs r0, r0, r7
3001097c: e0c11008 sbc r1, r1, r8
30010980: e1520001 cmp r2, r1
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
30010984: e5992058 ldr r2, [r9, #88] ; 0x58
if (my_length > (the_jnode->info.linearfile.size - start))
30010988: da00000b ble 300109bc <IMFS_memfile_read+0x1f4>
my_length = the_jnode->info.linearfile.size - start;
3001098c: e067a003 rsb sl, r7, r3
memcpy(dest, &file_ptr[start], my_length);
30010990: e0821007 add r1, r2, r7 30010994: e1a0000b mov r0, fp 30010998: e1a0200a mov r2, sl 3001099c: eb0007e2 bl 3001292c <memcpy>
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
300109a0: e28d000c add r0, sp, #12 300109a4: e3a01000 mov r1, #0 300109a8: ebffd6e3 bl 3000653c <gettimeofday> 300109ac: e59d300c ldr r3, [sp, #12]
return copied;
300109b0: e1a0000a mov r0, sl
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
300109b4: e5893040 str r3, [r9, #64] ; 0x40 300109b8: eaffffcf b 300108fc <IMFS_memfile_read+0x134>
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
300109bc: 1a000001 bne 300109c8 <IMFS_memfile_read+0x200>
300109c0: e1550000 cmp r5, r0
300109c4: 8afffff0 bhi 3001098c <IMFS_memfile_read+0x1c4>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
300109c8: e1a0a005 mov sl, r5 <== NOT EXECUTED 300109cc: eaffffef b 30010990 <IMFS_memfile_read+0x1c8> <== NOT EXECUTED
30010ab4 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
30010ab4: 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;
30010ab8: e59f6130 ldr r6, [pc, #304] ; 30010bf0 <IMFS_memfile_remove+0x13c>
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
30010abc: 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;
30010ac0: e5967000 ldr r7, [r6]
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
30010ac4: e3530000 cmp r3, #0
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
30010ac8: e1a0a000 mov sl, 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;
30010acc: e1a07127 lsr r7, r7, #2
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
30010ad0: 12800058 addne r0, r0, #88 ; 0x58 30010ad4: 11a01007 movne r1, r7 30010ad8: 1bffffe0 blne 30010a60 <memfile_free_blocks_in_table>
}
if ( info->doubly_indirect ) {
30010adc: e59a305c ldr r3, [sl, #92] ; 0x5c 30010ae0: e3530000 cmp r3, #0
30010ae4: 0a000014 beq 30010b3c <IMFS_memfile_remove+0x88>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
30010ae8: e5962000 ldr r2, [r6] <== NOT EXECUTED 30010aec: e1b02122 lsrs r2, r2, #2 <== NOT EXECUTED 30010af0: 0a00000e beq 30010b30 <IMFS_memfile_remove+0x7c> <== NOT EXECUTED 30010af4: e3a02000 mov r2, #0 <== NOT EXECUTED 30010af8: e1a04002 mov r4, r2 <== NOT EXECUTED 30010afc: ea000000 b 30010b04 <IMFS_memfile_remove+0x50> <== NOT EXECUTED 30010b00: e59a305c ldr r3, [sl, #92] ; 0x5c <== NOT EXECUTED
if ( info->doubly_indirect[i] ) {
30010b04: e7931102 ldr r1, [r3, r2, lsl #2] <== NOT EXECUTED 30010b08: e1a02102 lsl r2, r2, #2 <== NOT EXECUTED 30010b0c: e3510000 cmp r1, #0 <== 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++ ) {
30010b10: e2844001 add r4, r4, #1 <== NOT EXECUTED
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
30010b14: e1a01007 mov r1, r7 <== NOT EXECUTED 30010b18: e0830002 add r0, r3, r2 <== NOT EXECUTED 30010b1c: 1bffffcf blne 30010a60 <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++ ) {
30010b20: e5963000 ldr r3, [r6] <== NOT EXECUTED 30010b24: e1a02004 mov r2, r4 <== NOT EXECUTED 30010b28: e1540123 cmp r4, r3, lsr #2 <== NOT EXECUTED 30010b2c: 3afffff3 bcc 30010b00 <IMFS_memfile_remove+0x4c> <== 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 );
30010b30: e28a005c add r0, sl, #92 ; 0x5c <== NOT EXECUTED 30010b34: e1a01007 mov r1, r7 <== NOT EXECUTED 30010b38: ebffffc8 bl 30010a60 <memfile_free_blocks_in_table> <== NOT EXECUTED
}
if ( info->triply_indirect ) {
30010b3c: e59a0060 ldr r0, [sl, #96] ; 0x60 30010b40: e3500000 cmp r0, #0
30010b44: 0a000027 beq 30010be8 <IMFS_memfile_remove+0x134>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
30010b48: e5963000 ldr r3, [r6] <== NOT EXECUTED 30010b4c: e1b03123 lsrs r3, r3, #2 <== NOT EXECUTED 30010b50: 0a000021 beq 30010bdc <IMFS_memfile_remove+0x128> <== NOT EXECUTED
p = (block_p *) info->triply_indirect[i];
30010b54: e5905000 ldr r5, [r0] <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
30010b58: e3550000 cmp r5, #0 <== NOT EXECUTED
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
30010b5c: 13a09000 movne r9, #0 <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
30010b60: 11a08009 movne r8, r9 <== NOT EXECUTED 30010b64: 0a00001c beq 30010bdc <IMFS_memfile_remove+0x128> <== NOT EXECUTED
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
30010b68: e3530000 cmp r3, #0 <== NOT EXECUTED 30010b6c: 0a00000d beq 30010ba8 <IMFS_memfile_remove+0xf4> <== NOT EXECUTED 30010b70: e3a00000 mov r0, #0 <== NOT EXECUTED 30010b74: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( p[j] ) {
30010b78: e7953100 ldr r3, [r5, r0, lsl #2] <== NOT EXECUTED 30010b7c: e1a00100 lsl r0, r0, #2 <== NOT EXECUTED 30010b80: e3530000 cmp r3, #0 <== 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++ ) {
30010b84: e2844001 add r4, r4, #1 <== NOT EXECUTED
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
30010b88: e1a01007 mov r1, r7 <== NOT EXECUTED 30010b8c: e0850000 add r0, r5, r0 <== NOT EXECUTED 30010b90: 1bffffb2 blne 30010a60 <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++ ) {
30010b94: e5963000 ldr r3, [r6] <== NOT EXECUTED 30010b98: e1a00004 mov r0, r4 <== NOT EXECUTED 30010b9c: e1540123 cmp r4, r3, lsr #2 <== NOT EXECUTED 30010ba0: 3afffff4 bcc 30010b78 <IMFS_memfile_remove+0xc4> <== NOT EXECUTED 30010ba4: e59a0060 ldr r0, [sl, #96] ; 0x60 <== NOT EXECUTED
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
30010ba8: e0800009 add r0, r0, r9 <== NOT EXECUTED 30010bac: e1a01007 mov r1, r7 <== NOT EXECUTED 30010bb0: ebffffaa bl 30010a60 <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++ ) {
30010bb4: e5963000 ldr r3, [r6] <== NOT EXECUTED 30010bb8: e2888001 add r8, r8, #1 <== NOT EXECUTED 30010bbc: e1a03123 lsr r3, r3, #2 <== NOT EXECUTED 30010bc0: e1530008 cmp r3, r8 <== NOT EXECUTED 30010bc4: 9a000004 bls 30010bdc <IMFS_memfile_remove+0x128> <== NOT EXECUTED
p = (block_p *) info->triply_indirect[i];
30010bc8: e59a0060 ldr r0, [sl, #96] ; 0x60 <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
30010bcc: e1a09108 lsl r9, r8, #2 <== NOT EXECUTED
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
30010bd0: e7905108 ldr r5, [r0, r8, lsl #2] <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
30010bd4: e3550000 cmp r5, #0 <== NOT EXECUTED 30010bd8: 1affffe2 bne 30010b68 <IMFS_memfile_remove+0xb4> <== NOT EXECUTED
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
30010bdc: e28a0060 add r0, sl, #96 ; 0x60 <== NOT EXECUTED 30010be0: e1a01007 mov r1, r7 <== NOT EXECUTED 30010be4: ebffff9d bl 30010a60 <memfile_free_blocks_in_table> <== NOT EXECUTED
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
30010be8: e3a00000 mov r0, #0
30010bec: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
30010bf4 <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
30010bf4: 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 );
30010bf8: e3a02000 mov r2, #0 <== NOT EXECUTED 30010bfc: ebfffe6e bl 300105bc <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
*block_ptr = 0;
30010c00: e3a02000 mov r2, #0 <== NOT EXECUTED
)
{
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
30010c04: e1a03000 mov r3, r0 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
30010c08: e5900000 ldr r0, [r0] <== NOT EXECUTED
*block_ptr = 0;
30010c0c: e5832000 str r2, [r3] <== NOT EXECUTED
memfile_free_block( ptr );
30010c10: ebffff8a bl 30010a40 <memfile_free_block> <== NOT EXECUTED
return 1;
}
30010c14: e3a00001 mov r0, #1 <== NOT EXECUTED
30010c18: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30010d50 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
30010d50: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30010d54: e1a09000 mov r9, r0
30010d58: e24dd010 sub sp, sp, #16
* 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 ) {
30010d5c: e5900054 ldr r0, [r0, #84] ; 0x54
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
30010d60: e59db034 ldr fp, [sp, #52] ; 0x34
* 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 ) {
30010d64: e3500000 cmp r0, #0
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
30010d68: e1a06001 mov r6, r1 30010d6c: e1a07002 mov r7, r2 30010d70: e1a08003 mov r8, r3
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
30010d74: e08b1001 add r1, fp, r1
if ( last_byte > the_jnode->info.file.size ) {
30010d78: ba000054 blt 30010ed0 <IMFS_memfile_write+0x180>
30010d7c: 0a000050 beq 30010ec4 <IMFS_memfile_write+0x174>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
30010d80: e59f5170 ldr r5, [pc, #368] ; 30010ef8 <IMFS_memfile_write+0x1a8>
30010d84: e1a00006 mov r0, r6
30010d88: e5954000 ldr r4, [r5]
30010d8c: e1a01007 mov r1, r7
30010d90: e1a02004 mov r2, r4
30010d94: e1a03fc2 asr r3, r2, #31
30010d98: e88d000c stm sp, {r2, r3}
30010d9c: eb00164a bl 300166cc <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010da0: e89d000c ldm sp, {r2, r3}
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
30010da4: e1a0a000 mov sl, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010da8: e1a01007 mov r1, r7 30010dac: e1a00006 mov r0, r6 30010db0: eb001518 bl 30016218 <__divdi3>
if ( start_offset ) {
30010db4: e35a0000 cmp sl, #0
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
30010db8: e1a07000 mov r7, r0
if ( start_offset ) {
30010dbc: 01a0600b moveq r6, fp
30010dc0: 1a000016 bne 30010e20 <IMFS_memfile_write+0xd0>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
30010dc4: e1560004 cmp r6, r4
30010dc8: 2a000008 bcs 30010df0 <IMFS_memfile_write+0xa0>
30010dcc: ea000027 b 30010e70 <IMFS_memfile_write+0x120>
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
30010dd0: e5900000 ldr r0, [r0] 30010dd4: eb0006d4 bl 3001292c <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
30010dd8: e5953000 ldr r3, [r5]
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
src += to_copy;
30010ddc: e0888004 add r8, r8, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
30010de0: e1530006 cmp r3, r6
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
src += to_copy;
block++;
30010de4: e2877001 add r7, r7, #1
* IMFS_memfile_write * * This routine writes the specified data buffer into the in memory * file pointed to by the_jnode. The file is extended as needed. */ MEMFILE_STATIC ssize_t IMFS_memfile_write(
30010de8: e08aa004 add sl, sl, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
30010dec: 8a00001f bhi 30010e70 <IMFS_memfile_write+0x120>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
30010df0: e1a01007 mov r1, r7 30010df4: e3a02000 mov r2, #0 30010df8: e1a00009 mov r0, r9 30010dfc: ebfffdee bl 300105bc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
30010e00: e3500000 cmp r0, #0
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
30010e04: e1a01008 mov r1, r8 30010e08: e1a02004 mov r2, r4
src += to_copy;
block++;
my_length -= to_copy;
30010e0c: e0646006 rsb r6, r4, r6
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
30010e10: 1affffee bne 30010dd0 <IMFS_memfile_write+0x80>
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
30010e14: e1a0000a mov r0, sl <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
30010e18: e28dd010 add sp, sp, #16
30010e1c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
30010e20: e1a00009 mov r0, r9 <== NOT EXECUTED 30010e24: e1a01007 mov r1, r7 <== NOT EXECUTED 30010e28: e3a02000 mov r2, #0 <== NOT EXECUTED 30010e2c: ebfffde2 bl 300105bc <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
if ( !block_ptr )
30010e30: e3500000 cmp r0, #0 <== NOT EXECUTED 30010e34: 0afffff7 beq 30010e18 <IMFS_memfile_write+0xc8> <== 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;
30010e38: e06a4004 rsb r4, sl, r4 <== NOT EXECUTED
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
30010e3c: 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;
30010e40: e154000b cmp r4, fp <== NOT EXECUTED 30010e44: 21a0400b movcs r4, fp <== NOT EXECUTED
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
30010e48: e080000a add r0, r0, sl <== NOT EXECUTED 30010e4c: e1a01008 mov r1, r8 <== NOT EXECUTED 30010e50: e1a02004 mov r2, r4 <== NOT EXECUTED 30010e54: eb0006b4 bl 3001292c <memcpy> <== NOT EXECUTED
src += to_copy;
30010e58: e0888004 add r8, r8, r4 <== NOT EXECUTED
block++;
my_length -= to_copy;
30010e5c: e064600b rsb r6, r4, fp <== NOT EXECUTED
copied += to_copy;
30010e60: e1a0a004 mov sl, r4 <== NOT EXECUTED
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
src += to_copy;
block++;
30010e64: e2877001 add r7, r7, #1 <== NOT EXECUTED
my_length -= to_copy;
copied += to_copy;
30010e68: e5954000 ldr r4, [r5] <== NOT EXECUTED 30010e6c: eaffffd4 b 30010dc4 <IMFS_memfile_write+0x74> <== NOT EXECUTED
* 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 ) {
30010e70: e3560000 cmp r6, #0
30010e74: 0a00000a beq 30010ea4 <IMFS_memfile_write+0x154>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
30010e78: e1a00009 mov r0, r9 30010e7c: e1a01007 mov r1, r7 30010e80: e3a02000 mov r2, #0 30010e84: ebfffdcc bl 300105bc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
30010e88: e3500000 cmp r0, #0
30010e8c: 0affffe0 beq 30010e14 <IMFS_memfile_write+0xc4>
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 );
30010e90: e5900000 ldr r0, [r0] 30010e94: e1a01008 mov r1, r8 30010e98: e1a02006 mov r2, r6 30010e9c: eb0006a2 bl 3001292c <memcpy>
my_length = 0;
copied += to_copy;
30010ea0: e08aa006 add sl, sl, r6
}
IMFS_mtime_ctime_update( the_jnode );
30010ea4: e28d0008 add r0, sp, #8 30010ea8: e3a01000 mov r1, #0 30010eac: ebffd5a2 bl 3000653c <gettimeofday> 30010eb0: e59d3008 ldr r3, [sp, #8]
return copied;
30010eb4: e1a0000a mov r0, sl
memcpy( &(*block_ptr)[ 0 ], src, my_length );
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
30010eb8: e5893044 str r3, [r9, #68] ; 0x44 30010ebc: e5893048 str r3, [r9, #72] ; 0x48
return copied;
30010ec0: eaffffd4 b 30010e18 <IMFS_memfile_write+0xc8>
* 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 ) {
30010ec4: e5993050 ldr r3, [r9, #80] ; 0x50 30010ec8: e1530001 cmp r3, r1
30010ecc: 2affffab bcs 30010d80 <IMFS_memfile_write+0x30>
status = IMFS_memfile_extend( the_jnode, last_byte );
30010ed0: e1a00009 mov r0, r9 30010ed4: e3a02000 mov r2, #0 30010ed8: ebffff4f bl 30010c1c <IMFS_memfile_extend>
if ( status )
30010edc: e3500000 cmp r0, #0
30010ee0: 0affffa6 beq 30010d80 <IMFS_memfile_write+0x30>
rtems_set_errno_and_return_minus_one( ENOSPC );
30010ee4: eb000462 bl 30012074 <__errno> <== NOT EXECUTED 30010ee8: e3a0301c mov r3, #28 <== NOT EXECUTED 30010eec: e5803000 str r3, [r0] <== NOT EXECUTED 30010ef0: e3e00000 mvn r0, #0 <== NOT EXECUTED 30010ef4: eaffffc7 b 30010e18 <IMFS_memfile_write+0xc8> <== NOT EXECUTED
30005e0c <IMFS_mount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
30005e0c: e5903008 ldr r3, [r0, #8]
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
30005e10: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
30005e14: e593204c ldr r2, [r3, #76] ; 0x4c 30005e18: e3520001 cmp r2, #1
30005e1c: 1a000002 bne 30005e2c <IMFS_mount+0x20>
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
30005e20: e583005c str r0, [r3, #92] ; 0x5c
return 0;
30005e24: e3a00000 mov r0, #0
}
30005e28: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
30005e2c: eb003090 bl 30012074 <__errno> <== NOT EXECUTED
30005e30: e3a03014 mov r3, #20 <== NOT EXECUTED
30005e34: e5803000 str r3, [r0] <== NOT EXECUTED
30005e38: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005e3c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300087b0 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
300087b0: e92d4030 push {r4, r5, lr}
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
300087b4: e59f50f8 ldr r5, [pc, #248] ; 300088b4 <IMFS_print_jnode+0x104>
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
300087b8: e1a04000 mov r4, r0
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
300087bc: e5953000 ldr r3, [r5] 300087c0: e280000c add r0, r0, #12 300087c4: e5931008 ldr r1, [r3, #8] 300087c8: eb003866 bl 30016968 <fputs>
switch( the_jnode->type ) {
300087cc: e594204c ldr r2, [r4, #76] ; 0x4c 300087d0: e2423001 sub r3, r2, #1 300087d4: e3530006 cmp r3, #6 300087d8: 979ff103 ldrls pc, [pc, r3, lsl #2]
300087dc: ea000023 b 30008870 <IMFS_print_jnode+0xc0> <== NOT EXECUTED 300087e0: 30008884 .word 0x30008884 <== NOT EXECUTED 300087e4: 30008898 .word 0x30008898 <== NOT EXECUTED 300087e8: 300087fc .word 0x300087fc <== NOT EXECUTED 300087ec: 300087fc .word 0x300087fc <== NOT EXECUTED 300087f0: 30008834 .word 0x30008834 <== NOT EXECUTED 300087f4: 30008854 .word 0x30008854 <== NOT EXECUTED 300087f8: 30008818 .word 0x30008818 <== NOT EXECUTED
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
300087fc: e5953000 ldr r3, [r5] <== NOT EXECUTED 30008800: e59f00b0 ldr r0, [pc, #176] ; 300088b8 <IMFS_print_jnode+0x108><== NOT EXECUTED 30008804: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30008808: e3a01001 mov r1, #1 <== NOT EXECUTED 3000880c: e3a02013 mov r2, #19 <== NOT EXECUTED
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
30008810: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
30008814: ea003b83 b 30017628 <fwrite> <== NOT EXECUTED
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
30008818: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000881c: e59f0098 ldr r0, [pc, #152] ; 300088bc <IMFS_print_jnode+0x10c><== NOT EXECUTED 30008820: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30008824: e3a01001 mov r1, #1 <== NOT EXECUTED 30008828: e3a02012 mov r2, #18 <== NOT EXECUTED
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
3000882c: 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" );
30008830: ea003b7c b 30017628 <fwrite> <== NOT EXECUTED
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
30008834: e5953000 ldr r3, [r5] <== NOT EXECUTED 30008838: e59f1080 ldr r1, [pc, #128] ; 300088c0 <IMFS_print_jnode+0x110><== NOT EXECUTED 3000883c: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 30008840: e5942050 ldr r2, [r4, #80] ; 0x50 <== NOT EXECUTED 30008844: eb0037f2 bl 30016814 <fprintf> <== NOT EXECUTED
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
30008848: e59f0074 ldr r0, [pc, #116] ; 300088c4 <IMFS_print_jnode+0x114>
}
3000884c: e8bd4030 pop {r4, r5, lr}
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
30008850: ea003f56 b 300185b0 <puts>
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
30008854: e5953000 ldr r3, [r5] 30008858: e59f1068 ldr r1, [pc, #104] ; 300088c8 <IMFS_print_jnode+0x118> 3000885c: e5930008 ldr r0, [r3, #8] 30008860: e5942050 ldr r2, [r4, #80] ; 0x50 30008864: e5943058 ldr r3, [r4, #88] ; 0x58 30008868: eb0037e9 bl 30016814 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
3000886c: eafffff5 b 30008848 <IMFS_print_jnode+0x98>
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
30008870: e5953000 ldr r3, [r5] <== NOT EXECUTED 30008874: e59f1050 ldr r1, [pc, #80] ; 300088cc <IMFS_print_jnode+0x11c><== NOT EXECUTED 30008878: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
return;
}
puts("");
}
3000887c: 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 );
30008880: ea0037e3 b 30016814 <fprintf> <== NOT EXECUTED
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
30008884: e5953000 ldr r3, [r5] 30008888: e3a0002f mov r0, #47 ; 0x2f 3000888c: e5931008 ldr r1, [r3, #8] 30008890: eb0037ff bl 30016894 <fputc>
break;
30008894: eaffffeb b 30008848 <IMFS_print_jnode+0x98>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
30008898: e5953000 ldr r3, [r5] 3000889c: e59f102c ldr r1, [pc, #44] ; 300088d0 <IMFS_print_jnode+0x120> 300088a0: e5930008 ldr r0, [r3, #8] 300088a4: e5942050 ldr r2, [r4, #80] ; 0x50 300088a8: e5943054 ldr r3, [r4, #84] ; 0x54 300088ac: eb0037d8 bl 30016814 <fprintf>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
300088b0: eaffffe4 b 30008848 <IMFS_print_jnode+0x98>
30005e4c <IMFS_readlink>:
node = loc->node_access;
IMFS_assert( node->type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
30005e4c: e3520000 cmp r2, #0 <== NOT EXECUTED
ssize_t IMFS_readlink(
rtems_filesystem_location_info_t *loc,
char *buf, /* OUT */
size_t bufsize
)
{
30005e50: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
IMFS_jnode_t *node;
ssize_t i;
node = loc->node_access;
30005e54: e5904000 ldr r4, [r0] <== NOT EXECUTED
IMFS_assert( node->type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
30005e58: 01a00002 moveq r0, r2 <== NOT EXECUTED 30005e5c: 0a000010 beq 30005ea4 <IMFS_readlink+0x58> <== NOT EXECUTED 30005e60: e5943050 ldr r3, [r4, #80] ; 0x50 <== NOT EXECUTED 30005e64: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 30005e68: e3530000 cmp r3, #0 <== NOT EXECUTED 30005e6c: 01a00003 moveq r0, r3 <== NOT EXECUTED 30005e70: 0a00000b beq 30005ea4 <IMFS_readlink+0x58> <== NOT EXECUTED 30005e74: e3a0c000 mov ip, #0 <== NOT EXECUTED 30005e78: e1a0000c mov r0, ip <== NOT EXECUTED 30005e7c: ea000003 b 30005e90 <IMFS_readlink+0x44> <== NOT EXECUTED 30005e80: e5943050 ldr r3, [r4, #80] ; 0x50 <== NOT EXECUTED 30005e84: e7d33000 ldrb r3, [r3, r0] <== NOT EXECUTED 30005e88: e3530000 cmp r3, #0 <== NOT EXECUTED 30005e8c: 0a000004 beq 30005ea4 <IMFS_readlink+0x58> <== NOT EXECUTED 30005e90: e2800001 add r0, r0, #1 <== NOT EXECUTED 30005e94: e1500002 cmp r0, r2 <== NOT EXECUTED
buf[i] = node->info.sym_link.name[i];
30005e98: e7c1300c strb r3, [r1, ip] <== 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++ )
30005e9c: e1a0c000 mov ip, r0 <== NOT EXECUTED 30005ea0: 3afffff6 bcc 30005e80 <IMFS_readlink+0x34> <== NOT EXECUTED
buf[i] = node->info.sym_link.name[i];
return i;
}
30005ea4: e8bd0010 pop {r4} <== NOT EXECUTED
30005ea8: e12fff1e bx lr <== NOT EXECUTED
30005eac <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 */
)
{
30005eac: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
30005eb0: 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 */
)
{
30005eb4: e24dd008 sub sp, sp, #8 <== 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 );
30005eb8: e1a01003 mov r1, r3 <== 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 */
)
{
30005ebc: 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 );
30005ec0: e284000c add r0, r4, #12 <== NOT EXECUTED 30005ec4: e3a02020 mov r2, #32 <== NOT EXECUTED 30005ec8: eb00346b bl 3001307c <strncpy> <== NOT EXECUTED
if ( the_jnode->Parent != NULL )
30005ecc: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30005ed0: e3530000 cmp r3, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
30005ed4: 11a00004 movne r0, r4 <== NOT EXECUTED 30005ed8: 1b00119b blne 3000a54c <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
30005edc: e5953000 ldr r3, [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 );
30005ee0: e1a01004 mov r1, r4 <== NOT EXECUTED 30005ee4: e2830050 add r0, r3, #80 ; 0x50 <== NOT EXECUTED
the_jnode->Parent = new_parent;
30005ee8: e5843008 str r3, [r4, #8] <== NOT EXECUTED 30005eec: eb00118b bl 3000a520 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
30005ef0: e1a0000d mov r0, sp <== NOT EXECUTED 30005ef4: e3a01000 mov r1, #0 <== NOT EXECUTED 30005ef8: eb00018f bl 3000653c <gettimeofday> <== NOT EXECUTED 30005efc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
}
30005f00: 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 );
30005f04: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
30005f08: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30005f0c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000e4e0 <IMFS_stat>:
{
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
3000e4e0: e5903000 ldr r3, [r0]
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
3000e4e4: e92d40f0 push {r4, r5, r6, r7, lr}
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
3000e4e8: e593204c ldr r2, [r3, #76] ; 0x4c 3000e4ec: e2422002 sub r2, r2, #2 3000e4f0: e3520005 cmp r2, #5 3000e4f4: 979ff102 ldrls pc, [pc, r2, lsl #2]
3000e4f8: ea000026 b 3000e598 <IMFS_stat+0xb8> <== NOT EXECUTED 3000e4fc: 3000e584 .word 0x3000e584 <== NOT EXECUTED 3000e500: 3000e598 .word 0x3000e598 <== NOT EXECUTED 3000e504: 3000e514 .word 0x3000e514 <== NOT EXECUTED 3000e508: 3000e5ac .word 0x3000e5ac <== NOT EXECUTED 3000e50c: 3000e5ac .word 0x3000e5ac <== NOT EXECUTED 3000e510: 3000e514 .word 0x3000e514 <== NOT EXECUTED
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
3000e514: e3a04000 mov r4, #0 <== NOT EXECUTED 3000e518: e3a05000 mov r5, #0 <== NOT EXECUTED 3000e51c: e5814020 str r4, [r1, #32] <== NOT EXECUTED 3000e520: e5815024 str r5, [r1, #36] ; 0x24 <== 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;
3000e524: e5902010 ldr r2, [r0, #16]
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
3000e528: e1d373b4 ldrh r7, [r3, #52] ; 0x34
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
3000e52c: e5922034 ldr r2, [r2, #52] ; 0x34
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
3000e530: e5930044 ldr r0, [r3, #68] ; 0x44
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
3000e534: e5935030 ldr r5, [r3, #48] ; 0x30
buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino;
3000e538: e5934038 ldr r4, [r3, #56] ; 0x38
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
3000e53c: e5926000 ldr r6, [r2]
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
3000e540: e593c040 ldr ip, [r3, #64] ; 0x40
buf->st_mtime = the_jnode->stat_mtime; buf->st_ctime = the_jnode->stat_ctime;
3000e544: e5932048 ldr r2, [r3, #72] ; 0x48
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
3000e548: e1c171b0 strh r7, [r1, #16]
/* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; buf->st_dev =
3000e54c: e59f706c ldr r7, [pc, #108] ; 3000e5c0 <IMFS_stat+0xe0> 3000e550: e5817000 str r7, [r1]
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
3000e554: e1d373bc ldrh r7, [r3, #60] ; 0x3c
buf->st_gid = the_jnode->st_gid;
3000e558: e1d333be ldrh r3, [r3, #62] ; 0x3e
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
3000e55c: e1c171b2 strh r7, [r1, #18]
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
3000e560: e5810030 str r0, [r1, #48] ; 0x30
/* * 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 =
3000e564: e5816004 str r6, [r1, #4]
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
3000e568: e1c131b4 strh r3, [r1, #20]
*/
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;
3000e56c: e581500c str r5, [r1, #12]
buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino;
3000e570: e5814008 str r4, [r1, #8]
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
3000e574: e581c028 str ip, [r1, #40] ; 0x28
buf->st_mtime = the_jnode->stat_mtime; buf->st_ctime = the_jnode->stat_ctime;
3000e578: e5812038 str r2, [r1, #56] ; 0x38
return 0;
3000e57c: e3a00000 mov r0, #0
}
3000e580: e8bd80f0 pop {r4, r5, r6, r7, pc}
switch ( the_jnode->type ) {
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
3000e584: e593c054 ldr ip, [r3, #84] ; 0x54
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
3000e588: e5932050 ldr r2, [r3, #80] ; 0x50 3000e58c: e581c01c str ip, [r1, #28] 3000e590: e5812018 str r2, [r1, #24]
break;
3000e594: eaffffe2 b 3000e524 <IMFS_stat+0x44>
case IMFS_FIFO:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000e598: eb000eb5 bl 30012074 <__errno> <== NOT EXECUTED
3000e59c: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
3000e5a0: e5803000 str r3, [r0] <== NOT EXECUTED
3000e5a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000e5a8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
break;
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
3000e5ac: e2835050 add r5, r3, #80 ; 0x50
3000e5b0: e8950030 ldm r5, {r4, r5}
3000e5b4: e5814020 str r4, [r1, #32]
3000e5b8: e5815024 str r5, [r1, #36] ; 0x24
break;
3000e5bc: eaffffd8 b 3000e524 <IMFS_stat+0x44>
30005f10 <IMFS_symlink>:
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
30005f10: e92d40f0 push {r4, r5, r6, r7, lr}
30005f14: e1a06000 mov r6, r0
30005f18: 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 );
30005f1c: e1a00002 mov r0, r2
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
30005f20: e1a07002 mov r7, r2 30005f24: e1a05001 mov r5, r1
int i;
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
30005f28: eb00343b bl 3001301c <strlen> 30005f2c: e28d4004 add r4, sp, #4 30005f30: e1a01000 mov r1, r0 30005f34: e1a02004 mov r2, r4 30005f38: e28d303c add r3, sp, #60 ; 0x3c 30005f3c: e1a00007 mov r0, r7 30005f40: eb0020fb bl 3000e334 <IMFS_get_token>
/*
* Duplicate link name
*/
info.sym_link.name = strdup(link_name);
30005f44: e1a00005 mov r0, r5 30005f48: eb00341f bl 30012fcc <strdup>
if (info.sym_link.name == NULL) {
30005f4c: 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);
30005f50: e58d0028 str r0, [sp, #40] ; 0x28
if (info.sym_link.name == NULL) {
30005f54: 0a00000d beq 30005f90 <IMFS_symlink+0x80>
new_node = IMFS_create_node(
parent_loc,
IMFS_SYM_LINK,
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
30005f58: 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(
30005f5c: e58d3000 str r3, [sp] 30005f60: e3a01004 mov r1, #4 30005f64: e1a00006 mov r0, r6 30005f68: e1a02004 mov r2, r4 30005f6c: e59f3030 ldr r3, [pc, #48] ; 30005fa4 <IMFS_symlink+0x94> 30005f70: eb001e49 bl 3000d89c <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
30005f74: e3500000 cmp r0, #0
free(info.sym_link.name);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
return 0;
30005f78: 13a00000 movne r0, #0
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
30005f7c: 0a000001 beq 30005f88 <IMFS_symlink+0x78>
free(info.sym_link.name);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
return 0;
}
30005f80: e28dd040 add sp, sp, #64 ; 0x40
30005f84: e8bd80f0 pop {r4, r5, r6, r7, pc}
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
free(info.sym_link.name);
30005f88: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED 30005f8c: eb000141 bl 30006498 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
30005f90: eb003037 bl 30012074 <__errno> <== NOT EXECUTED 30005f94: e3a0300c mov r3, #12 <== NOT EXECUTED 30005f98: e5803000 str r3, [r0] <== NOT EXECUTED 30005f9c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30005fa0: eafffff6 b 30005f80 <IMFS_symlink+0x70> <== NOT EXECUTED
30005fa8 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005fa8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
30005fac: e5915000 ldr r5, [r1]
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005fb0: e24dd01c sub sp, sp, #28
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30005fb4: e595304c ldr r3, [r5, #76] ; 0x4c
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005fb8: e1a04001 mov r4, r1
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30005fbc: e3530003 cmp r3, #3
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005fc0: e1a06000 mov r6, r0
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30005fc4: 0a000006 beq 30005fe4 <IMFS_unlink+0x3c>
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
30005fc8: e5943008 ldr r3, [r4, #8] 30005fcc: e1a00006 mov r0, r6 30005fd0: e1a01004 mov r1, r4 30005fd4: e1a0e00f mov lr, pc 30005fd8: e593f034 ldr pc, [r3, #52] ; 0x34
return result;
}
30005fdc: e28dd01c add sp, sp, #28
30005fe0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
30005fe4: e595e050 ldr lr, [r5, #80] ; 0x50 <== NOT EXECUTED 30005fe8: e35e0000 cmp lr, #0 <== NOT EXECUTED 30005fec: 0a00001f beq 30006070 <IMFS_unlink+0xc8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
30005ff0: e1a0c00d mov ip, sp <== NOT EXECUTED
30005ff4: e1a07001 mov r7, r1 <== NOT EXECUTED
30005ff8: e8b7000f ldm r7!, {r0, r1, r2, r3} <== NOT EXECUTED
30005ffc: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30006000: e5973000 ldr r3, [r7] <== NOT EXECUTED
the_link.node_access = node->info.hard_link.link_node;
30006004: e28d801c add r8, sp, #28 <== NOT EXECUTED
IMFS_Set_handlers( &the_link );
30006008: 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;
3000600c: e58c3000 str r3, [ip] <== NOT EXECUTED
the_link.node_access = node->info.hard_link.link_node;
30006010: e528e01c str lr, [r8, #-28]! <== NOT EXECUTED
IMFS_Set_handlers( &the_link );
30006014: eb001e84 bl 3000da2c <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)
30006018: e5953050 ldr r3, [r5, #80] ; 0x50 <== NOT EXECUTED 3000601c: e1d323b4 ldrh r2, [r3, #52] ; 0x34 <== NOT EXECUTED 30006020: e3520001 cmp r2, #1 <== NOT EXECUTED 30006024: 0a000008 beq 3000604c <IMFS_unlink+0xa4> <== NOT EXECUTED
if ( result != 0 )
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
30006028: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000602c: e1c323b4 strh r2, [r3, #52] ; 0x34 <== NOT EXECUTED
IMFS_update_ctime( node->info.hard_link.link_node );
30006030: e28d0014 add r0, sp, #20 <== NOT EXECUTED 30006034: e3a01000 mov r1, #0 <== NOT EXECUTED 30006038: eb00013f bl 3000653c <gettimeofday> <== NOT EXECUTED 3000603c: e5953050 ldr r3, [r5, #80] ; 0x50 <== NOT EXECUTED 30006040: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 30006044: e5832048 str r2, [r3, #72] ; 0x48 <== NOT EXECUTED 30006048: eaffffde b 30005fc8 <IMFS_unlink+0x20> <== NOT EXECUTED
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
3000604c: e1a00006 mov r0, r6 <== NOT EXECUTED 30006050: e1a0100d mov r1, sp <== NOT EXECUTED 30006054: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30006058: e1a0e00f mov lr, pc <== NOT EXECUTED 3000605c: e593f034 ldr pc, [r3, #52] ; 0x34 <== NOT EXECUTED
if ( result != 0 )
30006060: e3500000 cmp r0, #0 <== NOT EXECUTED 30006064: 0affffd7 beq 30005fc8 <IMFS_unlink+0x20> <== NOT EXECUTED
return -1;
30006068: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000606c: eaffffda b 30005fdc <IMFS_unlink+0x34> <== NOT EXECUTED
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
30006070: eb002fff bl 30012074 <__errno> <== NOT EXECUTED 30006074: e3a03016 mov r3, #22 <== NOT EXECUTED 30006078: e5803000 str r3, [r0] <== NOT EXECUTED 3000607c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30006080: eaffffd5 b 30005fdc <IMFS_unlink+0x34> <== NOT EXECUTED
30006084 <IMFS_unmount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
30006084: e5903008 ldr r3, [r0, #8]
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
30006088: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
3000608c: e593204c ldr r2, [r3, #76] ; 0x4c 30006090: e3520001 cmp r2, #1
30006094: 1a000005 bne 300060b0 <IMFS_unmount+0x2c>
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
30006098: e593205c ldr r2, [r3, #92] ; 0x5c 3000609c: e3520000 cmp r2, #0
300060a0: 0a000007 beq 300060c4 <IMFS_unmount+0x40>
/*
* 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;
300060a4: e3a00000 mov r0, #0 300060a8: e583005c str r0, [r3, #92] ; 0x5c
return 0;
}
300060ac: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
300060b0: eb002fef bl 30012074 <__errno> <== NOT EXECUTED
300060b4: e3a03014 mov r3, #20 <== NOT EXECUTED
300060b8: e5803000 str r3, [r0] <== NOT EXECUTED
300060bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
300060c0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
300060c4: eb002fea bl 30012074 <__errno> <== NOT EXECUTED
300060c8: e3a03016 mov r3, #22 <== NOT EXECUTED
300060cc: e5803000 str r3, [r0] <== NOT EXECUTED
300060d0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300060d4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300060d8 <IMFS_utime>:
int IMFS_utime(
rtems_filesystem_location_info_t *pathloc, /* IN */
time_t actime, /* IN */
time_t modtime /* IN */
)
{
300060d8: e92d4010 push {r4, lr} <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
300060dc: e5904000 ldr r4, [r0] <== NOT EXECUTED
the_jnode->stat_atime = actime;
the_jnode->stat_mtime = modtime;
the_jnode->stat_ctime = time( NULL );
300060e0: e3a00000 mov r0, #0 <== NOT EXECUTED
{
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
the_jnode->stat_atime = actime;
300060e4: e5841040 str r1, [r4, #64] ; 0x40 <== NOT EXECUTED
the_jnode->stat_mtime = modtime;
300060e8: e5842044 str r2, [r4, #68] ; 0x44 <== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
300060ec: eb00341d bl 30013168 <time> <== NOT EXECUTED 300060f0: e5840048 str r0, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
300060f4: e3a00000 mov r0, #0 <== NOT EXECUTED
300060f8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30006714 <RTEMS_Malloc_Initialize>:
)
{
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
30006714: e59f30cc ldr r3, [pc, #204] ; 300067e8 <RTEMS_Malloc_Initialize+0xd4>
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
30006718: e92d4070 push {r4, r5, r6, lr}
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
3000671c: e5933000 ldr r3, [r3]
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
30006720: e1a05000 mov r5, r0
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
30006724: e3530000 cmp r3, #0
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
30006728: e1a06001 mov r6, r1 3000672c: e1a04002 mov r4, r2
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
(*rtems_malloc_statistics_helpers->initialize)();
30006730: 11a0e00f movne lr, pc 30006734: 1593f000 ldrne pc, [r3]
}
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
30006738: ebffffe1 bl 300066c4 <malloc_deferred_frees_initialize>
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
3000673c: e59f30a8 ldr r3, [pc, #168] ; 300067ec <RTEMS_Malloc_Initialize+0xd8> 30006740: e5933000 ldr r3, [r3] 30006744: e3530000 cmp r3, #0
30006748: 0a000005 beq 30006764 <RTEMS_Malloc_Initialize+0x50>
heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
3000674c: e1a00005 mov r0, r5 <== NOT EXECUTED 30006750: e1a01004 mov r1, r4 <== NOT EXECUTED 30006754: e1a0e00f mov lr, pc <== NOT EXECUTED 30006758: e593f000 ldr pc, [r3] <== NOT EXECUTED
heap_begin,
sbrk_amount
);
heap_size = (uintptr_t) sbrk_amount;
3000675c: e1a06004 mov r6, r4 <== NOT EXECUTED
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
30006760: e1a05000 mov r5, 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 (
30006764: e59f4084 ldr r4, [pc, #132] ; 300067f0 <RTEMS_Malloc_Initialize+0xdc> 30006768: e5d41000 ldrb r1, [r4] 3000676c: e3510000 cmp r1, #0
30006770: 1a000018 bne 300067d8 <RTEMS_Malloc_Initialize+0xc4>
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
30006774: e59f3078 ldr r3, [pc, #120] ; 300067f4 <RTEMS_Malloc_Initialize+0xe0> 30006778: e5d33028 ldrb r3, [r3, #40] ; 0x28 3000677c: e3530000 cmp r3, #0
30006780: 1a00000e bne 300067c0 <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 );
30006784: e59f406c ldr r4, [pc, #108] ; 300067f8 <RTEMS_Malloc_Initialize+0xe4> 30006788: e1a01005 mov r1, r5 3000678c: e5940000 ldr r0, [r4] 30006790: e1a02006 mov r2, r6 30006794: e3a03008 mov r3, #8 30006798: eb001119 bl 3000ac04 <_Heap_Initialize>
RTEMS_Malloc_Heap,
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
3000679c: e3500000 cmp r0, #0
300067a0: 0a00000e beq 300067e0 <RTEMS_Malloc_Initialize+0xcc>
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
}
MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
300067a4: e59f5050 ldr r5, [pc, #80] ; 300067fc <RTEMS_Malloc_Initialize+0xe8> 300067a8: e5940000 ldr r0, [r4] 300067ac: e5954000 ldr r4, [r5] 300067b0: eb0013d1 bl 3000b6fc <_Protected_heap_Get_size> 300067b4: e0800004 add r0, r0, r4 300067b8: e5850000 str r0, [r5]
}
300067bc: e8bd8070 pop {r4, r5, r6, pc}
if (
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
) {
memset( heap_begin, 0, heap_size );
300067c0: e1a00005 mov r0, r5 300067c4: e1a02006 mov r2, r6 300067c8: eb00308e bl 30012a08 <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 ) {
300067cc: e5d43000 ldrb r3, [r4] 300067d0: e3530000 cmp r3, #0
300067d4: 0affffea beq 30006784 <RTEMS_Malloc_Initialize+0x70>
300067d8: e59f4018 ldr r4, [pc, #24] ; 300067f8 <RTEMS_Malloc_Initialize+0xe4> 300067dc: eafffff0 b 300067a4 <RTEMS_Malloc_Initialize+0x90>
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
300067e0: e280001a add r0, r0, #26 <== NOT EXECUTED 300067e4: eb000e82 bl 3000a1f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
3000641c <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
3000641c: e92d4ff0 push {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);
30006420: e59030bc ldr r3, [r0, #188] ; 0xbc <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
30006424: e59060b8 ldr r6, [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);
30006428: e283c010 add ip, r3, #16 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
3000642c: e2466010 sub r6, r6, #16 <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
30006430: e28cb010 add fp, ip, #16 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
30006434: e3c61003 bic r1, r6, #3 <== NOT EXECUTED 30006438: e08b1001 add r1, fp, r1 <== NOT EXECUTED 3000643c: e15b0001 cmp fp, r1 <== NOT EXECUTED
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
30006440: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 30006444: 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 );
30006448: e59090e8 ldr r9, [r0, #232] ; 0xe8 <== 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++)
3000644c: 2a00000b bcs 30006480 <Stack_check_Dump_threads_usage+0x64><== NOT EXECUTED
if (*base != U32_PATTERN)
30006450: e59c0010 ldr r0, [ip, #16] <== NOT EXECUTED 30006454: e59f20d0 ldr r2, [pc, #208] ; 3000652c <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED 30006458: e1500002 cmp r0, r2 <== 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(
3000645c: 02833024 addeq r3, r3, #36 ; 0x24 <== NOT EXECUTED
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
30006460: 0a000003 beq 30006474 <Stack_check_Dump_threads_usage+0x58><== NOT EXECUTED 30006464: ea000027 b 30006508 <Stack_check_Dump_threads_usage+0xec> <== NOT EXECUTED 30006468: e4932004 ldr r2, [r3], #4 <== NOT EXECUTED 3000646c: e1520000 cmp r2, r0 <== NOT EXECUTED 30006470: 1a000024 bne 30006508 <Stack_check_Dump_threads_usage+0xec><== 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++)
30006474: e1510003 cmp r1, r3 <== NOT EXECUTED
if (*base != U32_PATTERN)
30006478: e1a0b003 mov fp, 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++)
3000647c: 8afffff9 bhi 30006468 <Stack_check_Dump_threads_usage+0x4c><== 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;
30006480: e3a0b000 mov fp, #0 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
#endif
{
(*print_handler)(
30006484: e5958008 ldr r8, [r5, #8] <== NOT EXECUTED
30006488: e59f40a0 ldr r4, [pc, #160] ; 30006530 <Stack_check_Dump_threads_usage+0x114><== NOT EXECUTED
3000648c: e3a01005 mov r1, #5 <== NOT EXECUTED
30006490: e28d2008 add r2, sp, #8 <== NOT EXECUTED
30006494: e1a00008 mov r0, r8 <== NOT EXECUTED
30006498: e8940480 ldm r4, {r7, sl} <== NOT EXECUTED
3000649c: eb00184d bl 3000c5d8 <rtems_object_get_name> <== NOT EXECUTED
300064a0: e1a02008 mov r2, r8 <== NOT EXECUTED
300064a4: e1a03000 mov r3, r0 <== NOT EXECUTED
300064a8: e59f1084 ldr r1, [pc, #132] ; 30006534 <Stack_check_Dump_threads_usage+0x118><== NOT EXECUTED
300064ac: e1a0000a mov r0, sl <== NOT EXECUTED
300064b0: e1a0e00f mov lr, pc <== NOT EXECUTED
300064b4: e12fff17 bx r7 <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
300064b8: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 300064bc: e59520bc ldr r2, [r5, #188] ; 0xbc <== NOT EXECUTED 300064c0: e2433001 sub r3, r3, #1 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
300064c4: e0823003 add r3, r2, r3 <== NOT EXECUTED 300064c8: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 300064cc: e58d9000 str r9, [sp] <== NOT EXECUTED 300064d0: e58d6004 str r6, [sp, #4] <== NOT EXECUTED 300064d4: e59f105c ldr r1, [pc, #92] ; 30006538 <Stack_check_Dump_threads_usage+0x11c><== NOT EXECUTED 300064d8: e1a0e00f mov lr, pc <== NOT EXECUTED 300064dc: e594f000 ldr pc, [r4] <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
300064e0: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 300064e4: e3530000 cmp r3, #0 <== NOT EXECUTED 300064e8: 0a00000a beq 30006518 <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
300064ec: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 300064f0: e59f1044 ldr r1, [pc, #68] ; 3000653c <Stack_check_Dump_threads_usage+0x120><== NOT EXECUTED 300064f4: e1a0200b mov r2, fp <== NOT EXECUTED 300064f8: e1a0e00f mov lr, pc <== NOT EXECUTED 300064fc: e594f000 ldr pc, [r4] <== NOT EXECUTED
}
}
30006500: e28dd010 add sp, sp, #16 <== NOT EXECUTED
30006504: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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 )
30006508: e35b0000 cmp fp, #0 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
3000650c: 108cc006 addne ip, ip, r6 <== NOT EXECUTED 30006510: 106bb00c rsbne fp, fp, ip <== NOT EXECUTED 30006514: eaffffda b 30006484 <Stack_check_Dump_threads_usage+0x68> <== NOT EXECUTED
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
30006518: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 3000651c: e59f101c ldr r1, [pc, #28] ; 30006540 <Stack_check_Dump_threads_usage+0x124><== NOT EXECUTED 30006520: e1a0e00f mov lr, pc <== NOT EXECUTED 30006524: e594f000 ldr pc, [r4] <== NOT EXECUTED 30006528: eafffff4 b 30006500 <Stack_check_Dump_threads_usage+0xe4> <== NOT EXECUTED
300065f0 <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)
{
300065f0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
300065f4: e1a06000 mov r6, r0 <== NOT EXECUTED
300065f8: e24dd020 sub sp, sp, #32 <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
char name[32];
printk("BLOWN STACK!!!\n");
300065fc: e59f0084 ldr r0, [pc, #132] ; 30006688 <Stack_check_report_blown_task+0x98><== 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)
{
30006600: e20140ff and r4, r1, #255 ; 0xff <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack);
30006604: e59650bc ldr r5, [r6, #188] ; 0xbc <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
30006608: eb00078e bl 30008448 <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
3000660c: e59f0078 ldr r0, [pc, #120] ; 3000668c <Stack_check_report_blown_task+0x9c><== NOT EXECUTED 30006610: e1a01006 mov r1, r6 <== NOT EXECUTED 30006614: eb00078b bl 30008448 <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
30006618: e59f0070 ldr r0, [pc, #112] ; 30006690 <Stack_check_report_blown_task+0xa0><== NOT EXECUTED 3000661c: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 30006620: eb000788 bl 30008448 <printk> <== NOT EXECUTED
printk(
30006624: e59f0068 ldr r0, [pc, #104] ; 30006694 <Stack_check_report_blown_task+0xa4><== NOT EXECUTED 30006628: e596100c ldr r1, [r6, #12] <== NOT EXECUTED 3000662c: eb000785 bl 30008448 <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
30006630: e1a0200d mov r2, sp <== NOT EXECUTED 30006634: e3a01020 mov r1, #32 <== NOT EXECUTED 30006638: e5960008 ldr r0, [r6, #8] <== NOT EXECUTED 3000663c: eb0017e5 bl 3000c5d8 <rtems_object_get_name> <== NOT EXECUTED 30006640: e1a01000 mov r1, r0 <== NOT EXECUTED 30006644: e59f004c ldr r0, [pc, #76] ; 30006698 <Stack_check_report_blown_task+0xa8><== NOT EXECUTED 30006648: eb00077e bl 30008448 <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)
3000664c: e59620bc ldr r2, [r6, #188] ; 0xbc <== NOT EXECUTED 30006650: 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(
30006654: e59f0040 ldr r0, [pc, #64] ; 3000669c <Stack_check_report_blown_task+0xac><== NOT EXECUTED 30006658: e0823001 add r3, r2, r1 <== NOT EXECUTED 3000665c: eb000779 bl 30008448 <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) {
30006660: e3540000 cmp r4, #0 <== NOT EXECUTED 30006664: 0a000001 beq 30006670 <Stack_check_report_blown_task+0x80> <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
30006668: e3a00081 mov r0, #129 ; 0x81 <== NOT EXECUTED 3000666c: eb0019e1 bl 3000cdf8 <rtems_fatal_error_occurred> <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
30006670: e59f0028 ldr r0, [pc, #40] ; 300066a0 <Stack_check_report_blown_task+0xb0><== NOT EXECUTED 30006674: e3a01010 mov r1, #16 <== NOT EXECUTED 30006678: e2852008 add r2, r5, #8 <== NOT EXECUTED 3000667c: e2853018 add r3, r5, #24 <== NOT EXECUTED 30006680: eb000770 bl 30008448 <printk> <== NOT EXECUTED 30006684: eafffff7 b 30006668 <Stack_check_report_blown_task+0x78> <== NOT EXECUTED
3001004c <TOD_MICROSECONDS_TO_TICKS>:
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
return (microseconds / rtems_configuration_get_microseconds_per_tick());
3001004c: e59f300c ldr r3, [pc, #12] ; 30010060 <TOD_MICROSECONDS_TO_TICKS+0x14><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
30010050: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (microseconds / rtems_configuration_get_microseconds_per_tick());
30010054: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 30010058: eb00520a bl 30024888 <__aeabi_uidiv> <== NOT EXECUTED
}
3001005c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b73c <TOD_MILLISECONDS_TO_TICKS>:
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000b73c: e59f3018 ldr r3, [pc, #24] ; 3000b75c <TOD_MILLISECONDS_TO_TICKS+0x20><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000b740: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000b744: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3000b748: e59f3010 ldr r3, [pc, #16] ; 3000b760 <TOD_MILLISECONDS_TO_TICKS+0x24><== NOT EXECUTED 3000b74c: e0812193 umull r2, r1, r3, r1 <== NOT EXECUTED 3000b750: e1a01321 lsr r1, r1, #6 <== NOT EXECUTED 3000b754: eb00443a bl 3001c844 <__aeabi_uidiv> <== NOT EXECUTED
}
3000b758: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30011e60 <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 /
30011e60: e59f3010 ldr r3, [pc, #16] ; 30011e78 <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)
{
30011e64: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (TOD_MICROSECONDS_PER_SECOND /
30011e68: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 30011e6c: e59f0008 ldr r0, [pc, #8] ; 30011e7c <TOD_TICKS_PER_SECOND_method+0x1c><== NOT EXECUTED 30011e70: eb000e42 bl 30015780 <__aeabi_uidiv> <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
}
30011e74: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30014234 <_Barrier_Translate_core_barrier_return_code>:
*/
#if defined(RTEMS_DEBUG)
if ( the_barrier_status > CORE_BARRIER_STATUS_LAST )
return RTEMS_INTERNAL_ERROR;
#endif
return _Barrier_Translate_core_barrier_return_code_[the_barrier_status];
30014234: e59f3004 ldr r3, [pc, #4] ; 30014240 <_Barrier_Translate_core_barrier_return_code+0xc><== NOT EXECUTED
}
30014238: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3001423c: e12fff1e bx lr <== NOT EXECUTED
3000cfcc <_CORE_RWLock_Initialize>:
CORE_RWLock_Control *the_rwlock,
CORE_RWLock_Attributes *the_rwlock_attributes
)
{
the_rwlock->Attributes = *the_rwlock_attributes;
3000cfcc: 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(
3000cfd0: 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;
3000cfd4: e3a01000 mov r1, #0 <== NOT EXECUTED
CORE_RWLock_Control *the_rwlock,
CORE_RWLock_Attributes *the_rwlock_attributes
)
{
the_rwlock->Attributes = *the_rwlock_attributes;
3000cfd8: 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(
3000cfdc: 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;
3000cfe0: e5801048 str r1, [r0, #72] ; 0x48 <== NOT EXECUTED
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
3000cfe4: e5801044 str r1, [r0, #68] ; 0x44 <== NOT EXECUTED
_Thread_queue_Initialize(
3000cfe8: ea0008d0 b 3000f330 <_Thread_queue_Initialize> <== NOT EXECUTED
3000cfec <_CORE_RWLock_Obtain_for_reading>:
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
3000cfec: e59fc0cc ldr ip, [pc, #204] ; 3000d0c0 <_CORE_RWLock_Obtain_for_reading+0xd4><== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000cff0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000cff4: e59c5004 ldr r5, [ip, #4] <== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000cff8: e1a04000 mov r4, r0 <== NOT EXECUTED 3000cffc: e1a07001 mov r7, r1 <== NOT EXECUTED 3000d000: e1a06003 mov r6, r3 <== NOT EXECUTED 3000d004: 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 (
3000d008: e10f8000 mrs r8, CPSR <== NOT EXECUTED 3000d00c: e3883080 orr r3, r8, #128 ; 0x80 <== NOT EXECUTED 3000d010: 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 ) {
3000d014: e5903044 ldr r3, [r0, #68] ; 0x44 <== NOT EXECUTED 3000d018: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d01c: 1a000008 bne 3000d044 <_CORE_RWLock_Obtain_for_reading+0x58><== NOT EXECUTED
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
the_rwlock->number_of_readers += 1;
3000d020: e5903048 ldr r3, [r0, #72] ; 0x48 <== NOT EXECUTED
*/
_ISR_Disable( level );
switch ( the_rwlock->current_state ) {
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
3000d024: e3a02001 mov r2, #1 <== NOT EXECUTED
the_rwlock->number_of_readers += 1;
3000d028: e2833001 add r3, r3, #1 <== NOT EXECUTED
*/
_ISR_Disable( level );
switch ( the_rwlock->current_state ) {
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
3000d02c: e5802044 str r2, [r0, #68] ; 0x44 <== NOT EXECUTED
the_rwlock->number_of_readers += 1;
3000d030: e5803048 str r3, [r0, #72] ; 0x48 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d034: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000d038: e3a03000 mov r3, #0 <== NOT EXECUTED 3000d03c: e5853034 str r3, [r5, #52] ; 0x34 <== NOT EXECUTED
return;
3000d040: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== 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 ) {
3000d044: e3530001 cmp r3, #1 <== NOT EXECUTED 3000d048: 0a000012 beq 3000d098 <_CORE_RWLock_Obtain_for_reading+0xac><== NOT EXECUTED
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
3000d04c: e35a0000 cmp sl, #0 <== NOT EXECUTED 3000d050: 1a000003 bne 3000d064 <_CORE_RWLock_Obtain_for_reading+0x78><== NOT EXECUTED 3000d054: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
3000d058: e3a03002 mov r3, #2 <== NOT EXECUTED
3000d05c: e5853034 str r3, [r5, #52] ; 0x34 <== NOT EXECUTED
3000d060: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== 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;
3000d064: e3a03000 mov r3, #0 <== NOT EXECUTED 3000d068: e3a02001 mov r2, #1 <== NOT EXECUTED 3000d06c: e5842030 str r2, [r4, #48] ; 0x30 <== 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;
3000d070: e5854044 str r4, [r5, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
3000d074: e5857020 str r7, [r5, #32] <== NOT EXECUTED
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
3000d078: e5853030 str r3, [r5, #48] ; 0x30 <== NOT EXECUTED
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000d07c: e5853034 str r3, [r5, #52] ; 0x34 <== NOT EXECUTED 3000d080: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
3000d084: e59f2038 ldr r2, [pc, #56] ; 3000d0c4 <_CORE_RWLock_Obtain_for_reading+0xd8><== NOT EXECUTED 3000d088: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d08c: e1a01006 mov r1, r6 <== NOT EXECUTED
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
3000d090: 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(
3000d094: ea00079b b 3000ef08 <_Thread_queue_Enqueue_with_handler> <== 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 );
3000d098: eb00087f bl 3000f29c <_Thread_queue_First> <== NOT EXECUTED
if ( !waiter ) {
3000d09c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d0a0: 1affffe9 bne 3000d04c <_CORE_RWLock_Obtain_for_reading+0x60><== NOT EXECUTED
the_rwlock->number_of_readers += 1;
3000d0a4: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED 3000d0a8: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000d0ac: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED 3000d0b0: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000d0b4: e3a03000 mov r3, #0 <== NOT EXECUTED 3000d0b8: e5853034 str r3, [r5, #52] ; 0x34 <== NOT EXECUTED
return;
3000d0bc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000d0c8 <_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;
3000d0c8: e59fc084 ldr ip, [pc, #132] ; 3000d154 <_CORE_RWLock_Obtain_for_writing+0x8c><== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
3000d0cc: e92d0030 push {r4, r5} <== NOT EXECUTED
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000d0d0: 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
)
{
3000d0d4: 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 (
3000d0d8: e10f5000 mrs r5, CPSR <== NOT EXECUTED 3000d0dc: e3854080 orr r4, r5, #128 ; 0x80 <== NOT EXECUTED 3000d0e0: e129f004 msr CPSR_fc, r4 <== 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 ) {
3000d0e4: e5904044 ldr r4, [r0, #68] ; 0x44 <== NOT EXECUTED 3000d0e8: e3540000 cmp r4, #0 <== NOT EXECUTED 3000d0ec: 1a000006 bne 3000d10c <_CORE_RWLock_Obtain_for_writing+0x44><== NOT EXECUTED
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
3000d0f0: e3a03002 mov r3, #2 <== NOT EXECUTED 3000d0f4: e5803044 str r3, [r0, #68] ; 0x44 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d0f8: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
_ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000d0fc: e3a03000 mov r3, #0 <== NOT EXECUTED 3000d100: e58c3034 str r3, [ip, #52] ; 0x34 <== NOT EXECUTED
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
3000d104: e8bd0030 pop {r4, r5} <== NOT EXECUTED
3000d108: e12fff1e bx lr <== NOT EXECUTED
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
3000d10c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000d110: 1a000003 bne 3000d124 <_CORE_RWLock_Obtain_for_writing+0x5c><== NOT EXECUTED 3000d114: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
3000d118: e3a03002 mov r3, #2 <== NOT EXECUTED 3000d11c: e58c3034 str r3, [ip, #52] ; 0x34 <== NOT EXECUTED 3000d120: eafffff7 b 3000d104 <_CORE_RWLock_Obtain_for_writing+0x3c> <== NOT EXECUTED 3000d124: e3a02001 mov r2, #1 <== NOT EXECUTED 3000d128: 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;
3000d12c: e58c2030 str r2, [ip, #48] ; 0x30 <== NOT EXECUTED
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000d130: 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;
3000d134: e58c0044 str r0, [ip, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
3000d138: e58c1020 str r1, [ip, #32] <== NOT EXECUTED
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000d13c: e58c2034 str r2, [ip, #52] ; 0x34 <== NOT EXECUTED 3000d140: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
3000d144: e59f200c ldr r2, [pc, #12] ; 3000d158 <_CORE_RWLock_Obtain_for_writing+0x90><== NOT EXECUTED 3000d148: e1a01003 mov r1, r3 <== NOT EXECUTED
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
3000d14c: e8bd0030 pop {r4, r5} <== 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(
3000d150: ea00076c b 3000ef08 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
3000d15c <_CORE_RWLock_Release>:
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
3000d15c: e59f30e0 ldr r3, [pc, #224] ; 3000d244 <_CORE_RWLock_Release+0xe8><== NOT EXECUTED
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
3000d160: e92d4010 push {r4, lr} <== NOT EXECUTED
ISR_Level level; Thread_Control *executing = _Thread_Executing;
3000d164: e5931004 ldr r1, [r3, #4] <== NOT EXECUTED
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
3000d168: e1a04000 mov r4, r0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000d16c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000d170: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000d174: 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 );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
3000d178: e5903044 ldr r3, [r0, #68] ; 0x44 <== NOT EXECUTED 3000d17c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d180: 0a00002a beq 3000d230 <_CORE_RWLock_Release+0xd4> <== 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 ) {
3000d184: e3530001 cmp r3, #1 <== NOT EXECUTED 3000d188: 0a000020 beq 3000d210 <_CORE_RWLock_Release+0xb4> <== NOT EXECUTED
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
3000d18c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000d190: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
3000d194: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d198: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
3000d19c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d1a0: eb0006fa bl 3000ed90 <_Thread_queue_Dequeue> <== NOT EXECUTED
if ( next ) {
3000d1a4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d1a8: 0a000016 beq 3000d208 <_CORE_RWLock_Release+0xac> <== NOT EXECUTED
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
3000d1ac: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000d1b0: e3530001 cmp r3, #1 <== NOT EXECUTED
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
3000d1b4: 03a03002 moveq r3, #2 <== NOT EXECUTED 3000d1b8: 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 ) {
3000d1bc: 0a000011 beq 3000d208 <_CORE_RWLock_Release+0xac> <== NOT EXECUTED
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
3000d1c0: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED 3000d1c4: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000d1c8: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
3000d1cc: e3a03001 mov r3, #1 <== NOT EXECUTED 3000d1d0: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED 3000d1d4: ea000007 b 3000d1f8 <_CORE_RWLock_Release+0x9c> <== NOT EXECUTED
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
3000d1d8: e5913030 ldr r3, [r1, #48] ; 0x30 <== NOT EXECUTED
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
3000d1dc: e1a00004 mov r0, r4 <== NOT EXECUTED
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
3000d1e0: e3530001 cmp r3, #1 <== NOT EXECUTED 3000d1e4: 0a000007 beq 3000d208 <_CORE_RWLock_Release+0xac> <== NOT EXECUTED
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
3000d1e8: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED 3000d1ec: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000d1f0: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
3000d1f4: eb0007db bl 3000f168 <_Thread_queue_Extract> <== NOT EXECUTED
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
3000d1f8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d1fc: eb000826 bl 3000f29c <_Thread_queue_First> <== NOT EXECUTED
if ( !next ||
3000d200: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000d204: 1afffff3 bne 3000d1d8 <_CORE_RWLock_Release+0x7c> <== NOT EXECUTED
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
3000d208: e3a00000 mov r0, #0 <== NOT EXECUTED
3000d20c: e8bd8010 pop {r4, pc} <== 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;
3000d210: e5903048 ldr r3, [r0, #72] ; 0x48 <== NOT EXECUTED 3000d214: e2433001 sub r3, r3, #1 <== NOT EXECUTED
if ( the_rwlock->number_of_readers != 0 ) {
3000d218: e3530000 cmp r3, #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;
3000d21c: e5803048 str r3, [r0, #72] ; 0x48 <== NOT EXECUTED
if ( the_rwlock->number_of_readers != 0 ) {
3000d220: 0affffd9 beq 3000d18c <_CORE_RWLock_Release+0x30> <== NOT EXECUTED 3000d224: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
3000d228: e3a00000 mov r0, #0 <== NOT EXECUTED
3000d22c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000d230: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
3000d234: e3a03002 mov r3, #2 <== NOT EXECUTED 3000d238: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
3000d23c: e3a00000 mov r0, #0 <== NOT EXECUTED
3000d240: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000d248 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
3000d248: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000d24c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d250: e1a0100d mov r1, sp <== NOT EXECUTED 3000d254: eb000608 bl 3000ea7c <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000d258: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000d25c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d260: 1a000004 bne 3000d278 <_CORE_RWLock_Timeout+0x30> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
3000d264: eb00084c bl 3000f39c <_Thread_queue_Process_timeout> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000d268: e59f3010 ldr r3, [pc, #16] ; 3000d280 <_CORE_RWLock_Timeout+0x38><== NOT EXECUTED 3000d26c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d270: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000d274: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000d278: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000d27c: e8bd8000 pop {pc} <== NOT EXECUTED
30011064 <_CORE_barrier_Release>:
#else
Objects_Id id __attribute__((unused)),
CORE_barrier_API_mp_support_callout api_barrier_mp_support __attribute__((unused))
#endif
)
{
30011064: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30011068: e1a05000 mov r5, r0 <== NOT EXECUTED
Thread_Control *the_thread;
uint32_t count;
count = 0;
3001106c: e3a04000 mov r4, #0 <== NOT EXECUTED
while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) {
30011070: ea000000 b 30011078 <_CORE_barrier_Release+0x14> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_barrier_mp_support) ( the_thread, id );
#endif
count++;
30011074: e2844001 add r4, r4, #1 <== NOT EXECUTED
{
Thread_Control *the_thread;
uint32_t count;
count = 0;
while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) {
30011078: e1a00005 mov r0, r5 <== NOT EXECUTED 3001107c: ebfff1ef bl 3000d840 <_Thread_queue_Dequeue> <== NOT EXECUTED 30011080: e3500000 cmp r0, #0 <== NOT EXECUTED 30011084: 1afffffa bne 30011074 <_CORE_barrier_Release+0x10> <== NOT EXECUTED
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_barrier_mp_support) ( the_thread, id );
#endif
count++;
}
the_barrier->number_of_waiting_threads = 0;
30011088: e5850048 str r0, [r5, #72] ; 0x48 <== NOT EXECUTED
return count; }
3001108c: e1a00004 mov r0, r4 <== NOT EXECUTED
30011090: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b9a8 <_CORE_barrier_Wait>:
)
{
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
3000b9a8: e59f2078 ldr r2, [pc, #120] ; 3000ba28 <_CORE_barrier_Wait+0x80><== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
3000b9ac: e92d0070 push {r4, r5, r6} <== NOT EXECUTED
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
3000b9b0: e592c004 ldr ip, [r2, #4] <== NOT EXECUTED
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
3000b9b4: e3a04000 mov r4, #0 <== NOT EXECUTED 3000b9b8: e58c4034 str r4, [ip, #52] ; 0x34 <== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
3000b9bc: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b9c0: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000b9c4: e3864080 orr r4, r6, #128 ; 0x80 <== NOT EXECUTED 3000b9c8: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
3000b9cc: e5904048 ldr r4, [r0, #72] ; 0x48 <== NOT EXECUTED
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
3000b9d0: e5905040 ldr r5, [r0, #64] ; 0x40 <== NOT EXECUTED
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
3000b9d4: e2844001 add r4, r4, #1 <== NOT EXECUTED
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
3000b9d8: e3550000 cmp r5, #0 <== NOT EXECUTED
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
3000b9dc: e5804048 str r4, [r0, #72] ; 0x48 <== NOT EXECUTED
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
3000b9e0: 1a000002 bne 3000b9f0 <_CORE_barrier_Wait+0x48> <== NOT EXECUTED
if ( the_barrier->number_of_waiting_threads ==
3000b9e4: e5905044 ldr r5, [r0, #68] ; 0x44 <== NOT EXECUTED 3000b9e8: e1540005 cmp r4, r5 <== NOT EXECUTED 3000b9ec: 0a000008 beq 3000ba14 <_CORE_barrier_Wait+0x6c> <== 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;
3000b9f0: e3a02001 mov r2, #1 <== NOT EXECUTED 3000b9f4: e5802030 str r2, [r0, #48] ; 0x30 <== NOT EXECUTED
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
3000b9f8: e58c0044 str r0, [ip, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
3000b9fc: e58c1020 str r1, [ip, #32] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ba00: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
3000ba04: e59f2020 ldr r2, [pc, #32] ; 3000ba2c <_CORE_barrier_Wait+0x84><== NOT EXECUTED 3000ba08: e1a01003 mov r1, r3 <== NOT EXECUTED
}
3000ba0c: e8bd0070 pop {r4, r5, r6} <== NOT EXECUTED
_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 );
3000ba10: ea0007e8 b 3000d9b8 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
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;
3000ba14: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ba18: e58c3034 str r3, [ip, #52] ; 0x34 <== NOT EXECUTED 3000ba1c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
3000ba20: e8bd0070 pop {r4, r5, r6} <== 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 );
3000ba24: ea00158e b 30011064 <_CORE_barrier_Release> <== NOT EXECUTED
3001b23c <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
3001b23c: 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
)
{
3001b240: 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 ) {
3001b244: e1530002 cmp r3, r2
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
3001b248: e1a07000 mov r7, r0 3001b24c: e1a05002 mov r5, r2 3001b250: e1a08001 mov r8, r1 3001b254: e59da020 ldr sl, [sp, #32]
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
3001b258: 3a000016 bcc 3001b2b8 <_CORE_message_queue_Broadcast+0x7c>
* 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 ) {
3001b25c: e5906048 ldr r6, [r0, #72] ; 0x48 3001b260: e3560000 cmp r6, #0
*count = 0;
3001b264: 13a00000 movne r0, #0 3001b268: 158a0000 strne r0, [sl]
* 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 ) {
3001b26c: 18bd85f0 popne {r4, r5, r6, r7, r8, sl, pc}
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
3001b270: e1a00007 mov r0, r7 3001b274: eb000b5d bl 3001dff0 <_Thread_queue_Dequeue> 3001b278: e2504000 subs r4, r0, #0
3001b27c: 0a00000a beq 3001b2ac <_CORE_message_queue_Broadcast+0x70>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
3001b280: e594002c ldr r0, [r4, #44] ; 0x2c 3001b284: e1a01008 mov r1, r8 3001b288: e1a02005 mov r2, r5 3001b28c: eb002449 bl 300243b8 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
3001b290: e5943028 ldr r3, [r4, #40] ; 0x28
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
3001b294: e1a00007 mov r0, r7
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
3001b298: e5835000 str r5, [r3]
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
3001b29c: eb000b53 bl 3001dff0 <_Thread_queue_Dequeue> 3001b2a0: e2504000 subs r4, r0, #0
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
3001b2a4: e2866001 add r6, r6, #1
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
3001b2a8: 1afffff4 bne 3001b280 <_CORE_message_queue_Broadcast+0x44>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
3001b2ac: e58a6000 str r6, [sl]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
3001b2b0: e1a00004 mov r0, r4
3001b2b4: 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;
3001b2b8: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
3001b2bc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30013304 <_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
)
{
30013304: e92d4070 push {r4, r5, r6, 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)) {
30013308: 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
)
{
3001330c: 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;
30013310: 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
)
{
30013314: e1a05001 mov r5, r1 30013318: e24dd004 sub sp, sp, #4
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
3001331c: e5842044 str r2, [r4, #68] ; 0x44
the_message_queue->number_of_pending_messages = 0;
30013320: e5840048 str r0, [r4, #72] ; 0x48
the_message_queue->maximum_message_size = maximum_message_size;
30013324: 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;
30013328: e5840060 str r0, [r4, #96] ; 0x60
the_message_queue->notify_argument = the_argument;
3001332c: 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)) {
30013330: 01a01003 moveq r1, r3
30013334: 0a000005 beq 30013350 <_CORE_message_queue_Initialize+0x4c>
allocated_message_size += sizeof(uint32_t);
30013338: e2831004 add r1, r3, #4 <== NOT EXECUTED
allocated_message_size &= ~(sizeof(uint32_t) - 1);
3001333c: e3c11003 bic r1, r1, #3 <== NOT EXECUTED
}
if (allocated_message_size < maximum_message_size)
30013340: e1530001 cmp r3, r1 <== NOT EXECUTED 30013344: 9a000001 bls 30013350 <_CORE_message_queue_Initialize+0x4c><== NOT EXECUTED
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
30013348: e28dd004 add sp, sp, #4
3001334c: e8bd8070 pop {r4, r5, r6, pc}
/*
* 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));
30013350: e2816014 add r6, r1, #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 *
30013354: e0000692 mul r0, r2, r6
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
30013358: e1500001 cmp r0, r1
return false;
3001335c: 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)
30013360: 3afffff8 bcc 30013348 <_CORE_message_queue_Initialize+0x44>
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
30013364: e58d2000 str r2, [sp] 30013368: eb000c24 bl 30016400 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
3001336c: e3500000 cmp r0, #0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
30013370: e1a01000 mov r1, r0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
30013374: e584005c str r0, [r4, #92] ; 0x5c
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
30013378: e59d2000 ldr r2, [sp]
return false;
3001337c: 01a00000 moveq r0, r0
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
30013380: 0afffff0 beq 30013348 <_CORE_message_queue_Initialize+0x44>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
30013384: e2840068 add r0, r4, #104 ; 0x68 30013388: e1a03006 mov r3, r6 3001338c: eb001653 bl 30018ce0 <_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 );
30013390: e2842054 add r2, r4, #84 ; 0x54
head->next = tail;
30013394: e5842050 str r2, [r4, #80] ; 0x50
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
30013398: e2843050 add r3, r4, #80 ; 0x50
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3001339c: e3a02000 mov r2, #0 300133a0: e5842054 str r2, [r4, #84] ; 0x54
tail->previous = head;
300133a4: 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(
300133a8: e5951000 ldr r1, [r5] 300133ac: e1a00004 mov r0, r4 300133b0: e3510001 cmp r1, #1 300133b4: 13a01000 movne r1, #0 300133b8: 03a01001 moveq r1, #1 300133bc: e3a02080 mov r2, #128 ; 0x80 300133c0: e3a03006 mov r3, #6 300133c4: eb000972 bl 30015994 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
300133c8: e3a00001 mov r0, #1 300133cc: eaffffdd b 30013348 <_CORE_message_queue_Initialize+0x44>
30018d44 <_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 ) {
30018d44: 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
)
{
30018d48: e92d4030 push {r4, r5, lr}
30018d4c: 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 ) {
30018d50: 0a000027 beq 30018df4 <_CORE_message_queue_Insert_message+0xb0>
_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 ) {
30018d54: e3520102 cmp r2, #-2147483648 ; 0x80000000
30018d58: 0a000037 beq 30018e3c <_CORE_message_queue_Insert_message+0xf8>
* 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
}
30018d5c: e5903050 ldr r3, [r0, #80] ; 0x50 <== 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));
30018d60: e280c054 add ip, r0, #84 ; 0x54 <== 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 ) ) {
30018d64: e15c0003 cmp ip, r3 <== NOT EXECUTED 30018d68: 0a000002 beq 30018d78 <_CORE_message_queue_Insert_message+0x34><== NOT EXECUTED
this_message = (CORE_message_queue_Buffer_control *) the_node;
this_priority = _CORE_message_queue_Get_message_priority(this_message);
if ( this_priority <= the_priority ) {
30018d6c: e5934008 ldr r4, [r3, #8] <== NOT EXECUTED 30018d70: e1520004 cmp r2, r4 <== NOT EXECUTED 30018d74: aa000017 bge 30018dd8 <_CORE_message_queue_Insert_message+0x94><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30018d78: e10f4000 mrs r4, CPSR <== NOT EXECUTED 30018d7c: e3842080 orr r2, r4, #128 ; 0x80 <== NOT EXECUTED 30018d80: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
break;
}
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
30018d84: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
continue;
}
break;
}
_ISR_Disable( level );
SET_NOTIFY();
30018d88: e5902048 ldr r2, [r0, #72] ; 0x48 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
30018d8c: e593c000 ldr ip, [r3] <== NOT EXECUTED
the_message_queue->number_of_pending_messages++;
30018d90: e2825001 add r5, r2, #1 <== NOT EXECUTED 30018d94: e5805048 str r5, [r0, #72] ; 0x48 <== NOT EXECUTED
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
30018d98: e2722001 rsbs r2, r2, #1 <== NOT EXECUTED 30018d9c: 33a02000 movcc r2, #0 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
30018da0: e5813004 str r3, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
30018da4: e5831000 str r1, [r3] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
30018da8: e58c1004 str r1, [ip, #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;
30018dac: e581c000 str ip, [r1] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30018db0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
/*
* 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 )
30018db4: e3520000 cmp r2, #0 <== NOT EXECUTED
30018db8: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
30018dbc: e5903060 ldr r3, [r0, #96] ; 0x60
30018dc0: e3530000 cmp r3, #0
30018dc4: 08bd8030 popeq {r4, r5, pc}
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
30018dc8: e5900064 ldr r0, [r0, #100] ; 0x64 <== NOT EXECUTED
30018dcc: e1a0e00f mov lr, pc <== NOT EXECUTED
30018dd0: e12fff13 bx r3 <== NOT EXECUTED
30018dd4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
this_message = (CORE_message_queue_Buffer_control *) the_node;
this_priority = _CORE_message_queue_Get_message_priority(this_message);
if ( this_priority <= the_priority ) {
the_node = the_node->next;
30018dd8: e5933000 ldr r3, [r3] <== 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 ) ) {
30018ddc: e15c0003 cmp ip, r3 <== NOT EXECUTED 30018de0: 0affffe4 beq 30018d78 <_CORE_message_queue_Insert_message+0x34><== NOT EXECUTED
this_message = (CORE_message_queue_Buffer_control *) the_node;
this_priority = _CORE_message_queue_Get_message_priority(this_message);
if ( this_priority <= the_priority ) {
30018de4: e5934008 ldr r4, [r3, #8] <== NOT EXECUTED 30018de8: e1520004 cmp r2, r4 <== NOT EXECUTED 30018dec: baffffe1 blt 30018d78 <_CORE_message_queue_Insert_message+0x34><== NOT EXECUTED 30018df0: eafffff8 b 30018dd8 <_CORE_message_queue_Insert_message+0x94><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30018df4: e10fc000 mrs ip, CPSR 30018df8: e38c3080 orr r3, ip, #128 ; 0x80 30018dfc: e129f003 msr CPSR_fc, r3
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
_ISR_Disable( level );
SET_NOTIFY();
30018e00: e5902048 ldr r2, [r0, #72] ; 0x48
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
30018e04: e5903058 ldr r3, [r0, #88] ; 0x58
the_message_queue->number_of_pending_messages++;
30018e08: e2825001 add r5, r2, #1
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
30018e0c: e2804054 add r4, r0, #84 ; 0x54 30018e10: e5805048 str r5, [r0, #72] ; 0x48
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
30018e14: e5801058 str r1, [r0, #88] ; 0x58
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
30018e18: e5814000 str r4, [r1]
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
30018e1c: e2722001 rsbs r2, r2, #1 30018e20: 33a02000 movcc r2, #0
tail->previous = the_node; old_last->next = the_node;
30018e24: e5831000 str r1, [r3]
the_node->previous = old_last;
30018e28: e5813004 str r3, [r1, #4]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30018e2c: e129f00c msr CPSR_fc, ip
/*
* 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 )
30018e30: e3520000 cmp r2, #0
30018e34: 1affffe0 bne 30018dbc <_CORE_message_queue_Insert_message+0x78>
30018e38: e8bd8030 pop {r4, r5, pc}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30018e3c: e10fc000 mrs ip, CPSR 30018e40: e38c3080 orr r3, ip, #128 ; 0x80 30018e44: e129f003 msr CPSR_fc, r3
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 ) {
_ISR_Disable( level );
SET_NOTIFY();
30018e48: e5902048 ldr r2, [r0, #72] ; 0x48
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
30018e4c: e5903050 ldr r3, [r0, #80] ; 0x50
the_message_queue->number_of_pending_messages++;
30018e50: e2825001 add r5, r2, #1
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
30018e54: e2804050 add r4, r0, #80 ; 0x50 30018e58: e5805048 str r5, [r0, #72] ; 0x48
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
30018e5c: e5801050 str r1, [r0, #80] ; 0x50
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
30018e60: e5814004 str r4, [r1, #4]
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
30018e64: e2722001 rsbs r2, r2, #1 30018e68: 33a02000 movcc r2, #0
before_node = after_node->next; after_node->next = the_node; the_node->next = before_node;
30018e6c: e5813000 str r3, [r1]
before_node->previous = the_node;
30018e70: e5831004 str r1, [r3, #4]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30018e74: e129f00c msr CPSR_fc, ip
/*
* 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 )
30018e78: e3520000 cmp r2, #0
30018e7c: 1affffce bne 30018dbc <_CORE_message_queue_Insert_message+0x78>
30018e80: e8bd8030 pop {r4, r5, pc}
300133d0 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
300133d0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
300133d4: e59fc114 ldr ip, [pc, #276] ; 300134f0 <_CORE_message_queue_Seize+0x120>
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
300133d8: e3a04000 mov r4, #0
{
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
300133dc: e59c5004 ldr r5, [ip, #4]
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
300133e0: e59d7020 ldr r7, [sp, #32]
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;
300133e4: e5854034 str r4, [r5, #52] ; 0x34
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
300133e8: e5dd601c ldrb r6, [sp, #28] 300133ec: e1a04000 mov r4, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300133f0: e10f0000 mrs r0, CPSR 300133f4: e3808080 orr r8, r0, #128 ; 0x80 300133f8: e129f008 msr CPSR_fc, r8
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 );
}
300133fc: e5948050 ldr r8, [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 );
30013400: e284a054 add sl, r4, #84 ; 0x54
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
30013404: e158000a cmp r8, sl
30013408: 0a000022 beq 30013498 <_CORE_message_queue_Seize+0xc8>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
3001340c: e598e000 ldr lr, [r8]
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 ) {
the_message_queue->number_of_pending_messages -= 1;
30013410: e5945048 ldr r5, [r4, #72] ; 0x48
head->next = new_first;
30013414: e1a01004 mov r1, r4 30013418: e5a1e050 str lr, [r1, #80]! ; 0x50 3001341c: e2455001 sub r5, r5, #1
new_first->previous = head;
30013420: e58e1004 str r1, [lr, #4] 30013424: e5845048 str r5, [r4, #72] ; 0x48
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30013428: e129f000 msr CPSR_fc, r0
_ISR_Enable( level );
*size_p = the_message->Contents.size;
_Thread_Executing->Wait.count =
3001342c: e59c1004 ldr r1, [ip, #4]
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;
30013430: e598e00c ldr lr, [r8, #12]
_Thread_Executing->Wait.count =
30013434: e5980008 ldr r0, [r8, #8]
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
30013438: e2885010 add r5, r8, #16
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;
3001343c: e583e000 str lr, [r3]
_Thread_Executing->Wait.count =
30013440: e5810024 str r0, [r1, #36] ; 0x24
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30013444: e1a00002 mov r0, r2 30013448: e1a01005 mov r1, r5 3001344c: e5932000 ldr r2, [r3] 30013450: eb0021c9 bl 3001bb7c <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 );
30013454: e1a00004 mov r0, r4 30013458: eb000841 bl 30015564 <_Thread_queue_Dequeue>
if ( !the_thread ) {
3001345c: e2503000 subs r3, r0, #0
30013460: 0a00001e beq 300134e0 <_CORE_message_queue_Seize+0x110>
*/
_CORE_message_queue_Set_message_priority(
the_message,
the_thread->Wait.count
);
the_message->Contents.size = (size_t) the_thread->Wait.option;
30013464: e5931030 ldr r1, [r3, #48] ; 0x30 <== NOT EXECUTED
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
30013468: e5932024 ldr r2, [r3, #36] ; 0x24 <== NOT EXECUTED
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
3001346c: e1a00005 mov r0, r5 <== NOT EXECUTED
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
30013470: e5882008 str r2, [r8, #8] <== NOT EXECUTED 30013474: e588100c str r1, [r8, #12] <== NOT EXECUTED
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30013478: e1a02001 mov r2, r1 <== NOT EXECUTED 3001347c: e593102c ldr r1, [r3, #44] ; 0x2c <== NOT EXECUTED 30013480: eb0021bd bl 3001bb7c <memcpy> <== NOT EXECUTED
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
30013484: e5982008 ldr r2, [r8, #8] <== NOT EXECUTED 30013488: e1a00004 mov r0, r4 <== NOT EXECUTED 3001348c: e1a01008 mov r1, r8 <== 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 );
}
30013490: 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(
30013494: ea00162a b 30018d44 <_CORE_message_queue_Insert_message> <== NOT EXECUTED
return;
}
#endif
}
if ( !wait ) {
30013498: e3560000 cmp r6, #0
3001349c: 1a000003 bne 300134b0 <_CORE_message_queue_Seize+0xe0>
300134a0: e129f000 msr CPSR_fc, r0
_ISR_Enable( level );
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
300134a4: e3a03004 mov r3, #4 300134a8: e5853034 str r3, [r5, #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 );
}
300134ac: 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;
300134b0: e3a0c001 mov ip, #1 300134b4: e584c030 str ip, [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;
300134b8: e5854044 str r4, [r5, #68] ; 0x44
executing->Wait.id = id;
300134bc: e5851020 str r1, [r5, #32]
executing->Wait.return_argument_second.mutable_object = buffer;
300134c0: e585202c str r2, [r5, #44] ; 0x2c
executing->Wait.return_argument = size_p;
300134c4: e5853028 str r3, [r5, #40] ; 0x28 300134c8: e129f000 msr CPSR_fc, r0
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
300134cc: e59f2020 ldr r2, [pc, #32] ; 300134f4 <_CORE_message_queue_Seize+0x124> 300134d0: e1a00004 mov r0, r4 300134d4: e1a01007 mov r1, r7
}
300134d8: 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 );
300134dc: ea00087e b 300156dc <_Thread_queue_Enqueue_with_handler>
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 );
300134e0: e2840068 add r0, r4, #104 ; 0x68 300134e4: e1a01008 mov r1, r8
}
300134e8: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
300134ec: eaffff5a b 3001325c <_Chain_Append>
300134f8 <_CORE_message_queue_Submit>:
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
300134f8: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
300134fc: e590c04c ldr ip, [r0, #76] ; 0x4c
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30013500: e24dd004 sub sp, sp, #4
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30013504: e15c0002 cmp ip, r2
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30013508: e1a04000 mov r4, r0 3001350c: e1a05002 mov r5, r2 30013510: e1a0a001 mov sl, r1 30013514: e59d7028 ldr r7, [sp, #40] ; 0x28 30013518: e5dd902c ldrb r9, [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;
3001351c: 33a00001 movcc r0, #1
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30013520: 3a00000d bcc 3001355c <_CORE_message_queue_Submit+0x64>
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
30013524: e5946048 ldr r6, [r4, #72] ; 0x48 30013528: e3560000 cmp r6, #0
3001352c: 0a00000c beq 30013564 <_CORE_message_queue_Submit+0x6c>
/*
* 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 <
30013530: e5942044 ldr r2, [r4, #68] ; 0x44 30013534: e1520006 cmp r2, r6
30013538: 8a00002a bhi 300135e8 <_CORE_message_queue_Submit+0xf0>
/*
* 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 ) {
3001353c: e3590000 cmp r9, #0 <== NOT EXECUTED
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
30013540: 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 ) {
30013544: 0a000004 beq 3001355c <_CORE_message_queue_Submit+0x64> <== 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() ) {
30013548: e59f20d4 ldr r2, [pc, #212] ; 30013624 <_CORE_message_queue_Submit+0x12c><== NOT EXECUTED 3001354c: e5921000 ldr r1, [r2] <== NOT EXECUTED 30013550: e3510000 cmp r1, #0 <== NOT EXECUTED
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
30013554: 13a00003 movne r0, #3 <== 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() ) {
30013558: 0a000010 beq 300135a0 <_CORE_message_queue_Submit+0xa8> <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
3001355c: e28dd004 add sp, sp, #4
30013560: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
30013564: e58d3000 str r3, [sp] 30013568: eb0007fd bl 30015564 <_Thread_queue_Dequeue>
if ( the_thread ) {
3001356c: e2508000 subs r8, r0, #0 30013570: e59d3000 ldr r3, [sp] 30013574: 05946048 ldreq r6, [r4, #72] ; 0x48
30013578: 0affffec beq 30013530 <_CORE_message_queue_Submit+0x38>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
3001357c: e598002c ldr r0, [r8, #44] ; 0x2c 30013580: e1a0100a mov r1, sl 30013584: e1a02005 mov r2, r5 30013588: eb00217b bl 3001bb7c <memcpy>
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
3001358c: e5983028 ldr r3, [r8, #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;
30013590: e1a00006 mov r0, r6
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30013594: e5835000 str r5, [r3]
the_thread->Wait.count = (uint32_t) submit_type;
30013598: e5887024 str r7, [r8, #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;
3001359c: eaffffee b 3001355c <_CORE_message_queue_Submit+0x64>
* 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;
300135a0: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300135a4: e10f1000 mrs r1, CPSR <== NOT EXECUTED 300135a8: e3810080 orr r0, r1, #128 ; 0x80 <== NOT EXECUTED 300135ac: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 300135b0: e3a00001 mov r0, #1 <== NOT EXECUTED 300135b4: e5840030 str r0, [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;
300135b8: e5824044 str r4, [r2, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
300135bc: e5823020 str r3, [r2, #32] <== NOT EXECUTED
executing->Wait.return_argument_second.immutable_object = buffer;
300135c0: e582a02c str sl, [r2, #44] ; 0x2c <== NOT EXECUTED
executing->Wait.option = (uint32_t) size;
300135c4: e5825030 str r5, [r2, #48] ; 0x30 <== NOT EXECUTED
executing->Wait.count = submit_type;
300135c8: e5827024 str r7, [r2, #36] ; 0x24 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300135cc: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
300135d0: e59f2050 ldr r2, [pc, #80] ; 30013628 <_CORE_message_queue_Submit+0x130><== NOT EXECUTED 300135d4: e1a00004 mov r0, r4 <== NOT EXECUTED 300135d8: e59d1030 ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED 300135dc: eb00083e bl 300156dc <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
300135e0: e3a00007 mov r0, #7 <== NOT EXECUTED 300135e4: eaffffdc b 3001355c <_CORE_message_queue_Submit+0x64> <== NOT EXECUTED
_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 );
300135e8: e2840068 add r0, r4, #104 ; 0x68 300135ec: ebffff2d bl 300132a8 <_Chain_Get>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
300135f0: e1a0100a mov r1, sl
_CORE_message_queue_Allocate_message_buffer (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
_Chain_Get( &the_message_queue->Inactive_messages );
300135f4: e1a06000 mov r6, r0
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
300135f8: e1a02005 mov r2, r5 300135fc: e2800010 add r0, r0, #16 30013600: eb00215d bl 3001bb7c <memcpy>
size
);
the_message->Contents.size = size;
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
30013604: e1a00004 mov r0, r4
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
30013608: e586500c str r5, [r6, #12]
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
3001360c: e5867008 str r7, [r6, #8]
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
30013610: e1a01006 mov r1, r6 30013614: e1a02007 mov r2, r7 30013618: eb0015c9 bl 30018d44 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
3001361c: e3a00000 mov r0, #0 30013620: eaffffcd b 3001355c <_CORE_message_queue_Submit+0x64>
3000a6c8 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000a6c8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
3000a6cc: e59f40b4 ldr r4, [pc, #180] ; 3000a788 <_CORE_mutex_Seize+0xc0>
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000a6d0: e1a05000 mov r5, r0
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
3000a6d4: e594c000 ldr ip, [r4]
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000a6d8: e1a06001 mov r6, r1
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
3000a6dc: e35c0000 cmp ip, #0
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000a6e0: e1a08003 mov r8, r3 3000a6e4: e20270ff and r7, r2, #255 ; 0xff
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 3000a6e8: 0a000001 beq 3000a6f4 <_CORE_mutex_Seize+0x2c>
3000a6ec: e3570000 cmp r7, #0
3000a6f0: 1a00000d bne 3000a72c <_CORE_mutex_Seize+0x64>
3000a6f4: e1a00005 mov r0, r5
3000a6f8: e28d1018 add r1, sp, #24
3000a6fc: eb001542 bl 3000fc0c <_CORE_mutex_Seize_interrupt_trylock>
3000a700: e3500000 cmp r0, #0
3000a704: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
3000a708: e3570000 cmp r7, #0
3000a70c: 1a00000e bne 3000a74c <_CORE_mutex_Seize+0x84>
3000a710: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
3000a714: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3000a718: e59f306c ldr r3, [pc, #108] ; 3000a78c <_CORE_mutex_Seize+0xc4><== NOT EXECUTED
3000a71c: e3a02001 mov r2, #1 <== NOT EXECUTED
3000a720: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
3000a724: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
3000a728: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000a72c: e59f305c ldr r3, [pc, #92] ; 3000a790 <_CORE_mutex_Seize+0xc8> 3000a730: e5933000 ldr r3, [r3] 3000a734: e3530001 cmp r3, #1
3000a738: 9affffed bls 3000a6f4 <_CORE_mutex_Seize+0x2c>
3000a73c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a740: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a744: e3a02012 mov r2, #18 <== NOT EXECUTED 3000a748: eb0001c8 bl 3000ae70 <_Internal_error_Occurred> <== NOT EXECUTED
3000a74c: e59f3038 ldr r3, [pc, #56] ; 3000a78c <_CORE_mutex_Seize+0xc4> 3000a750: e5942000 ldr r2, [r4] 3000a754: e5933004 ldr r3, [r3, #4] 3000a758: e2822001 add r2, r2, #1
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;
3000a75c: e3a01001 mov r1, #1
3000a760: e5851030 str r1, [r5, #48] ; 0x30
3000a764: e5842000 str r2, [r4]
3000a768: e5835044 str r5, [r3, #68] ; 0x44
3000a76c: e5836020 str r6, [r3, #32]
3000a770: e59d3018 ldr r3, [sp, #24]
3000a774: e129f003 msr CPSR_fc, r3
3000a778: e1a00005 mov r0, r5
3000a77c: e1a01008 mov r1, r8
3000a780: ebffffb5 bl 3000a65c <_CORE_mutex_Seize_interrupt_blocking>
3000a784: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000fc0c <_CORE_mutex_Seize_interrupt_trylock>:
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000fc0c: e59f215c ldr r2, [pc, #348] ; 3000fd70 <_CORE_mutex_Seize_interrupt_trylock+0x164>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000fc10: e590c050 ldr ip, [r0, #80] ; 0x50
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
3000fc14: e1a03000 mov r3, r0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000fc18: e5922004 ldr r2, [r2, #4]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000fc1c: e3a00000 mov r0, #0
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000fc20: e15c0000 cmp ip, r0
3000fc24: e92d40f0 push {r4, r5, r6, r7, lr}
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000fc28: e5820034 str r0, [r2, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000fc2c: 0a00000e beq 3000fc6c <_CORE_mutex_Seize_interrupt_trylock+0x60>
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
3000fc30: e593c048 ldr ip, [r3, #72] ; 0x48
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
3000fc34: e5925008 ldr r5, [r2, #8]
the_mutex->nest_count = 1;
3000fc38: e3a04001 mov r4, #1
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000fc3c: e35c0002 cmp ip, #2
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
3000fc40: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->holder = executing;
3000fc44: e583205c str r2, [r3, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
3000fc48: e5835060 str r5, [r3, #96] ; 0x60
the_mutex->nest_count = 1;
3000fc4c: e5834054 str r4, [r3, #84] ; 0x54
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000fc50: 0a000013 beq 3000fca4 <_CORE_mutex_Seize_interrupt_trylock+0x98>
3000fc54: e35c0003 cmp ip, #3
3000fc58: 0a000018 beq 3000fcc0 <_CORE_mutex_Seize_interrupt_trylock+0xb4>
3000fc5c: e5913000 ldr r3, [r1] 3000fc60: e129f003 msr CPSR_fc, r3
executing->resource_count++;
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( *level_p );
return 0;
3000fc64: e3a00000 mov r0, #0
3000fc68: e8bd80f0 pop {r4, r5, r6, r7, 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 ) ) {
3000fc6c: e593005c ldr r0, [r3, #92] ; 0x5c 3000fc70: e1520000 cmp r2, r0
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000fc74: 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 ) ) {
3000fc78: 18bd80f0 popne {r4, r5, r6, r7, pc}
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
3000fc7c: e5930040 ldr r0, [r3, #64] ; 0x40 3000fc80: e3500000 cmp r0, #0
3000fc84: 1a00001e bne 3000fd04 <_CORE_mutex_Seize_interrupt_trylock+0xf8>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
3000fc88: e5932054 ldr r2, [r3, #84] ; 0x54 3000fc8c: e2822001 add r2, r2, #1 3000fc90: e5832054 str r2, [r3, #84] ; 0x54 3000fc94: e5913000 ldr r3, [r1] 3000fc98: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
3000fc9c: e3a00000 mov r0, #0
3000fca0: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000fca4: e592301c ldr r3, [r2, #28] 3000fca8: e2833001 add r3, r3, #1 3000fcac: e582301c str r3, [r2, #28] 3000fcb0: e5913000 ldr r3, [r1] 3000fcb4: e129f003 msr CPSR_fc, r3
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( *level_p );
return 0;
3000fcb8: e3a00000 mov r0, #0
3000fcbc: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000fcc0: e592c01c ldr ip, [r2, #28]
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
3000fcc4: e593704c ldr r7, [r3, #76] ; 0x4c
current = executing->current_priority;
3000fcc8: e5926014 ldr r6, [r2, #20]
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000fccc: e08c5004 add r5, ip, r4
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
3000fcd0: e1570006 cmp r7, r6
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000fcd4: e582501c str r5, [r2, #28]
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
3000fcd8: 0a000020 beq 3000fd60 <_CORE_mutex_Seize_interrupt_trylock+0x154>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
3000fcdc: 3a000012 bcc 3000fd2c <_CORE_mutex_Seize_interrupt_trylock+0x120>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
3000fce0: e3a05006 mov r5, #6 3000fce4: e5825034 str r5, [r2, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000fce8: e5834050 str r4, [r3, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
3000fcec: e5830054 str r0, [r3, #84] ; 0x54
executing->resource_count--; /* undo locking above */
3000fcf0: e582c01c str ip, [r2, #28] 3000fcf4: e5913000 ldr r3, [r1] 3000fcf8: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
3000fcfc: e3a00000 mov r0, #0
3000fd00: e8bd80f0 pop {r4, r5, r6, r7, 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 ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
3000fd04: e3500001 cmp r0, #1
3000fd08: 0a000001 beq 3000fd14 <_CORE_mutex_Seize_interrupt_trylock+0x108>
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000fd0c: e3a00001 mov r0, #1
3000fd10: e8bd80f0 pop {r4, r5, r6, r7, pc}
the_mutex->nest_count++;
_ISR_Enable( *level_p );
return 0;
#if defined(RTEMS_POSIX_API)
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
3000fd14: e3a03002 mov r3, #2 <== NOT EXECUTED 3000fd18: e5823034 str r3, [r2, #52] ; 0x34 <== NOT EXECUTED 3000fd1c: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000fd20: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( *level_p );
return 0;
3000fd24: e3a00000 mov r0, #0 <== NOT EXECUTED
3000fd28: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000fd2c: e59f2040 ldr r2, [pc, #64] ; 3000fd74 <_CORE_mutex_Seize_interrupt_trylock+0x168><== NOT EXECUTED 3000fd30: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000fd34: e2800001 add r0, r0, #1 <== NOT EXECUTED 3000fd38: e5820000 str r0, [r2] <== NOT EXECUTED 3000fd3c: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000fd40: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
3000fd44: e3a02000 mov r2, #0 <== NOT EXECUTED 3000fd48: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED 3000fd4c: e593104c ldr r1, [r3, #76] ; 0x4c <== NOT EXECUTED 3000fd50: ebffefcd bl 3000bc8c <_Thread_Change_priority> <== NOT EXECUTED
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
3000fd54: ebfff0e9 bl 3000c100 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000fd58: e3a00000 mov r0, #0 <== NOT EXECUTED
3000fd5c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000fd60: e5913000 ldr r3, [r1] <== NOT EXECUTED
3000fd64: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
_ISR_Enable( *level_p );
return 0;
3000fd68: e3a00000 mov r0, #0 <== NOT EXECUTED
3000fd6c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000a794 <_CORE_mutex_Surrender>:
* 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 ) {
3000a794: e5d03044 ldrb r3, [r0, #68] ; 0x44
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
3000a798: e92d4030 push {r4, r5, lr}
* 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 ) {
3000a79c: e3530000 cmp r3, #0
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
3000a7a0: e1a04000 mov r4, r0
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
3000a7a4: e590205c ldr r2, [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 ) {
3000a7a8: 0a000004 beq 3000a7c0 <_CORE_mutex_Surrender+0x2c>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000a7ac: e59f3110 ldr r3, [pc, #272] ; 3000a8c4 <_CORE_mutex_Surrender+0x130>
if ( !_Thread_Is_executing( holder ) )
3000a7b0: e5933004 ldr r3, [r3, #4] 3000a7b4: e1520003 cmp r2, r3
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
3000a7b8: 13a00003 movne r0, #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 ) )
3000a7bc: 18bd8030 popne {r4, r5, pc}
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
3000a7c0: e5940054 ldr r0, [r4, #84] ; 0x54
3000a7c4: e3500000 cmp r0, #0
3000a7c8: 08bd8030 popeq {r4, r5, pc}
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000a7cc: e2400001 sub r0, r0, #1
if ( the_mutex->nest_count != 0 ) {
3000a7d0: e3500000 cmp r0, #0
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000a7d4: e5840054 str r0, [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;
3000a7d8: 13a00000 movne r0, #0
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
3000a7dc: 18bd8030 popne {r4, r5, pc}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
3000a7e0: 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 ) ||
3000a7e4: e3530002 cmp r3, #2
3000a7e8: 0a00001f beq 3000a86c <_CORE_mutex_Surrender+0xd8>
3000a7ec: e3530003 cmp r3, #3
3000a7f0: 0a00001d beq 3000a86c <_CORE_mutex_Surrender+0xd8>
if ( holder->resource_count == 0 &&
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
}
}
the_mutex->holder = NULL;
3000a7f4: e3a05000 mov r5, #0 3000a7f8: e584505c str r5, [r4, #92] ; 0x5c
the_mutex->holder_id = 0;
3000a7fc: 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 ) ) ) {
3000a800: e1a00004 mov r0, r4 3000a804: eb00070b bl 3000c438 <_Thread_queue_Dequeue> 3000a808: e2503000 subs r3, r0, #0
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000a80c: 03a02001 moveq r2, #1 3000a810: 05842050 streq r2, [r4, #80] ; 0x50
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a814: 01a00003 moveq r0, 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 ) ) ) {
3000a818: 08bd8030 popeq {r4, r5, pc}
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000a81c: e5931008 ldr r1, [r3, #8]
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000a820: e5942048 ldr r2, [r4, #72] ; 0x48
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000a824: e5841060 str r1, [r4, #96] ; 0x60
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000a828: e3520002 cmp r2, #2
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
3000a82c: e3a01001 mov r1, #1
} else
#endif
{
the_mutex->holder = the_thread;
3000a830: e584305c str r3, [r4, #92] ; 0x5c
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
3000a834: e5841054 str r1, [r4, #84] ; 0x54
switch ( the_mutex->Attributes.discipline ) {
3000a838: 0a000018 beq 3000a8a0 <_CORE_mutex_Surrender+0x10c>
3000a83c: e3520003 cmp r2, #3 <== NOT EXECUTED
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a840: 11a00005 movne r0, r5 <== NOT EXECUTED
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000a844: 18bd8030 popne {r4, r5, pc} <== 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++;
3000a848: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000a84c: e594104c ldr r1, [r4, #76] ; 0x4c <== NOT EXECUTED 3000a850: e593c014 ldr ip, [r3, #20] <== 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++;
3000a854: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000a858: e151000c cmp r1, ip <== 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++;
3000a85c: e583201c str r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000a860: 3a000013 bcc 3000a8b4 <_CORE_mutex_Surrender+0x120> <== NOT EXECUTED
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a864: e1a00005 mov r0, r5 <== NOT EXECUTED
}
3000a868: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000a86c: e592301c ldr r3, [r2, #28] 3000a870: 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 &&
3000a874: e3530000 cmp r3, #0
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000a878: e582301c str r3, [r2, #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 &&
3000a87c: 1affffdc bne 3000a7f4 <_CORE_mutex_Surrender+0x60>
holder->real_priority != holder->current_priority ) {
3000a880: e5921018 ldr r1, [r2, #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 &&
3000a884: e5923014 ldr r3, [r2, #20] 3000a888: e1510003 cmp r1, r3
3000a88c: 0affffd8 beq 3000a7f4 <_CORE_mutex_Surrender+0x60>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
3000a890: e1a00002 mov r0, r2 3000a894: e3a02001 mov r2, #1 3000a898: eb0004fb bl 3000bc8c <_Thread_Change_priority> 3000a89c: eaffffd4 b 3000a7f4 <_CORE_mutex_Surrender+0x60>
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++;
3000a8a0: e593201c ldr r2, [r3, #28]
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a8a4: e1a00005 mov r0, r5
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++;
3000a8a8: e2822001 add r2, r2, #1 3000a8ac: e583201c str r2, [r3, #28]
break;
3000a8b0: e8bd8030 pop {r4, r5, pc}
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
if (the_mutex->Attributes.priority_ceiling <
the_thread->current_priority){
_Thread_Change_priority(
3000a8b4: e1a02005 mov r2, r5 <== NOT EXECUTED 3000a8b8: eb0004f3 bl 3000bc8c <_Thread_Change_priority> <== NOT EXECUTED
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a8bc: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a8c0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30013bd0 <_CORE_semaphore_Seize>:
)
{
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
30013bd0: e59fc078 ldr ip, [pc, #120] ; 30013c50 <_CORE_semaphore_Seize+0x80><== NOT EXECUTED
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
bool wait,
Watchdog_Interval timeout
)
{
30013bd4: e92d0030 push {r4, r5} <== NOT EXECUTED
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
30013bd8: e59cc004 ldr ip, [ip, #4] <== NOT EXECUTED
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
30013bdc: e3a04000 mov r4, #0 <== NOT EXECUTED 30013be0: e58c4034 str r4, [ip, #52] ; 0x34 <== NOT EXECUTED
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
bool wait,
Watchdog_Interval timeout
)
{
30013be4: 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 (
30013be8: e10f5000 mrs r5, CPSR <== NOT EXECUTED 30013bec: e3854080 orr r4, r5, #128 ; 0x80 <== NOT EXECUTED 30013bf0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
if ( the_semaphore->count != 0 ) {
30013bf4: e5904048 ldr r4, [r0, #72] ; 0x48 <== NOT EXECUTED 30013bf8: e3540000 cmp r4, #0 <== NOT EXECUTED 30013bfc: 1a00000f bne 30013c40 <_CORE_semaphore_Seize+0x70> <== 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 ) {
30013c00: e3520000 cmp r2, #0 <== NOT EXECUTED 30013c04: 1a000004 bne 30013c1c <_CORE_semaphore_Seize+0x4c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30013c08: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
_ISR_Enable( level );
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
30013c0c: e3a03001 mov r3, #1 <== NOT EXECUTED 30013c10: e58c3034 str r3, [ip, #52] ; 0x34 <== 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 ); }
30013c14: e8bd0030 pop {r4, r5} <== NOT EXECUTED
30013c18: e12fff1e bx lr <== NOT EXECUTED
30013c1c: e3a02001 mov r2, #1 <== NOT EXECUTED
30013c20: 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;
30013c24: e58c0044 str r0, [ip, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
30013c28: e58c1020 str r1, [ip, #32] <== NOT EXECUTED 30013c2c: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
_ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
30013c30: e59f201c ldr r2, [pc, #28] ; 30013c54 <_CORE_semaphore_Seize+0x84><== NOT EXECUTED 30013c34: e1a01003 mov r1, r3 <== NOT EXECUTED
}
30013c38: e8bd0030 pop {r4, r5} <== 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 );
30013c3c: eafff061 b 3000fdc8 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
if ( the_semaphore->count != 0 ) {
the_semaphore->count -= 1;
30013c40: e2444001 sub r4, r4, #1 <== NOT EXECUTED 30013c44: e5804048 str r4, [r0, #72] ; 0x48 <== NOT EXECUTED 30013c48: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED 30013c4c: eafffff0 b 30013c14 <_CORE_semaphore_Seize+0x44> <== NOT EXECUTED
3000b4e8 <_CORE_spinlock_Initialize>:
CORE_spinlock_Control *the_spinlock,
CORE_spinlock_Attributes *the_spinlock_attributes
)
{
the_spinlock->Attributes = *the_spinlock_attributes;
3000b4e8: e5913000 ldr r3, [r1] <== NOT EXECUTED
the_spinlock->lock = 0;
3000b4ec: e3a02000 mov r2, #0 <== NOT EXECUTED 3000b4f0: e5802004 str r2, [r0, #4] <== NOT EXECUTED
CORE_spinlock_Control *the_spinlock,
CORE_spinlock_Attributes *the_spinlock_attributes
)
{
the_spinlock->Attributes = *the_spinlock_attributes;
3000b4f4: e5803000 str r3, [r0] <== NOT EXECUTED
the_spinlock->lock = 0;
the_spinlock->users = 0;
3000b4f8: e5802008 str r2, [r0, #8] <== NOT EXECUTED
the_spinlock->holder = 0;
3000b4fc: e580200c str r2, [r0, #12] <== NOT EXECUTED
}
3000b500: e12fff1e bx lr <== NOT EXECUTED
3000b504 <_CORE_spinlock_Release>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b504: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b508: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b50c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Disable( level );
/*
* It must locked before it can be unlocked.
*/
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
3000b510: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 3000b514: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b518: 1a000002 bne 3000b528 <_CORE_spinlock_Release+0x24> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b51c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_NOT_LOCKED;
3000b520: e3a00006 mov r0, #6 <== NOT EXECUTED 3000b524: 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 ) {
3000b528: e59f3040 ldr r3, [pc, #64] ; 3000b570 <_CORE_spinlock_Release+0x6c><== NOT EXECUTED 3000b52c: e590100c ldr r1, [r0, #12] <== NOT EXECUTED 3000b530: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000b534: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000b538: e1510003 cmp r1, r3 <== NOT EXECUTED 3000b53c: 0a000002 beq 3000b54c <_CORE_spinlock_Release+0x48> <== NOT EXECUTED 3000b540: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_NOT_HOLDER;
3000b544: e3a00002 mov r0, #2 <== NOT EXECUTED 3000b548: e12fff1e bx lr <== NOT EXECUTED
}
/*
* Let it be unlocked.
*/
the_spinlock->users -= 1;
3000b54c: e5901008 ldr r1, [r0, #8] <== NOT EXECUTED
the_spinlock->lock = CORE_SPINLOCK_UNLOCKED;
3000b550: e3a03000 mov r3, #0 <== NOT EXECUTED
}
/*
* Let it be unlocked.
*/
the_spinlock->users -= 1;
3000b554: e2411001 sub r1, r1, #1 <== NOT EXECUTED 3000b558: e5801008 str r1, [r0, #8] <== NOT EXECUTED
the_spinlock->lock = CORE_SPINLOCK_UNLOCKED;
3000b55c: e5803004 str r3, [r0, #4] <== NOT EXECUTED
the_spinlock->holder = 0;
3000b560: e580300c str r3, [r0, #12] <== NOT EXECUTED 3000b564: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_SUCCESSFUL;
3000b568: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000b56c: e12fff1e bx lr <== NOT EXECUTED
3000b574 <_CORE_spinlock_Wait>:
CORE_spinlock_Status _CORE_spinlock_Wait(
CORE_spinlock_Control *the_spinlock,
bool wait,
Watchdog_Interval timeout
)
{
3000b574: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000b578: e20110ff and r1, r1, #255 ; 0xff <== NOT EXECUTED
3000b57c: e1a05000 mov r5, r0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b580: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000b584: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000b588: 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) &&
3000b58c: e5902004 ldr r2, [r0, #4] <== NOT EXECUTED 3000b590: e3520001 cmp r2, #1 <== NOT EXECUTED 3000b594: 0a000023 beq 3000b628 <_CORE_spinlock_Wait+0xb4> <== NOT EXECUTED
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
_ISR_Enable( level );
return CORE_SPINLOCK_HOLDER_RELOCKING;
}
the_spinlock->users += 1;
3000b598: e5952008 ldr r2, [r5, #8] <== NOT EXECUTED 3000b59c: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000b5a0: e5852008 str r2, [r5, #8] <== NOT EXECUTED
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
3000b5a4: e5952004 ldr r2, [r5, #4] <== NOT EXECUTED 3000b5a8: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b5ac: 0a000026 beq 3000b64c <_CORE_spinlock_Wait+0xd8> <== NOT EXECUTED
}
/*
* Spinlock is unavailable. If not willing to wait, return.
*/
if ( !wait ) {
3000b5b0: e3510000 cmp r1, #0 <== NOT EXECUTED 3000b5b4: 159f4098 ldrne r4, [pc, #152] ; 3000b654 <_CORE_spinlock_Wait+0xe0><== NOT EXECUTED 3000b5b8: 0a000014 beq 3000b610 <_CORE_spinlock_Wait+0x9c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b5bc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
*/
_ISR_Enable( level );
/* An ISR could occur here */
_Thread_Enable_dispatch();
3000b5c0: eb0005f1 bl 3000cd8c <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b5c4: e5943000 ldr r3, [r4] <== NOT EXECUTED 3000b5c8: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000b5cc: e5843000 str r3, [r4] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b5d0: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b5d4: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b5d8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_HOLDER_RELOCKING;
}
the_spinlock->users += 1;
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
3000b5dc: e5951004 ldr r1, [r5, #4] <== NOT EXECUTED 3000b5e0: e1a03002 mov r3, r2 <== NOT EXECUTED 3000b5e4: e3510000 cmp r1, #0 <== NOT EXECUTED 3000b5e8: 1afffff3 bne 3000b5bc <_CORE_spinlock_Wait+0x48> <== NOT EXECUTED
the_spinlock->lock = CORE_SPINLOCK_LOCKED;
the_spinlock->holder = _Thread_Executing->Object.id;
3000b5ec: e59f3064 ldr r3, [pc, #100] ; 3000b658 <_CORE_spinlock_Wait+0xe4><== NOT EXECUTED
return CORE_SPINLOCK_HOLDER_RELOCKING;
}
the_spinlock->users += 1;
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
the_spinlock->lock = CORE_SPINLOCK_LOCKED;
3000b5f0: e3a01001 mov r1, #1 <== NOT EXECUTED
the_spinlock->holder = _Thread_Executing->Object.id;
3000b5f4: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
return CORE_SPINLOCK_HOLDER_RELOCKING;
}
the_spinlock->users += 1;
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
the_spinlock->lock = CORE_SPINLOCK_LOCKED;
3000b5f8: e5851004 str r1, [r5, #4] <== NOT EXECUTED
the_spinlock->holder = _Thread_Executing->Object.id;
3000b5fc: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000b600: e585300c str r3, [r5, #12] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b604: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_SUCCESSFUL;
3000b608: e3a00000 mov r0, #0 <== NOT EXECUTED
3000b60c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Spinlock is unavailable. If not willing to wait, return.
*/
if ( !wait ) {
the_spinlock->users -= 1;
3000b610: e5952008 ldr r2, [r5, #8] <== NOT EXECUTED 3000b614: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000b618: e5852008 str r2, [r5, #8] <== NOT EXECUTED 3000b61c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
return CORE_SPINLOCK_UNAVAILABLE;
3000b620: e3a00005 mov r0, #5 <== NOT EXECUTED
3000b624: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout;
#endif
_ISR_Disable( level );
if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) &&
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
3000b628: e59f2028 ldr r2, [pc, #40] ; 3000b658 <_CORE_spinlock_Wait+0xe4><== NOT EXECUTED 3000b62c: e590000c ldr r0, [r0, #12] <== NOT EXECUTED 3000b630: 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) &&
3000b634: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000b638: e1500002 cmp r0, r2 <== NOT EXECUTED 3000b63c: 1affffd5 bne 3000b598 <_CORE_spinlock_Wait+0x24> <== NOT EXECUTED 3000b640: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
_ISR_Enable( level );
return CORE_SPINLOCK_HOLDER_RELOCKING;
3000b644: e3a00001 mov r0, #1 <== NOT EXECUTED
3000b648: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
ISR_Level level;
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout;
#endif
_ISR_Disable( level );
3000b64c: e1a02003 mov r2, r3 <== NOT EXECUTED 3000b650: eaffffe5 b 3000b5ec <_CORE_spinlock_Wait+0x78> <== NOT EXECUTED
3000af50 <_Chain_Append_with_empty_check>:
bool _Chain_Append_with_empty_check(
Chain_Control *chain,
Chain_Node *node
)
{
3000af50: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
3000af54: e10fc000 mrs ip, CPSR <== NOT EXECUTED
3000af58: e38c3080 orr r3, ip, #128 ; 0x80 <== NOT EXECUTED
3000af5c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3000af60: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000af64: e5904000 ldr r4, [r0] <== NOT EXECUTED
== _Chain_Immutable_tail( the_chain );
3000af68: e2802004 add r2, r0, #4 <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3000af6c: e5801008 str r1, [r0, #8] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3000af70: e881000c stm r1, {r2, r3} <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node;
3000af74: e5831000 str r1, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000af78: e1540002 cmp r4, r2 <== NOT EXECUTED 3000af7c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000af80: 03a00001 moveq r0, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000af84: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
_ISR_Disable( level );
was_empty = _Chain_Append_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return was_empty;
}
3000af88: e8bd0010 pop {r4} <== NOT EXECUTED
3000af8c: e12fff1e bx lr <== NOT EXECUTED
3000afdc <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
3000afdc: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000afe0: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000afe4: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000afe8: 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;
3000afec: e5903000 ldr r3, [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 );
3000aff0: e280c004 add ip, r0, #4 <== NOT EXECUTED
Chain_Node *old_first = head->next;
if ( old_first != tail ) {
3000aff4: e15c0003 cmp ip, r3 <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
} else
*the_node = NULL;
3000aff8: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000affc: 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;
3000b000: 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 ) {
3000b004: 0a000006 beq 3000b024 <_Chain_Get_with_empty_check+0x48> <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
3000b008: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
3000b00c: e5802000 str r2, [r0] <== NOT EXECUTED
new_first->previous = head;
3000b010: e5820004 str r0, [r2, #4] <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
3000b014: e15c0002 cmp ip, r2 <== NOT EXECUTED 3000b018: 13a00000 movne r0, #0 <== NOT EXECUTED 3000b01c: 03a00001 moveq r0, #1 <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
head->next = new_first;
new_first->previous = head;
*the_node = old_first;
3000b020: e5813000 str r3, [r1] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b024: 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;
}
3000b028: e8bd0010 pop {r4} <== NOT EXECUTED
3000b02c: e12fff1e bx lr <== NOT EXECUTED
3000b08c <_Chain_Prepend_with_empty_check>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b08c: e10fc000 mrs ip, CPSR <== NOT EXECUTED 3000b090: e38c3080 orr r3, ip, #128 ; 0x80 <== NOT EXECUTED 3000b094: 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;
}
3000b098: e5902000 ldr r2, [r0] <== NOT EXECUTED
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
3000b09c: e1a03000 mov r3, r0 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b0a0: e5810004 str r0, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b0a4: e4831004 str r1, [r3], #4 <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b0a8: e5821004 str r1, [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;
3000b0ac: e5812000 str r2, [r1] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b0b0: e129f00c msr CPSR_fc, ip <== NOT EXECUTED 3000b0b4: e1520003 cmp r2, r3 <== NOT EXECUTED 3000b0b8: 13a00000 movne r0, #0 <== NOT EXECUTED 3000b0bc: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000b0c0: e12fff1e bx lr <== NOT EXECUTED
300095b4 <_Event_Seize>:
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
300095b4: e59fc0fc ldr ip, [pc, #252] ; 300096b8 <_Event_Seize+0x104>
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
300095b8: 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;
300095bc: e59c4004 ldr r4, [ip, #4]
executing->Wait.return_code = RTEMS_SUCCESSFUL;
300095c0: e3a0c000 mov ip, #0 300095c4: e584c034 str ip, [r4, #52] ; 0x34
api = executing->API_Extensions[ THREAD_API_RTEMS ];
300095c8: e594c0f8 ldr ip, [r4, #248] ; 0xf8
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300095cc: e10f7000 mrs r7, CPSR 300095d0: e3875080 orr r5, r7, #128 ; 0x80 300095d4: e129f005 msr CPSR_fc, r5
_ISR_Disable( level );
pending_events = api->pending_events;
300095d8: e59c5000 ldr r5, [ip]
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
300095dc: e0106005 ands r6, r0, r5
300095e0: 0a000003 beq 300095f4 <_Event_Seize+0x40>
300095e4: e1500006 cmp r0, r6
300095e8: 0a00001f beq 3000966c <_Event_Seize+0xb8>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
300095ec: e3110002 tst r1, #2 <== NOT EXECUTED 300095f0: 1a00001d bne 3000966c <_Event_Seize+0xb8> <== NOT EXECUTED
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
300095f4: e3110001 tst r1, #1
300095f8: 1a000016 bne 30009658 <_Event_Seize+0xa4>
*/
executing->Wait.option = (uint32_t) option_set;
executing->Wait.count = (uint32_t) event_in;
executing->Wait.return_argument = event_out;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
300095fc: e59f50b8 ldr r5, [pc, #184] ; 300096bc <_Event_Seize+0x108>
* 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;
30009600: e5843028 str r3, [r4, #40] ; 0x28
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30009604: e3a03001 mov r3, #1
* 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;
30009608: e5841030 str r1, [r4, #48] ; 0x30
executing->Wait.count = (uint32_t) event_in;
3000960c: e5840024 str r0, [r4, #36] ; 0x24
executing->Wait.return_argument = event_out;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30009610: e5853000 str r3, [r5]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009614: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
if ( ticks ) {
30009618: e3520000 cmp r2, #0
3000961c: 1a000019 bne 30009688 <_Event_Seize+0xd4>
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
30009620: e1a00004 mov r0, r4 30009624: e3a01c01 mov r1, #256 ; 0x100 30009628: eb000cdc bl 3000c9a0 <_Thread_Set_state>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000962c: e10f2000 mrs r2, CPSR 30009630: e3823080 orr r3, r2, #128 ; 0x80 30009634: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
sync_state = _Event_Sync_state;
30009638: e5950000 ldr r0, [r5]
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000963c: e3a03000 mov r3, #0
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
30009640: e3500001 cmp r0, #1
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
_ISR_Disable( level );
sync_state = _Event_Sync_state;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
30009644: e5853000 str r3, [r5]
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
30009648: 0a00000c beq 30009680 <_Event_Seize+0xcc>
* 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 );
3000964c: e1a01004 mov r1, r4 <== NOT EXECUTED
}
30009650: 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 );
30009654: ea000976 b 3000bc34 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009658: e129f007 msr CPSR_fc, r7
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
executing->Wait.return_code = RTEMS_UNSATISFIED;
3000965c: e3a0200d mov r2, #13 30009660: e5842034 str r2, [r4, #52] ; 0x34
*event_out = seized_events;
30009664: e5836000 str r6, [r3]
return;
30009668: e8bd80f0 pop {r4, r5, r6, r7, pc}
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) );
3000966c: e1c55006 bic r5, r5, r6
pending_events = api->pending_events;
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
(seized_events == event_in || _Options_Is_any( option_set )) ) {
api->pending_events =
30009670: e58c5000 str r5, [ip] 30009674: e129f007 msr CPSR_fc, r7
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
*event_out = seized_events;
30009678: e5836000 str r6, [r3]
return;
3000967c: e8bd80f0 pop {r4, r5, r6, r7, pc}
30009680: e129f002 msr CPSR_fc, r2
30009684: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
_ISR_Enable( level );
if ( ticks ) {
_Watchdog_Initialize(
30009688: e5941008 ldr r1, [r4, #8]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000968c: e59f002c ldr r0, [pc, #44] ; 300096c0 <_Event_Seize+0x10c>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30009690: e3a03000 mov r3, #0
the_watchdog->routine = routine;
30009694: e5840064 str r0, [r4, #100] ; 0x64
the_watchdog->id = id;
30009698: e5841068 str r1, [r4, #104] ; 0x68
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000969c: e5843050 str r3, [r4, #80] ; 0x50
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
300096a0: e584306c str r3, [r4, #108] ; 0x6c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
300096a4: e5842054 str r2, [r4, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
300096a8: e59f0014 ldr r0, [pc, #20] ; 300096c4 <_Event_Seize+0x110> 300096ac: e2841048 add r1, r4, #72 ; 0x48 300096b0: eb000e2c bl 3000cf68 <_Watchdog_Insert> 300096b4: eaffffd9 b 30009620 <_Event_Seize+0x6c>
30009720 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
30009720: 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 ];
30009724: e59010f8 ldr r1, [r0, #248] ; 0xf8
option_set = (rtems_option) the_thread->Wait.option;
30009728: e5906030 ldr r6, [r0, #48] ; 0x30
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
3000972c: e1a04000 mov r4, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30009730: e10f0000 mrs r0, CPSR 30009734: e3803080 orr r3, r0, #128 ; 0x80 30009738: e129f003 msr CPSR_fc, r3
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
pending_events = api->pending_events;
3000973c: e5912000 ldr r2, [r1]
event_condition = (rtems_event_set) the_thread->Wait.count;
30009740: e5943024 ldr r3, [r4, #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 ) ) {
30009744: e013c002 ands ip, r3, r2
30009748: 0a000020 beq 300097d0 <_Event_Surrender+0xb0>
/*
* 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() &&
3000974c: e59f50fc ldr r5, [pc, #252] ; 30009850 <_Event_Surrender+0x130> 30009750: e5957000 ldr r7, [r5] 30009754: e3570000 cmp r7, #0
30009758: 0a000002 beq 30009768 <_Event_Surrender+0x48>
3000975c: e5955004 ldr r5, [r5, #4] <== NOT EXECUTED 30009760: e1540005 cmp r4, r5 <== NOT EXECUTED 30009764: 0a000024 beq 300097fc <_Event_Surrender+0xdc> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
30009768: e5945010 ldr r5, [r4, #16]
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
3000976c: e3150c01 tst r5, #256 ; 0x100
30009770: 0a000014 beq 300097c8 <_Event_Surrender+0xa8>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
30009774: e153000c cmp r3, ip
30009778: 0a000001 beq 30009784 <_Event_Surrender+0x64>
3000977c: e3160002 tst r6, #2 <== NOT EXECUTED 30009780: 0a000010 beq 300097c8 <_Event_Surrender+0xa8> <== NOT EXECUTED
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
30009784: e5943028 ldr r3, [r4, #40] ; 0x28
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) );
30009788: e1c2200c bic r2, r2, ip
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
3000978c: e5812000 str r2, [r1]
the_thread->Wait.count = 0;
30009790: e3a02000 mov r2, #0 30009794: e5842024 str r2, [r4, #36] ; 0x24
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
30009798: e583c000 str ip, [r3]
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000979c: e10f3000 mrs r3, CPSR 300097a0: e129f000 msr CPSR_fc, r0 300097a4: e129f003 msr CPSR_fc, r3
_ISR_Flash( level );
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
300097a8: e5943050 ldr r3, [r4, #80] ; 0x50 300097ac: e3530002 cmp r3, #2
300097b0: 0a000008 beq 300097d8 <_Event_Surrender+0xb8>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300097b4: e129f000 msr CPSR_fc, r0
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
300097b8: e59f1094 ldr r1, [pc, #148] ; 30009854 <_Event_Surrender+0x134> 300097bc: e1a00004 mov r0, r4
}
return;
}
}
_ISR_Enable( level );
}
300097c0: e8bd40f0 pop {r4, r5, r6, r7, lr}
300097c4: ea000970 b 3000bd8c <_Thread_Clear_state>
300097c8: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
300097cc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
300097d0: e129f000 msr CPSR_fc, r0
300097d4: e8bd80f0 pop {r4, r5, r6, r7, pc}
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
300097d8: e3a03003 mov r3, #3 <== NOT EXECUTED 300097dc: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 300097e0: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
300097e4: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 300097e8: eb000e4d bl 3000d124 <_Watchdog_Remove> <== NOT EXECUTED 300097ec: e59f1060 ldr r1, [pc, #96] ; 30009854 <_Event_Surrender+0x134><== NOT EXECUTED 300097f0: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return;
}
}
_ISR_Enable( level );
}
300097f4: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
300097f8: ea000963 b 3000bd8c <_Thread_Clear_state> <== 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) ||
300097fc: e59f5054 ldr r5, [pc, #84] ; 30009858 <_Event_Surrender+0x138><== NOT EXECUTED 30009800: e5957000 ldr r7, [r5] <== 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 ) &&
30009804: e3570002 cmp r7, #2 <== NOT EXECUTED 30009808: 0a000002 beq 30009818 <_Event_Surrender+0xf8> <== NOT EXECUTED
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
3000980c: e5957000 ldr r7, [r5] <== 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) ||
30009810: e3570001 cmp r7, #1 <== NOT EXECUTED 30009814: 1affffd3 bne 30009768 <_Event_Surrender+0x48> <== NOT EXECUTED
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
30009818: e153000c cmp r3, ip <== NOT EXECUTED 3000981c: 0a000001 beq 30009828 <_Event_Surrender+0x108> <== NOT EXECUTED 30009820: e3160002 tst r6, #2 <== NOT EXECUTED 30009824: 0a000007 beq 30009848 <_Event_Surrender+0x128> <== NOT EXECUTED
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
30009828: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 3000982c: e1c2200c bic r2, r2, ip <== NOT EXECUTED
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
30009830: e5812000 str r2, [r1] <== NOT EXECUTED
the_thread->Wait.count = 0;
30009834: e3a02000 mov r2, #0 <== NOT EXECUTED 30009838: e5842024 str r2, [r4, #36] ; 0x24 <== NOT EXECUTED
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
3000983c: e583c000 str ip, [r3] <== NOT EXECUTED
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
30009840: e3a03003 mov r3, #3 <== NOT EXECUTED
30009844: e5853000 str r3, [r5] <== NOT EXECUTED
30009848: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
3000984c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000985c <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
3000985c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30009860: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
30009864: e1a0100d mov r1, sp <== NOT EXECUTED 30009868: eb000a2d bl 3000c124 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000986c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30009870: e3530000 cmp r3, #0 <== NOT EXECUTED 30009874: 1a000010 bne 300098bc <_Event_Timeout+0x60> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30009878: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000987c: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30009880: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
30009884: e5803024 str r3, [r0, #36] ; 0x24 <== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) ) {
30009888: e59f304c ldr r3, [pc, #76] ; 300098dc <_Event_Timeout+0x80><== NOT EXECUTED 3000988c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30009890: e1500003 cmp r0, r3 <== NOT EXECUTED 30009894: 0a00000a beq 300098c4 <_Event_Timeout+0x68> <== NOT EXECUTED
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
30009898: e3a03006 mov r3, #6 <== NOT EXECUTED 3000989c: e5803034 str r3, [r0, #52] ; 0x34 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300098a0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 300098a4: e59f1034 ldr r1, [pc, #52] ; 300098e0 <_Event_Timeout+0x84><== NOT EXECUTED 300098a8: eb000937 bl 3000bd8c <_Thread_Clear_state> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
300098ac: e59f3030 ldr r3, [pc, #48] ; 300098e4 <_Event_Timeout+0x88><== NOT EXECUTED 300098b0: e5932000 ldr r2, [r3] <== NOT EXECUTED 300098b4: e2422001 sub r2, r2, #1 <== NOT EXECUTED 300098b8: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
300098bc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300098c0: e8bd8000 pop {pc} <== NOT EXECUTED
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
300098c4: e59f301c ldr r3, [pc, #28] ; 300098e8 <_Event_Timeout+0x8c><== NOT EXECUTED 300098c8: e5931000 ldr r1, [r3] <== NOT EXECUTED 300098cc: e3510001 cmp r1, #1 <== NOT EXECUTED
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
300098d0: 03a01002 moveq r1, #2 <== NOT EXECUTED 300098d4: 05831000 streq r1, [r3] <== NOT EXECUTED 300098d8: eaffffee b 30009898 <_Event_Timeout+0x3c> <== NOT EXECUTED
3000fde0 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000fde0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000fde4: 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;
3000fde8: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000fdec: e24dd01c sub sp, sp, #28 3000fdf0: e1a05001 mov r5, r1
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3000fdf4: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000fdf8: e1a07000 mov r7, r0
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3000fdfc: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000fe00: e1a0b003 mov fp, r3
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
3000fe04: e58d200c str r2, [sp, #12]
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3000fe08: 2a000078 bcs 3000fff0 <_Heap_Allocate_aligned_with_boundary+0x210>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
3000fe0c: e3530000 cmp r3, #0
3000fe10: 1a000074 bne 3000ffe8 <_Heap_Allocate_aligned_with_boundary+0x208>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000fe14: e5979008 ldr r9, [r7, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000fe18: e1570009 cmp r7, r9
3000fe1c: 0a000073 beq 3000fff0 <_Heap_Allocate_aligned_with_boundary+0x210>
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
3000fe20: e59d300c ldr r3, [sp, #12]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000fe24: e2651004 rsb r1, r5, #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
3000fe28: e2833007 add r3, r3, #7
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000fe2c: e3a06001 mov r6, #1
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
3000fe30: e58d3010 str r3, [sp, #16]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000fe34: e58d1014 str r1, [sp, #20]
/*
* 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 ) {
3000fe38: e599a004 ldr sl, [r9, #4] 3000fe3c: e59d2000 ldr r2, [sp] 3000fe40: e152000a cmp r2, sl
3000fe44: 2a00004e bcs 3000ff84 <_Heap_Allocate_aligned_with_boundary+0x1a4>
if ( alignment == 0 ) {
3000fe48: e3580000 cmp r8, #0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000fe4c: 02894008 addeq r4, r9, #8
3000fe50: 0a000051 beq 3000ff9c <_Heap_Allocate_aligned_with_boundary+0x1bc>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000fe54: e5973014 ldr r3, [r7, #20]
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000fe58: e59d1014 ldr r1, [sp, #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;
3000fe5c: e59d2010 ldr r2, [sp, #16]
- 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;
3000fe60: e3caa001 bic sl, sl, #1
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;
3000fe64: e089a00a add sl, r9, sl
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000fe68: e081400a add r4, r1, sl
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000fe6c: e58d3004 str r3, [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;
3000fe70: e0633002 rsb r3, r3, r2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000fe74: e1a00004 mov r0, r4
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
3000fe78: e083a00a add sl, r3, sl 3000fe7c: e1a01008 mov r1, r8
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000fe80: e2893008 add r3, r9, #8 3000fe84: e58d3008 str r3, [sp, #8]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000fe88: eb001682 bl 30015898 <__umodsi3> 3000fe8c: e0604004 rsb r4, r0, r4
uintptr_t alloc_begin = alloc_end - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
3000fe90: e15a0004 cmp sl, r4
3000fe94: 2a000003 bcs 3000fea8 <_Heap_Allocate_aligned_with_boundary+0xc8>
3000fe98: e1a0000a mov r0, sl 3000fe9c: e1a01008 mov r1, r8 3000fea0: eb00167c bl 30015898 <__umodsi3> 3000fea4: e060400a rsb r4, r0, sl
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
3000fea8: e35b0000 cmp fp, #0
3000feac: 0a000026 beq 3000ff4c <_Heap_Allocate_aligned_with_boundary+0x16c>
/* 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;
3000feb0: e084a005 add sl, r4, r5 <== NOT EXECUTED 3000feb4: e1a0000a mov r0, sl <== NOT EXECUTED 3000feb8: e1a0100b mov r1, fp <== NOT EXECUTED 3000febc: eb001675 bl 30015898 <__umodsi3> <== NOT EXECUTED 3000fec0: e060000a rsb r0, r0, sl <== 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 ) {
3000fec4: e15a0000 cmp sl, r0 <== NOT EXECUTED 3000fec8: 93a0a000 movls sl, #0 <== NOT EXECUTED 3000fecc: 83a0a001 movhi sl, #1 <== NOT EXECUTED 3000fed0: e1540000 cmp r4, r0 <== NOT EXECUTED 3000fed4: 23a0a000 movcs sl, #0 <== NOT EXECUTED 3000fed8: e35a0000 cmp sl, #0 <== NOT EXECUTED 3000fedc: 0a00001a beq 3000ff4c <_Heap_Allocate_aligned_with_boundary+0x16c><== NOT EXECUTED
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000fee0: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3000fee4: e0813005 add r3, r1, r5 <== 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 ) {
3000fee8: e1530000 cmp r3, r0 <== NOT EXECUTED 3000feec: 958d9018 strls r9, [sp, #24] <== NOT EXECUTED 3000fef0: 91a09003 movls r9, r3 <== NOT EXECUTED 3000fef4: 9a000002 bls 3000ff04 <_Heap_Allocate_aligned_with_boundary+0x124><== NOT EXECUTED 3000fef8: ea000021 b 3000ff84 <_Heap_Allocate_aligned_with_boundary+0x1a4><== NOT EXECUTED 3000fefc: e1590000 cmp r9, r0 <== NOT EXECUTED 3000ff00: 8a00003c bhi 3000fff8 <_Heap_Allocate_aligned_with_boundary+0x218><== NOT EXECUTED
return 0;
}
alloc_begin = boundary_line - alloc_size;
3000ff04: e0654000 rsb r4, r5, r0 <== NOT EXECUTED 3000ff08: e1a01008 mov r1, r8 <== NOT EXECUTED 3000ff0c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ff10: eb001660 bl 30015898 <__umodsi3> <== NOT EXECUTED 3000ff14: e0604004 rsb r4, r0, r4 <== NOT EXECUTED
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
3000ff18: e084a005 add sl, r4, r5 <== NOT EXECUTED 3000ff1c: e1a0000a mov r0, sl <== NOT EXECUTED 3000ff20: e1a0100b mov r1, fp <== NOT EXECUTED 3000ff24: eb00165b bl 30015898 <__umodsi3> <== NOT EXECUTED 3000ff28: e060000a rsb r0, r0, sl <== 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 ) {
3000ff2c: e15a0000 cmp sl, r0 <== NOT EXECUTED 3000ff30: 93a0a000 movls sl, #0 <== NOT EXECUTED 3000ff34: 83a0a001 movhi sl, #1 <== NOT EXECUTED 3000ff38: e1540000 cmp r4, r0 <== NOT EXECUTED 3000ff3c: 23a0a000 movcs sl, #0 <== NOT EXECUTED 3000ff40: e35a0000 cmp sl, #0 <== NOT EXECUTED 3000ff44: 1affffec bne 3000fefc <_Heap_Allocate_aligned_with_boundary+0x11c><== NOT EXECUTED 3000ff48: e59d9018 ldr r9, [sp, #24] <== 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 ) {
3000ff4c: e59d2008 ldr r2, [sp, #8] 3000ff50: e1520004 cmp r2, r4
3000ff54: 8a00000a bhi 3000ff84 <_Heap_Allocate_aligned_with_boundary+0x1a4>
3000ff58: e59d100c ldr r1, [sp, #12] 3000ff5c: e1a00004 mov r0, r4 3000ff60: eb00164c bl 30015898 <__umodsi3> 3000ff64: e3e0a007 mvn sl, #7 3000ff68: e069a00a rsb sl, r9, sl
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000ff6c: e08aa004 add sl, sl, r4
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 ) {
3000ff70: e59d1004 ldr r1, [sp, #4] 3000ff74: e060300a rsb r3, r0, sl 3000ff78: e15a0000 cmp sl, r0 3000ff7c: 11510003 cmpne r1, r3
3000ff80: 9a000005 bls 3000ff9c <_Heap_Allocate_aligned_with_boundary+0x1bc>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
3000ff84: e5999008 ldr r9, [r9, #8] 3000ff88: e2863001 add r3, r6, #1
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000ff8c: e1570009 cmp r7, r9
3000ff90: 0a00001d beq 3001000c <_Heap_Allocate_aligned_with_boundary+0x22c>
3000ff94: e1a06003 mov r6, r3 3000ff98: eaffffa6 b 3000fe38 <_Heap_Allocate_aligned_with_boundary+0x58>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
3000ff9c: e3540000 cmp r4, #0
3000ffa0: 0afffff7 beq 3000ff84 <_Heap_Allocate_aligned_with_boundary+0x1a4>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000ffa4: e5972048 ldr r2, [r7, #72] ; 0x48
stats->searches += search_count;
3000ffa8: e597304c ldr r3, [r7, #76] ; 0x4c
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000ffac: e2822001 add r2, r2, #1
stats->searches += search_count;
3000ffb0: e0833006 add r3, r3, r6
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000ffb4: e5872048 str r2, [r7, #72] ; 0x48
stats->searches += search_count;
3000ffb8: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000ffbc: e1a00007 mov r0, r7 3000ffc0: e1a01009 mov r1, r9 3000ffc4: e1a02004 mov r2, r4 3000ffc8: e1a03005 mov r3, r5 3000ffcc: ebffeb56 bl 3000ad2c <_Heap_Block_allocate> 3000ffd0: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000ffd4: e5973044 ldr r3, [r7, #68] ; 0x44 3000ffd8: e1530006 cmp r3, r6
stats->max_search = search_count;
3000ffdc: 35876044 strcc r6, [r7, #68] ; 0x44
}
return (void *) alloc_begin;
}
3000ffe0: e28dd01c add sp, sp, #28
3000ffe4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
3000ffe8: e1550003 cmp r5, r3 <== NOT EXECUTED 3000ffec: 9a000008 bls 30010014 <_Heap_Allocate_aligned_with_boundary+0x234><== NOT EXECUTED
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000fff0: e3a00000 mov r0, #0 3000fff4: eafffff9 b 3000ffe0 <_Heap_Allocate_aligned_with_boundary+0x200>
3000fff8: e59d9018 ldr r9, [sp, #24] <== NOT EXECUTED
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
3000fffc: e2863001 add r3, r6, #1 <== NOT EXECUTED 30010000: e5999008 ldr r9, [r9, #8] <== NOT EXECUTED
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
30010004: e1570009 cmp r7, r9 <== NOT EXECUTED 30010008: 1affffe1 bne 3000ff94 <_Heap_Allocate_aligned_with_boundary+0x1b4><== NOT EXECUTED
3001000c: e3a00000 mov r0, #0 30010010: eaffffef b 3000ffd4 <_Heap_Allocate_aligned_with_boundary+0x1f4>
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
30010014: e3580000 cmp r8, #0 <== NOT EXECUTED 30010018: 01a08002 moveq r8, r2 <== NOT EXECUTED 3001001c: eaffff7c b 3000fe14 <_Heap_Allocate_aligned_with_boundary+0x34><== NOT EXECUTED
3000ad2c <_Heap_Block_allocate>:
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000ad2c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000ad30: e5917004 ldr r7, [r1, #4]
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000ad34: e1a05001 mov r5, r1
- 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;
3000ad38: e3c71001 bic r1, r7, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000ad3c: e0858001 add r8, r5, 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;
3000ad40: e598c004 ldr ip, [r8, #4]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000ad44: e2426008 sub r6, r2, #8
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000ad48: e31c0001 tst ip, #1
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000ad4c: e1a0a003 mov sl, r3 3000ad50: e1a04000 mov r4, r0
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;
3000ad54: e0653006 rsb r3, r5, r6
/* Statistics */
--stats->free_blocks;
++stats->used_blocks;
stats->free_size -= _Heap_Block_size( block );
} else {
free_list_anchor = _Heap_Free_list_head( heap );
3000ad58: 11a09000 movne r9, r0
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000ad5c: 1a00000c bne 3000ad94 <_Heap_Block_allocate+0x68>
free_list_anchor = block->prev;
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000ad60: e590e038 ldr lr, [r0, #56] ; 0x38
++stats->used_blocks;
3000ad64: e590c040 ldr ip, [r0, #64] ; 0x40
stats->free_size -= _Heap_Block_size( block );
3000ad68: e590b030 ldr fp, [r0, #48] ; 0x30
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
free_list_anchor = block->prev;
3000ad6c: e595900c ldr r9, [r5, #12]
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000ad70: e5950008 ldr r0, [r5, #8]
free_list_anchor = block->prev;
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000ad74: e24ee001 sub lr, lr, #1
++stats->used_blocks;
3000ad78: e28cc001 add ip, ip, #1
stats->free_size -= _Heap_Block_size( block );
3000ad7c: e061100b rsb r1, r1, fp
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
3000ad80: e5890008 str r0, [r9, #8]
next->prev = prev;
3000ad84: e580900c str r9, [r0, #12]
free_list_anchor = block->prev;
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000ad88: e584e038 str lr, [r4, #56] ; 0x38
++stats->used_blocks;
3000ad8c: e584c040 str ip, [r4, #64] ; 0x40
stats->free_size -= _Heap_Block_size( block );
3000ad90: e5841030 str r1, [r4, #48] ; 0x30
} else {
free_list_anchor = _Heap_Free_list_head( heap );
}
if ( alloc_area_offset < heap->page_size ) {
3000ad94: e5941010 ldr r1, [r4, #16] 3000ad98: e1530001 cmp r3, r1
3000ad9c: 3a000027 bcc 3000ae40 <_Heap_Block_allocate+0x114>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000ada0: e1a00002 mov r0, r2 3000ada4: eb002abb bl 30015898 <__umodsi3>
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000ada8: e5943030 ldr r3, [r4, #48] ; 0x30
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000adac: 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;
3000adb0: e0651006 rsb r1, r5, r6
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000adb4: e0833001 add r3, r3, r1
if ( _Heap_Is_prev_used( block ) ) {
3000adb8: e3170001 tst r7, #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;
3000adbc: e0668008 rsb r8, r6, r8
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000adc0: e5843030 str r3, [r4, #48] ; 0x30
if ( _Heap_Is_prev_used( block ) ) {
3000adc4: 1a000013 bne 3000ae18 <_Heap_Block_allocate+0xec>
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Prev_block(
const Heap_Block *block
)
{
return (Heap_Block *) ((uintptr_t) block - block->prev_size);
3000adc8: e5953000 ldr r3, [r5] <== 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;
3000adcc: e1a02009 mov r2, r9 <== NOT EXECUTED 3000add0: e0635005 rsb r5, r3, r5 <== 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;
3000add4: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 3000add8: e3c33001 bic r3, r3, #1 <== NOT EXECUTED 3000addc: e0811003 add r1, r1, r3 <== NOT EXECUTED
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
3000ade0: e3813001 orr r3, r1, #1 3000ade4: e5853004 str r3, [r5, #4]
new_block->prev_size = block_size;
3000ade8: e5861000 str r1, [r6]
new_block->size_and_flag = new_block_size;
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
3000adec: e1a00004 mov r0, r4 3000adf0: e1a0300a mov r3, sl
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
new_block->prev_size = block_size;
new_block->size_and_flag = new_block_size;
3000adf4: e5868004 str r8, [r6, #4]
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
3000adf8: e1a01006 mov r1, r6 3000adfc: ebffff1a bl 3000aa6c <_Heap_Block_split>
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000ae00: e5943030 ldr r3, [r4, #48] ; 0x30 3000ae04: e5942034 ldr r2, [r4, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000ae08: e1a00006 mov r0, r6
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000ae0c: e1520003 cmp r2, r3
stats->min_free_size = stats->free_size;
3000ae10: 85843034 strhi r3, [r4, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000ae14: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
_Heap_Free_list_insert_after( free_list_anchor, block );
free_list_anchor = block;
/* Statistics */
++stats->free_blocks;
3000ae18: e5940038 ldr r0, [r4, #56] ; 0x38
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000ae1c: e5993008 ldr r3, [r9, #8] 3000ae20: e2800001 add r0, r0, #1
new_block->next = next;
3000ae24: e5853008 str r3, [r5, #8]
new_block->prev = block_before;
3000ae28: e585900c str r9, [r5, #12]
block_before->next = new_block;
3000ae2c: e5895008 str r5, [r9, #8]
next->prev = new_block;
3000ae30: e583500c str r5, [r3, #12] 3000ae34: e1a02005 mov r2, r5 3000ae38: e5840038 str r0, [r4, #56] ; 0x38 3000ae3c: eaffffe7 b 3000ade0 <_Heap_Block_allocate+0xb4>
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
_Heap_Block_split( heap, block, free_list_anchor, alloc_size );
3000ae40: e1a00004 mov r0, r4 3000ae44: e1a02009 mov r2, r9 3000ae48: e083300a add r3, r3, sl 3000ae4c: e1a01005 mov r1, r5 3000ae50: ebffff05 bl 3000aa6c <_Heap_Block_split>
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000ae54: e5943030 ldr r3, [r4, #48] ; 0x30 3000ae58: e5942034 ldr r2, [r4, #52] ; 0x34
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
_Heap_Block_split( heap, block, free_list_anchor, alloc_size );
3000ae5c: e1a06005 mov r6, r5
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000ae60: e1520003 cmp r2, r3
stats->min_free_size = stats->free_size;
3000ae64: 85843034 strhi r3, [r4, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000ae68: e1a00006 mov r0, r6
3000ae6c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000aa6c <_Heap_Block_split>:
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000aa6c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, 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;
3000aa70: e5905014 ldr r5, [r0, #20]
uintptr_t alloc_size
)
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const page_size = heap->page_size;
3000aa74: e5906010 ldr r6, [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;
3000aa78: e2458008 sub r8, r5, #8
return heap->stats.size;
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Max( uintptr_t a, uintptr_t b )
{
return a > b ? a : b;
3000aa7c: e1530008 cmp r3, r8 3000aa80: 21a08003 movcs r8, r3
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const used_size =
3000aa84: e2888008 add r8, r8, #8
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000aa88: e1a07001 mov r7, r1 3000aa8c: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000aa90: e1a01006 mov r1, r6 3000aa94: e1a00008 mov r0, r8 3000aa98: e1a09002 mov r9, r2 3000aa9c: eb002b7d bl 30015898 <__umodsi3>
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000aaa0: e597a004 ldr sl, [r7, #4]
if ( remainder != 0 ) {
3000aaa4: e3500000 cmp r0, #0
- 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;
3000aaa8: e3ca2001 bic r2, sl, #1
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;
3000aaac: e2823004 add r3, r2, #4
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
3000aab0: 10886006 addne r6, r8, r6
} else {
return value;
3000aab4: 01a06008 moveq r6, r8
uintptr_t const free_size_limit = min_block_size + HEAP_ALLOC_BONUS;
3000aab8: e2855004 add r5, r5, #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;
3000aabc: e0688003 rsb r8, r8, r3
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
3000aac0: 10606006 rsbne r6, r0, r6
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 ) {
3000aac4: e1580005 cmp r8, r5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000aac8: e0873002 add r3, r7, r2
3000aacc: 3a00001c bcc 3000ab44 <_Heap_Block_split+0xd8>
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;
3000aad0: e20aa001 and sl, sl, #1
block->size_and_flag = size | flag;
3000aad4: e186a00a orr sl, r6, sl 3000aad8: e587a004 str sl, [r7, #4]
- 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;
3000aadc: e5931004 ldr r1, [r3, #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;
3000aae0: e5940030 ldr r0, [r4, #48] ; 0x30 3000aae4: e3c11001 bic r1, r1, #1
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000aae8: e083c001 add ip, 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;
3000aaec: e59cc004 ldr ip, [ip, #4]
_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;
3000aaf0: e0662002 rsb r2, r6, r2
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000aaf4: e0800002 add r0, r0, r2
if ( _Heap_Is_used( next_block ) ) {
3000aaf8: e31c0001 tst ip, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000aafc: e0867007 add r7, r6, r7
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000ab00: e5840030 str r0, [r4, #48] ; 0x30
if ( _Heap_Is_used( next_block ) ) {
3000ab04: 1a000012 bne 3000ab54 <_Heap_Block_split+0xe8>
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000ab08: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 3000ab0c: 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;
3000ab10: e0822001 add r2, r2, r1 <== NOT EXECUTED
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
3000ab14: e587300c str r3, [r7, #12] <== NOT EXECUTED
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
3000ab18: e5870008 str r0, [r7, #8] <== NOT EXECUTED
new_block->prev = prev;
next->prev = new_block;
3000ab1c: e580700c str r7, [r0, #12] <== NOT EXECUTED
prev->next = new_block;
3000ab20: e5837008 str r7, [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);
3000ab24: e0823007 add r3, r2, r7 <== NOT EXECUTED
next_block = _Heap_Block_at( free_block, free_block_size );
}
free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED;
3000ab28: e3821001 orr r1, r2, #1 3000ab2c: e5871004 str r1, [r7, #4]
next_block->prev_size = free_block_size;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000ab30: e5931004 ldr r1, [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;
3000ab34: e5832000 str r2, [r3]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000ab38: e3c12001 bic r2, r1, #1
3000ab3c: e5832004 str r2, [r3, #4]
3000ab40: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
_Heap_Protection_block_initialize( heap, free_block );
} else {
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000ab44: e5932004 ldr r2, [r3, #4]
3000ab48: e3822001 orr r2, r2, #1
3000ab4c: e5832004 str r2, [r3, #4]
3000ab50: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
if ( _Heap_Is_used( next_block ) ) {
_Heap_Free_list_insert_after( free_list_anchor, free_block );
/* Statistics */
++stats->free_blocks;
3000ab54: e5940038 ldr r0, [r4, #56] ; 0x38
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000ab58: e5991008 ldr r1, [r9, #8] 3000ab5c: e2800001 add r0, r0, #1
new_block->next = next;
3000ab60: e5871008 str r1, [r7, #8]
new_block->prev = block_before;
3000ab64: e587900c str r9, [r7, #12]
block_before->next = new_block;
3000ab68: e5897008 str r7, [r9, #8]
next->prev = new_block;
3000ab6c: e581700c str r7, [r1, #12] 3000ab70: e5840038 str r0, [r4, #56] ; 0x38 3000ab74: eaffffeb b 3000ab28 <_Heap_Block_split+0xbc>
30010364 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
30010364: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
30010368: e1a05000 mov r5, r0 <== 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 ) {
3001036c: e0916002 adds r6, r1, r2 <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
30010370: e1a04001 mov r4, r1 <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
30010374: e5908020 ldr r8, [r0, #32] <== 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; 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;
30010378: e5951030 ldr r1, [r5, #48] ; 0x30 <== 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;
3001037c: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
30010380: e24dd024 sub sp, sp, #36 ; 0x24 <== 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;
30010384: e3a07000 mov r7, #0 <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
30010388: e58d3010 str r3, [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;
3001038c: e58d0008 str r0, [sp, #8] <== 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;
30010390: e58d7020 str r7, [sp, #32] <== NOT EXECUTED
Heap_Block *extend_last_block = NULL;
30010394: e58d701c str r7, [sp, #28] <== NOT EXECUTED
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size;
30010398: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
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;
3001039c: e58d1018 str r1, [sp, #24] <== 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;
300103a0: 21a00007 movcs r0, r7 <== 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 ) {
300103a4: 3a000001 bcc 300103b0 <_Heap_Extend+0x4c> <== NOT EXECUTED
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
300103a8: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
300103ac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( extend_area_end < extend_area_begin ) {
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
300103b0: e28dc020 add ip, sp, #32 <== NOT EXECUTED 300103b4: e1a01002 mov r1, r2 <== NOT EXECUTED 300103b8: e58dc000 str ip, [sp] <== NOT EXECUTED 300103bc: e1a00004 mov r0, r4 <== NOT EXECUTED 300103c0: e28dc01c add ip, sp, #28 <== NOT EXECUTED 300103c4: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 300103c8: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 300103cc: ebffeac0 bl 3000aed4 <_Heap_Get_first_and_last_block> <== NOT EXECUTED
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
300103d0: e3500000 cmp r0, #0 <== NOT EXECUTED 300103d4: 0afffff3 beq 300103a8 <_Heap_Extend+0x44> <== NOT EXECUTED 300103d8: e1a09008 mov r9, r8 <== NOT EXECUTED 300103dc: e1a0b007 mov fp, r7 <== NOT EXECUTED 300103e0: e58d700c str r7, [sp, #12] <== NOT EXECUTED 300103e4: e58d7014 str r7, [sp, #20] <== NOT EXECUTED
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
300103e8: e1590008 cmp r9, r8 <== NOT EXECUTED 300103ec: 05953018 ldreq r3, [r5, #24] <== NOT EXECUTED
uintptr_t const sub_area_end = start_block->prev_size;
300103f0: e599a000 ldr sl, [r9] <== NOT EXECUTED
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
300103f4: 11a03009 movne r3, r9 <== NOT EXECUTED
uintptr_t const sub_area_end = start_block->prev_size;
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
300103f8: e1530006 cmp r3, r6 <== NOT EXECUTED 300103fc: 3154000a cmpcc r4, sl <== NOT EXECUTED 30010400: 3a00006c bcc 300105b8 <_Heap_Extend+0x254> <== NOT EXECUTED
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
30010404: e1530006 cmp r3, r6 <== NOT EXECUTED 30010408: 058d9014 streq r9, [sp, #20] <== NOT EXECUTED 3001040c: 0a000001 beq 30010418 <_Heap_Extend+0xb4> <== NOT EXECUTED
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
30010410: e156000a cmp r6, sl <== NOT EXECUTED 30010414: 31a0b009 movcc fp, r9 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30010418: e1a0000a mov r0, sl <== NOT EXECUTED 3001041c: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 30010420: eb00166f bl 30015de4 <__umodsi3> <== NOT EXECUTED 30010424: e24a3008 sub r3, sl, #8 <== NOT EXECUTED
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
30010428: e15a0004 cmp sl, r4 <== NOT EXECUTED
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3001042c: e0603003 rsb r3, r0, r3 <== NOT EXECUTED
start_block->prev_size = extend_area_end;
30010430: 05896000 streq r6, [r9] <== 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 )
30010434: 058d300c streq r3, [sp, #12] <== 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 ) {
30010438: 0a000001 beq 30010444 <_Heap_Extend+0xe0> <== NOT EXECUTED 3001043c: e154000a cmp r4, sl <== NOT EXECUTED 30010440: 81a07003 movhi r7, r3 <== 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;
30010444: e5939004 ldr r9, [r3, #4] <== NOT EXECUTED 30010448: e3c99001 bic r9, r9, #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);
3001044c: e0839009 add r9, r3, r9 <== 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 );
30010450: e1580009 cmp r8, r9 <== NOT EXECUTED 30010454: 1affffe3 bne 300103e8 <_Heap_Extend+0x84> <== NOT EXECUTED
if ( extend_area_begin < heap->area_begin ) {
30010458: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED 3001045c: e1540003 cmp r4, r3 <== NOT EXECUTED
heap->area_begin = extend_area_begin;
30010460: 35854018 strcc r4, [r5, #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 ) {
30010464: 3a000002 bcc 30010474 <_Heap_Extend+0x110> <== NOT EXECUTED
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
30010468: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3001046c: e1560003 cmp r6, r3 <== NOT EXECUTED
heap->area_end = extend_area_end;
30010470: 8585601c strhi r6, [r5, #28] <== NOT EXECUTED
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
30010474: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 30010478: e59d201c ldr r2, [sp, #28] <== 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 ) {
3001047c: e595c020 ldr ip, [r5, #32] <== 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 =
30010480: e0631002 rsb r1, r3, r2 <== 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;
30010484: e3810001 orr r0, r1, #1 <== NOT EXECUTED
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
30010488: e5836000 str r6, [r3] <== 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 ) {
3001048c: e15c0003 cmp ip, r3 <== NOT EXECUTED
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
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;
30010490: e5821000 str r1, [r2] <== NOT EXECUTED
extend_last_block->size_and_flag = 0;
30010494: e3a01000 mov r1, #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 =
30010498: e5830004 str r0, [r3, #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;
3001049c: e5821004 str r1, [r2, #4] <== NOT EXECUTED
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
heap->first_block = extend_first_block;
300104a0: 85853020 strhi r3, [r5, #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 ) {
300104a4: 8a000002 bhi 300104b4 <_Heap_Extend+0x150> <== NOT EXECUTED
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
300104a8: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED 300104ac: e1530002 cmp r3, r2 <== NOT EXECUTED
heap->last_block = extend_last_block;
300104b0: 35852024 strcc r2, [r5, #36] ; 0x24 <== NOT EXECUTED
}
if ( merge_below_block != NULL ) {
300104b4: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 300104b8: e3530000 cmp r3, #0 <== NOT EXECUTED 300104bc: 0a000050 beq 30010604 <_Heap_Extend+0x2a0> <== NOT EXECUTED
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
300104c0: e5958010 ldr r8, [r5, #16] <== NOT EXECUTED
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
300104c4: e2844008 add r4, r4, #8 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
300104c8: e1a00004 mov r0, r4 <== NOT EXECUTED 300104cc: e1a01008 mov r1, r8 <== NOT EXECUTED 300104d0: eb001643 bl 30015de4 <__umodsi3> <== NOT EXECUTED
if ( remainder != 0 ) {
300104d4: e3500000 cmp r0, #0 <== NOT EXECUTED
return value - remainder + alignment;
300104d8: 10844008 addne r4, r4, r8 <== NOT EXECUTED 300104dc: 10604004 rsbne r4, r0, r4 <== 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;
300104e0: e59dc014 ldr ip, [sp, #20] <== 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 =
300104e4: e2441008 sub r1, r4, #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;
300104e8: e59c2000 ldr r2, [ip] <== 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 =
300104ec: e061300c rsb r3, r1, ip <== 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;
300104f0: e3833001 orr r3, r3, #1 <== 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;
300104f4: e5042008 str r2, [r4, #-8] <== NOT EXECUTED
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
300104f8: e5813004 str r3, [r1, #4] <== NOT EXECUTED
_Heap_Free_block( heap, new_first_block );
300104fc: e1a00005 mov r0, r5 <== NOT EXECUTED 30010500: ebffff8f bl 30010344 <_Heap_Free_block> <== NOT EXECUTED
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
30010504: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED 30010508: e3500000 cmp r0, #0 <== NOT EXECUTED 3001050c: 0a00002b beq 300105c0 <_Heap_Extend+0x25c> <== 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,
30010510: 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(
30010514: e0606006 rsb r6, r0, r6 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30010518: e5951010 ldr r1, [r5, #16] <== NOT EXECUTED 3001051c: e1a00006 mov r0, r6 <== NOT EXECUTED 30010520: eb00162f bl 30015de4 <__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)
30010524: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 30010528: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3001052c: e5913004 ldr r3, [r1, #4] <== 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 =
30010530: e0862001 add r2, r6, r1 <== NOT EXECUTED
(last_block->size_and_flag - last_block_new_size)
30010534: e0663003 rsb r3, r6, r3 <== NOT EXECUTED
| HEAP_PREV_BLOCK_USED;
30010538: e3833001 orr r3, r3, #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 =
3001053c: e5823004 str r3, [r2, #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;
30010540: e5913004 ldr r3, [r1, #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 );
30010544: e1a00005 mov r0, r5 <== NOT EXECUTED 30010548: e2033001 and r3, r3, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3001054c: e1866003 orr r6, r6, r3 <== NOT EXECUTED 30010550: e5816004 str r6, [r1, #4] <== NOT EXECUTED 30010554: ebffff7a bl 30010344 <_Heap_Free_block> <== NOT EXECUTED
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
30010558: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 3001055c: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 30010560: e3520000 cmp r2, #0 <== NOT EXECUTED 30010564: 03530000 cmpeq r3, #0 <== NOT EXECUTED 30010568: 0a000021 beq 300105f4 <_Heap_Extend+0x290> <== NOT EXECUTED
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
3001056c: e5953024 ldr r3, [r5, #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(
30010570: e595c020 ldr ip, [r5, #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;
30010574: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
30010578: e5952030 ldr r2, [r5, #48] ; 0x30 <== 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(
3001057c: e063c00c rsb ip, r3, ip <== NOT EXECUTED 30010580: e59d4018 ldr r4, [sp, #24] <== 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;
30010584: e2000001 and r0, r0, #1 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
30010588: e595102c ldr r1, [r5, #44] ; 0x2c <== NOT EXECUTED
block->size_and_flag = size | flag;
3001058c: e18c0000 orr r0, ip, r0 <== NOT EXECUTED
if ( extended_size_ptr != NULL )
30010590: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
30010594: e0642002 rsb r2, r4, r2 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
30010598: e35c0000 cmp ip, #0 <== NOT EXECUTED
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
3001059c: e0811002 add r1, r1, r2 <== NOT EXECUTED 300105a0: e5830004 str r0, [r3, #4] <== NOT EXECUTED 300105a4: e585102c str r1, [r5, #44] ; 0x2c <== NOT EXECUTED
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
300105a8: 13a00001 movne r0, #1 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
300105ac: 158c2000 strne r2, [ip] <== NOT EXECUTED
return true;
300105b0: 03a00001 moveq r0, #1 <== NOT EXECUTED 300105b4: eaffff7b b 300103a8 <_Heap_Extend+0x44> <== 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;
300105b8: e3a00000 mov r0, #0 <== NOT EXECUTED 300105bc: eaffff79 b 300103a8 <_Heap_Extend+0x44> <== NOT EXECUTED
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
300105c0: e3570000 cmp r7, #0 <== NOT EXECUTED 300105c4: 0affffe3 beq 30010558 <_Heap_Extend+0x1f4> <== 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;
300105c8: e5971004 ldr r1, [r7, #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 );
300105cc: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 300105d0: e2011001 and r1, r1, #1 <== NOT EXECUTED 300105d4: e0672002 rsb r2, r7, r2 <== 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(
300105d8: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
block->size_and_flag = size | flag;
300105dc: e1822001 orr r2, r2, r1 <== NOT EXECUTED 300105e0: e5872004 str r2, [r7, #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;
300105e4: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 300105e8: e3822001 orr r2, r2, #1 <== NOT EXECUTED 300105ec: e5832004 str r2, [r3, #4] <== NOT EXECUTED 300105f0: eaffffd8 b 30010558 <_Heap_Extend+0x1f4> <== NOT EXECUTED
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
_Heap_Free_block( heap, extend_first_block );
300105f4: e1a00005 mov r0, r5 <== NOT EXECUTED 300105f8: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 300105fc: ebffff50 bl 30010344 <_Heap_Free_block> <== NOT EXECUTED 30010600: eaffffd9 b 3001056c <_Heap_Extend+0x208> <== 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 ) {
30010604: e35b0000 cmp fp, #0 <== 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;
30010608: 1062b00b rsbne fp, r2, fp <== NOT EXECUTED 3001060c: 138bb001 orrne fp, fp, #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 =
30010610: 1582b004 strne fp, [r2, #4] <== NOT EXECUTED 30010614: eaffffba b 30010504 <_Heap_Extend+0x1a0> <== NOT EXECUTED
30010020 <_Heap_Free>:
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
30010020: e2513000 subs r3, r1, #0
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
30010024: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30010028: e1a04000 mov r4, r0
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
3001002c: 03a00001 moveq r0, #1
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
30010030: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30010034: e1a00003 mov r0, r3 30010038: e5941010 ldr r1, [r4, #16] 3001003c: e2435008 sub r5, r3, #8 30010040: eb001614 bl 30015898 <__umodsi3>
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
30010044: e5942020 ldr r2, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
30010048: e0605005 rsb r5, r0, r5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3001004c: e1550002 cmp r5, r2
30010050: 3a00002f bcc 30010114 <_Heap_Free+0xf4>
30010054: e5941024 ldr r1, [r4, #36] ; 0x24 30010058: e1550001 cmp r5, r1
3001005c: 8a00002c bhi 30010114 <_Heap_Free+0xf4>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
30010060: e595c004 ldr ip, [r5, #4]
- 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;
30010064: e3cc6001 bic r6, ip, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30010068: e0853006 add r3, r5, r6
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3001006c: e1520003 cmp r2, r3
30010070: 8a000027 bhi 30010114 <_Heap_Free+0xf4>
30010074: e1510003 cmp r1, r3
30010078: 3a000027 bcc 3001011c <_Heap_Free+0xfc>
3001007c: e5937004 ldr r7, [r3, #4]
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
30010080: e2170001 ands r0, r7, #1
30010084: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
30010088: e1510003 cmp r1, r3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3001008c: e3c77001 bic r7, r7, #1 30010090: 03a08000 moveq r8, #0
30010094: 0a000004 beq 300100ac <_Heap_Free+0x8c>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
30010098: e0830007 add r0, r3, r7
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;
3001009c: e5900004 ldr r0, [r0, #4]
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
300100a0: e3100001 tst r0, #1 300100a4: 13a08000 movne r8, #0 300100a8: 03a08001 moveq r8, #1
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
300100ac: e21c0001 ands r0, ip, #1
300100b0: 1a00001b bne 30010124 <_Heap_Free+0x104>
uintptr_t const prev_size = block->prev_size;
300100b4: e595c000 ldr ip, [r5]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
300100b8: e06ca005 rsb sl, ip, r5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
300100bc: e152000a cmp r2, sl
300100c0: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
300100c4: e151000a cmp r1, sl
300100c8: 38bd85f0 popcc {r4, r5, r6, r7, r8, sl, pc}
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
300100cc: e59a0004 ldr r0, [sl, #4]
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
300100d0: e2100001 ands r0, r0, #1
300100d4: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
300100d8: e3580000 cmp r8, #0
300100dc: 0a000039 beq 300101c8 <_Heap_Free+0x1a8>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
300100e0: e5940038 ldr r0, [r4, #56] ; 0x38
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
300100e4: e0867007 add r7, r6, r7
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
300100e8: e5932008 ldr r2, [r3, #8]
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
300100ec: e087c00c add ip, r7, ip
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
300100f0: e593300c ldr r3, [r3, #12]
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
300100f4: e2400001 sub r0, r0, #1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
300100f8: e38c1001 orr r1, ip, #1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
300100fc: e5832008 str r2, [r3, #8]
next->prev = prev;
30010100: e582300c str r3, [r2, #12]
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
30010104: e5840038 str r0, [r4, #56] ; 0x38
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
30010108: e58a1004 str r1, [sl, #4]
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
3001010c: e78ac00c str ip, [sl, ip] 30010110: ea00000f b 30010154 <_Heap_Free+0x134>
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
return false;
30010114: e3a00000 mov r0, #0
30010118: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
3001011c: e3a00000 mov r0, #0 <== NOT EXECUTED
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
30010120: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
30010124: e3580000 cmp r8, #0
30010128: 0a000014 beq 30010180 <_Heap_Free+0x160>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3001012c: e5932008 ldr r2, [r3, #8]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
30010130: e0877006 add r7, r7, r6
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
30010134: e593300c ldr r3, [r3, #12]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
30010138: e3871001 orr r1, r7, #1
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
3001013c: e5852008 str r2, [r5, #8]
new_block->prev = prev;
30010140: e585300c str r3, [r5, #12]
next->prev = new_block;
prev->next = new_block;
30010144: e5835008 str r5, [r3, #8]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
30010148: e582500c str r5, [r2, #12] 3001014c: e5851004 str r1, [r5, #4]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
30010150: e7857007 str r7, [r5, r7]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
30010154: e5942040 ldr r2, [r4, #64] ; 0x40
++stats->frees;
30010158: e5943050 ldr r3, [r4, #80] ; 0x50
stats->free_size += block_size;
3001015c: e5941030 ldr r1, [r4, #48] ; 0x30
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
30010160: e2422001 sub r2, r2, #1
++stats->frees;
30010164: e2833001 add r3, r3, #1
stats->free_size += block_size;
30010168: e0816006 add r6, r1, r6
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
3001016c: e5842040 str r2, [r4, #64] ; 0x40
++stats->frees;
30010170: e5843050 str r3, [r4, #80] ; 0x50
stats->free_size += block_size;
30010174: e5846030 str r6, [r4, #48] ; 0x30
return( true );
30010178: e3a00001 mov r0, #1
3001017c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
30010180: e3862001 orr r2, r6, #1 30010184: e5852004 str r2, [r5, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
30010188: e5942038 ldr r2, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
3001018c: e594c03c ldr ip, [r4, #60] ; 0x3c
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
30010190: e5930004 ldr r0, [r3, #4]
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
30010194: e5941008 ldr r1, [r4, #8]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
30010198: e2822001 add r2, r2, #1
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3001019c: e3c00001 bic r0, r0, #1
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
300101a0: e152000c cmp r2, ip
new_block->next = next;
300101a4: e5851008 str r1, [r5, #8]
new_block->prev = block_before;
300101a8: e585400c str r4, [r5, #12]
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
300101ac: e5830004 str r0, [r3, #4]
block_before->next = new_block; next->prev = new_block;
300101b0: e581500c str r5, [r1, #12]
next_block->prev_size = block_size;
300101b4: e7856006 str r6, [r5, r6]
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
300101b8: e5845008 str r5, [r4, #8]
/* Statistics */
++stats->free_blocks;
300101bc: e5842038 str r2, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
stats->max_free_blocks = stats->free_blocks;
300101c0: 8584203c strhi r2, [r4, #60] ; 0x3c 300101c4: eaffffe2 b 30010154 <_Heap_Free+0x134>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
300101c8: e086c00c add ip, r6, ip
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
300101cc: e38c2001 orr r2, ip, #1 300101d0: e58a2004 str r2, [sl, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
300101d4: e5932004 ldr r2, [r3, #4]
next_block->prev_size = size;
300101d8: e785c006 str ip, [r5, r6]
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
300101dc: e3c22001 bic r2, r2, #1 300101e0: e5832004 str r2, [r3, #4] 300101e4: eaffffda b 30010154 <_Heap_Free+0x134>
30010344 <_Heap_Free_block>:
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block )
{
Heap_Statistics *const stats = &heap->stats;
/* Statistics */
++stats->used_blocks;
30010344: e590c040 ldr ip, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
30010348: e5902050 ldr r2, [r0, #80] ; 0x50 <== NOT EXECUTED
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block )
{
Heap_Statistics *const stats = &heap->stats;
/* Statistics */
++stats->used_blocks;
3001034c: e28cc001 add ip, ip, #1 <== NOT EXECUTED
--stats->frees;
30010350: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ));
30010354: 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;
30010358: e580c040 str ip, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
3001035c: e5802050 str r2, [r0, #80] ; 0x50 <== NOT EXECUTED
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ));
30010360: ea0000ac b 30010618 <_Heap_Free> <== NOT EXECUTED
30017c94 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
30017c94: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30017c98: e1a04000 mov r4, r0
30017c9c: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30017ca0: e1a00001 mov r0, r1 30017ca4: e5941010 ldr r1, [r4, #16] 30017ca8: e1a07003 mov r7, r3 30017cac: e1a0a002 mov sl, r2 30017cb0: ebfff6f8 bl 30015898 <__umodsi3> 30017cb4: e2458008 sub r8, r5, #8
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;
30017cb8: e5943020 ldr r3, [r4, #32] 30017cbc: e59d601c ldr r6, [sp, #28]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
30017cc0: e0601008 rsb r1, r0, r8
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;
30017cc4: e3a02000 mov r2, #0
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;
30017cc8: e1530001 cmp r3, r1 30017ccc: e5872000 str r2, [r7]
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
30017cd0: 83a00002 movhi r0, #2
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;
*new_size = 0;
30017cd4: e5862000 str r2, [r6]
30017cd8: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
30017cdc: e5943024 ldr r3, [r4, #36] ; 0x24
30017ce0: e1530001 cmp r3, r1
30017ce4: 3a000036 bcc 30017dc4 <_Heap_Resize_block+0x130>
- 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;
30017ce8: e5910004 ldr r0, [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;
30017cec: e2653004 rsb r3, r5, #4 30017cf0: e3c00001 bic r0, r0, #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;
30017cf4: e0812000 add r2, r1, r0 30017cf8: e592c004 ldr ip, [r2, #4]
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
30017cfc: e0833002 add r3, r3, r2 30017d00: e3ccc001 bic ip, ip, #1
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
30017d04: e082800c add r8, r2, ip
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;
30017d08: e5988004 ldr r8, [r8, #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;
30017d0c: e5873000 str r3, [r7]
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
30017d10: e3180001 tst r8, #1 30017d14: 13a07000 movne r7, #0 30017d18: 03a07001 moveq r7, #1
if ( next_block_is_free ) {
30017d1c: e3570000 cmp r7, #0
block_size += next_block_size;
alloc_size += next_block_size;
30017d20: 1083300c addne r3, r3, ip
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
if ( next_block_is_free ) {
block_size += next_block_size;
30017d24: 1080000c addne r0, r0, ip
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
30017d28: e15a0003 cmp sl, r3
return HEAP_RESIZE_UNSATISFIED;
30017d2c: 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 ) {
30017d30: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
30017d34: e3570000 cmp r7, #0
30017d38: 0a000011 beq 30017d84 <_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;
30017d3c: e591e004 ldr lr, [r1, #4] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30017d40: e0803001 add r3, r0, 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;
30017d44: e20ee001 and lr, lr, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
30017d48: e180000e orr r0, r0, lr <== NOT EXECUTED 30017d4c: e5810004 str r0, [r1, #4] <== NOT EXECUTED
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
/* Statistics */
--stats->free_blocks;
30017d50: e594e038 ldr lr, [r4, #56] ; 0x38 <== NOT EXECUTED
stats->free_size -= next_block_size;
30017d54: e5948030 ldr r8, [r4, #48] ; 0x30 <== 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;
30017d58: e5937004 ldr r7, [r3, #4] <== NOT EXECUTED
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
30017d5c: e5920008 ldr r0, [r2, #8] <== NOT EXECUTED 30017d60: e592200c ldr r2, [r2, #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;
30017d64: e3877001 orr r7, r7, #1 <== NOT EXECUTED
/* Statistics */
--stats->free_blocks;
30017d68: e24ee001 sub lr, lr, #1 <== NOT EXECUTED
stats->free_size -= next_block_size;
30017d6c: e06cc008 rsb ip, ip, r8 <== 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;
30017d70: e5820008 str r0, [r2, #8] <== NOT EXECUTED
next->prev = prev;
30017d74: e580200c str r2, [r0, #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;
30017d78: e5837004 str r7, [r3, #4] <== NOT EXECUTED
/* Statistics */
--stats->free_blocks;
30017d7c: e584e038 str lr, [r4, #56] ; 0x38 <== NOT EXECUTED
stats->free_size -= next_block_size;
30017d80: e584c030 str ip, [r4, #48] ; 0x30 <== NOT EXECUTED
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
30017d84: e1a02005 mov r2, r5 30017d88: e1a0300a mov r3, sl 30017d8c: e1a00004 mov r0, r4 30017d90: ebffcbe5 bl 3000ad2c <_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;
30017d94: e5902004 ldr r2, [r0, #4] 30017d98: e1a03000 mov r3, r0 30017d9c: e3c22001 bic r2, r2, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30017da0: e2822004 add r2, r2, #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;
30017da4: e0655002 rsb r5, r5, r2 30017da8: e0833005 add r3, r3, r5 30017dac: e5863000 str r3, [r6]
/* Statistics */
++stats->resizes;
30017db0: e5943054 ldr r3, [r4, #84] ; 0x54
return HEAP_RESIZE_SUCCESSFUL;
30017db4: 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;
30017db8: e2833001 add r3, r3, #1
30017dbc: e5843054 str r3, [r4, #84] ; 0x54
30017dc0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
30017dc4: e3a00002 mov r0, #2 <== NOT EXECUTED
}
30017dc8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30017dcc <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
30017dcc: e92d40f0 push {r4, r5, r6, r7, lr}
30017dd0: e1a04000 mov r4, r0
30017dd4: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30017dd8: e1a00001 mov r0, r1 30017ddc: e5941010 ldr r1, [r4, #16] 30017de0: e1a07002 mov r7, r2 30017de4: ebfff6ab bl 30015898 <__umodsi3> 30017de8: e2456008 sub r6, r5, #8
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
30017dec: 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);
30017df0: e0600006 rsb r0, r0, 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;
30017df4: e1500003 cmp r0, r3
30017df8: 3a000010 bcc 30017e40 <_Heap_Size_of_alloc_area+0x74>
30017dfc: e5942024 ldr r2, [r4, #36] ; 0x24 30017e00: e1500002 cmp r0, r2
30017e04: 8a00000d bhi 30017e40 <_Heap_Size_of_alloc_area+0x74>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
30017e08: e5906004 ldr r6, [r0, #4] 30017e0c: e3c66001 bic r6, r6, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30017e10: e0806006 add r6, r0, 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;
30017e14: e1530006 cmp r3, r6
30017e18: 8a000008 bhi 30017e40 <_Heap_Size_of_alloc_area+0x74>
30017e1c: e1520006 cmp r2, r6
30017e20: 3a000008 bcc 30017e48 <_Heap_Size_of_alloc_area+0x7c>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
30017e24: e5960004 ldr r0, [r6, #4]
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
30017e28: e2100001 ands r0, r0, #1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
30017e2c: 12655004 rsbne r5, r5, #4 30017e30: 10856006 addne r6, r5, r6 30017e34: 15876000 strne r6, [r7]
return true;
30017e38: 13a00001 movne r0, #1
30017e3c: e8bd80f0 pop {r4, r5, r6, r7, pc}
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
30017e40: e3a00000 mov r0, #0 <== NOT EXECUTED
30017e44: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30017e48: e3a00000 mov r0, #0 <== NOT EXECUTED
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
30017e4c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000bac4 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000bac4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== 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() ) ) {
3000bac8: e59f35d8 ldr r3, [pc, #1496] ; 3000c0a8 <_Heap_Walk+0x5e4> <== NOT EXECUTED
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;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
3000bacc: e31200ff tst r2, #255 ; 0xff <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000bad0: e5933000 ldr r3, [r3] <== NOT EXECUTED
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;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
3000bad4: e59f25d0 ldr r2, [pc, #1488] ; 3000c0ac <_Heap_Walk+0x5e8> <== NOT EXECUTED 3000bad8: e59f95d0 ldr r9, [pc, #1488] ; 3000c0b0 <_Heap_Walk+0x5ec> <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000badc: e1a0a001 mov sl, r1 <== NOT EXECUTED
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;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
3000bae0: 11a09002 movne r9, r2 <== NOT EXECUTED
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
3000bae4: e5901010 ldr r1, [r0, #16] <== 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() ) ) {
3000bae8: e3530003 cmp r3, #3 <== NOT EXECUTED
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000baec: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
3000baf0: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000baf4: e24dd038 sub sp, sp, #56 ; 0x38 <== NOT EXECUTED 3000baf8: e1a04000 mov r4, r0 <== NOT EXECUTED
uintptr_t const page_size = heap->page_size;
3000bafc: e58d1024 str r1, [sp, #36] ; 0x24 <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
3000bb00: e58d2028 str r2, [sp, #40] ; 0x28 <== NOT EXECUTED
Heap_Block *const first_block = heap->first_block;
3000bb04: e5908020 ldr r8, [r0, #32] <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
3000bb08: e58d302c str r3, [sp, #44] ; 0x2c <== 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() ) ) {
3000bb0c: 0a000002 beq 3000bb1c <_Heap_Walk+0x58> <== NOT EXECUTED
}
block = next_block;
} while ( block != first_block );
return true;
3000bb10: e3a00001 mov r0, #1 <== NOT EXECUTED
}
3000bb14: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
3000bb18: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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)(
3000bb1c: e594101c ldr r1, [r4, #28] <== NOT EXECUTED 3000bb20: e5900018 ldr r0, [r0, #24] <== NOT EXECUTED 3000bb24: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3000bb28: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3000bb2c: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bb30: e58d1008 str r1, [sp, #8] <== NOT EXECUTED 3000bb34: e59d102c ldr r1, [sp, #44] ; 0x2c <== NOT EXECUTED 3000bb38: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 3000bb3c: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000bb40: e58d2014 str r2, [sp, #20] <== NOT EXECUTED 3000bb44: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000bb48: e59f2564 ldr r2, [pc, #1380] ; 3000c0b4 <_Heap_Walk+0x5f0> <== NOT EXECUTED 3000bb4c: e58dc000 str ip, [sp] <== NOT EXECUTED 3000bb50: e58d800c str r8, [sp, #12] <== NOT EXECUTED 3000bb54: e1a0000a mov r0, sl <== NOT EXECUTED 3000bb58: e3a01000 mov r1, #0 <== NOT EXECUTED 3000bb5c: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bb60: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bb64: e12fff19 bx r9 <== NOT EXECUTED
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
3000bb68: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bb6c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000bb70: 0a000026 beq 3000bc10 <_Heap_Walk+0x14c> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
3000bb74: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bb78: e2135007 ands r5, r3, #7 <== NOT EXECUTED 3000bb7c: 1a00002a bne 3000bc2c <_Heap_Walk+0x168> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bb80: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bb84: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bb88: ebffe54c bl 300050c0 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
3000bb8c: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3000bb90: 1a00002c bne 3000bc48 <_Heap_Walk+0x184> <== NOT EXECUTED 3000bb94: e2880008 add r0, r8, #8 <== NOT EXECUTED 3000bb98: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bb9c: ebffe547 bl 300050c0 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000bba0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000bba4: 1a00002f bne 3000bc68 <_Heap_Walk+0x1a4> <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bba8: e598b004 ldr fp, [r8, #4] <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
3000bbac: e21b5001 ands r5, fp, #1 <== NOT EXECUTED 3000bbb0: 0a000103 beq 3000bfc4 <_Heap_Walk+0x500> <== 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;
3000bbb4: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 3000bbb8: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 3000bbbc: e3c33001 bic r3, 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);
3000bbc0: e08c3003 add r3, ip, 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;
3000bbc4: e5935004 ldr r5, [r3, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
3000bbc8: e2155001 ands r5, r5, #1 <== NOT EXECUTED 3000bbcc: 0a000008 beq 3000bbf4 <_Heap_Walk+0x130> <== NOT EXECUTED
);
return false;
}
if (
3000bbd0: e1580003 cmp r8, r3 <== NOT EXECUTED 3000bbd4: 0a00002b beq 3000bc88 <_Heap_Walk+0x1c4> <== NOT EXECUTED
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
3000bbd8: e1a0000a mov r0, sl <== NOT EXECUTED 3000bbdc: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bbe0: e59f24d0 ldr r2, [pc, #1232] ; 3000c0b8 <_Heap_Walk+0x5f4> <== NOT EXECUTED 3000bbe4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bbe8: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bbec: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bbf0: eaffffc7 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
3000bbf4: e1a0000a mov r0, sl <== NOT EXECUTED 3000bbf8: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bbfc: e59f24b8 ldr r2, [pc, #1208] ; 3000c0bc <_Heap_Walk+0x5f8> <== NOT EXECUTED 3000bc00: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bc04: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bc08: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bc0c: eaffffc0 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
3000bc10: e1a0000a mov r0, sl <== NOT EXECUTED 3000bc14: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bc18: e59f24a0 ldr r2, [pc, #1184] ; 3000c0c0 <_Heap_Walk+0x5fc> <== NOT EXECUTED 3000bc1c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bc20: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bc24: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bc28: eaffffb9 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
3000bc2c: e1a0000a mov r0, sl <== NOT EXECUTED 3000bc30: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bc34: e59f2488 ldr r2, [pc, #1160] ; 3000c0c4 <_Heap_Walk+0x600> <== NOT EXECUTED 3000bc38: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bc3c: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bc40: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bc44: eaffffb2 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
3000bc48: e1a0000a mov r0, sl <== NOT EXECUTED 3000bc4c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bc50: e59f2470 ldr r2, [pc, #1136] ; 3000c0c8 <_Heap_Walk+0x604> <== NOT EXECUTED 3000bc54: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bc58: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bc5c: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bc60: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bc64: eaffffaa b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
3000bc68: e1a0000a mov r0, sl <== NOT EXECUTED 3000bc6c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bc70: e59f2454 ldr r2, [pc, #1108] ; 3000c0cc <_Heap_Walk+0x608> <== NOT EXECUTED 3000bc74: e1a03008 mov r3, r8 <== NOT EXECUTED 3000bc78: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bc7c: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bc80: e1a0000b mov r0, fp <== NOT EXECUTED 3000bc84: eaffffa2 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bc88: e5946008 ldr r6, [r4, #8] <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
3000bc8c: e5947010 ldr r7, [r4, #16] <== 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 ) {
3000bc90: e1540006 cmp r4, r6 <== NOT EXECUTED 3000bc94: 05943020 ldreq r3, [r4, #32] <== NOT EXECUTED 3000bc98: 0a00002c beq 3000bd50 <_Heap_Walk+0x28c> <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bc9c: e5943020 ldr r3, [r4, #32] <== 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;
3000bca0: e1530006 cmp r3, r6 <== NOT EXECUTED 3000bca4: 8a0000cd bhi 3000bfe0 <_Heap_Walk+0x51c> <== NOT EXECUTED 3000bca8: e594c024 ldr ip, [r4, #36] ; 0x24 <== NOT EXECUTED 3000bcac: e15c0006 cmp ip, r6 <== NOT EXECUTED 3000bcb0: 3a0000ca bcc 3000bfe0 <_Heap_Walk+0x51c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bcb4: e2860008 add r0, r6, #8 <== NOT EXECUTED 3000bcb8: e1a01007 mov r1, r7 <== NOT EXECUTED 3000bcbc: e58d3020 str r3, [sp, #32] <== NOT EXECUTED 3000bcc0: e58dc01c str ip, [sp, #28] <== NOT EXECUTED 3000bcc4: ebffe4fd bl 300050c0 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000bcc8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bccc: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3000bcd0: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 3000bcd4: 1a0000df bne 3000c058 <_Heap_Walk+0x594> <== 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;
3000bcd8: e5962004 ldr r2, [r6, #4] <== NOT EXECUTED 3000bcdc: e3c22001 bic r2, r2, #1 <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bce0: e0862002 add r2, r6, r2 <== 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;
3000bce4: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000bce8: e3120001 tst r2, #1 <== NOT EXECUTED 3000bcec: 1a0000eb bne 3000c0a0 <_Heap_Walk+0x5dc> <== NOT EXECUTED 3000bcf0: e58d8030 str r8, [sp, #48] ; 0x30 <== NOT EXECUTED 3000bcf4: e58db034 str fp, [sp, #52] ; 0x34 <== NOT EXECUTED 3000bcf8: e1a02004 mov r2, r4 <== NOT EXECUTED 3000bcfc: e1a08003 mov r8, r3 <== NOT EXECUTED 3000bd00: e1a0b00c mov fp, ip <== NOT EXECUTED
);
return false;
}
if ( free_block->prev != prev_block ) {
3000bd04: e596100c ldr r1, [r6, #12] <== NOT EXECUTED 3000bd08: e1510002 cmp r1, r2 <== NOT EXECUTED 3000bd0c: 1a0000da bne 3000c07c <_Heap_Walk+0x5b8> <== NOT EXECUTED
return false;
}
prev_block = free_block;
free_block = free_block->next;
3000bd10: e5965008 ldr r5, [r6, #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 ) {
3000bd14: e1540005 cmp r4, r5 <== NOT EXECUTED 3000bd18: 0a000009 beq 3000bd44 <_Heap_Walk+0x280> <== 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;
3000bd1c: e1580005 cmp r8, r5 <== NOT EXECUTED 3000bd20: 9a00007d bls 3000bf1c <_Heap_Walk+0x458> <== NOT EXECUTED
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
3000bd24: e1a0000a mov r0, sl <== NOT EXECUTED 3000bd28: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bd2c: e59f239c ldr r2, [pc, #924] ; 3000c0d0 <_Heap_Walk+0x60c> <== NOT EXECUTED 3000bd30: e1a03005 mov r3, r5 <== NOT EXECUTED 3000bd34: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bd38: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bd3c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bd40: eaffff73 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED 3000bd44: e1a03008 mov r3, r8 <== NOT EXECUTED 3000bd48: e59db034 ldr fp, [sp, #52] ; 0x34 <== NOT EXECUTED 3000bd4c: e59d8030 ldr r8, [sp, #48] ; 0x30 <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000bd50: e1a06008 mov r6, r8 <== 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;
3000bd54: e3cb7001 bic r7, fp, #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);
3000bd58: e0875006 add r5, r7, r6 <== 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;
3000bd5c: e1530005 cmp r3, r5 <== NOT EXECUTED 3000bd60: 9a000008 bls 3000bd88 <_Heap_Walk+0x2c4> <== NOT EXECUTED
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 ) ) {
(*printer)(
3000bd64: e1a0000a mov r0, sl <== NOT EXECUTED 3000bd68: e58d5000 str r5, [sp] <== NOT EXECUTED 3000bd6c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bd70: e59f235c ldr r2, [pc, #860] ; 3000c0d4 <_Heap_Walk+0x610> <== NOT EXECUTED 3000bd74: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bd78: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bd7c: e12fff19 bx r9 <== NOT EXECUTED
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
3000bd80: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bd84: eaffff62 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED 3000bd88: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3000bd8c: e1530005 cmp r3, r5 <== NOT EXECUTED 3000bd90: 3afffff3 bcc 3000bd64 <_Heap_Walk+0x2a0> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bd94: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bd98: e1a00007 mov r0, r7 <== NOT EXECUTED 3000bd9c: ebffe4c7 bl 300050c0 <__umodsi3> <== 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;
3000bda0: e59d102c ldr r1, [sp, #44] ; 0x2c <== NOT EXECUTED 3000bda4: e0563001 subs r3, r6, r1 <== NOT EXECUTED 3000bda8: 13a03001 movne r3, #1 <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
3000bdac: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bdb0: 0a000001 beq 3000bdbc <_Heap_Walk+0x2f8> <== NOT EXECUTED 3000bdb4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bdb8: 1a00008a bne 3000bfe8 <_Heap_Walk+0x524> <== NOT EXECUTED
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
3000bdbc: e59d2028 ldr r2, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bdc0: e1520007 cmp r2, r7 <== NOT EXECUTED 3000bdc4: 9a000001 bls 3000bdd0 <_Heap_Walk+0x30c> <== NOT EXECUTED 3000bdc8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bdcc: 1a00008e bne 3000c00c <_Heap_Walk+0x548> <== NOT EXECUTED
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
3000bdd0: e1560005 cmp r6, r5 <== NOT EXECUTED 3000bdd4: 3a000001 bcc 3000bde0 <_Heap_Walk+0x31c> <== NOT EXECUTED 3000bdd8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bddc: 1a000094 bne 3000c034 <_Heap_Walk+0x570> <== 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;
3000bde0: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 3000bde4: e20bb001 and fp, fp, #1 <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
3000bde8: e3130001 tst r3, #1 <== NOT EXECUTED 3000bdec: 0a000018 beq 3000be54 <_Heap_Walk+0x390> <== NOT EXECUTED
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
3000bdf0: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000bdf4: 0a00000c beq 3000be2c <_Heap_Walk+0x368> <== NOT EXECUTED
(*printer)(
3000bdf8: e58d7000 str r7, [sp] <== NOT EXECUTED 3000bdfc: e1a0000a mov r0, sl <== NOT EXECUTED 3000be00: e3a01000 mov r1, #0 <== NOT EXECUTED 3000be04: e59f22cc ldr r2, [pc, #716] ; 3000c0d8 <_Heap_Walk+0x614> <== NOT EXECUTED 3000be08: e1a03006 mov r3, r6 <== NOT EXECUTED 3000be0c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000be10: e12fff19 bx r9 <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000be14: e1580005 cmp r8, r5 <== NOT EXECUTED 3000be18: 0affff3c beq 3000bb10 <_Heap_Walk+0x4c> <== NOT EXECUTED 3000be1c: e595b004 ldr fp, [r5, #4] <== NOT EXECUTED 3000be20: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000be24: e1a06005 mov r6, r5 <== NOT EXECUTED 3000be28: eaffffc9 b 3000bd54 <_Heap_Walk+0x290> <== NOT EXECUTED
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
3000be2c: e58d7000 str r7, [sp] <== NOT EXECUTED 3000be30: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000be34: e1a0000a mov r0, sl <== NOT EXECUTED 3000be38: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000be3c: e1a0100b mov r1, fp <== NOT EXECUTED 3000be40: e59f2294 ldr r2, [pc, #660] ; 3000c0dc <_Heap_Walk+0x618> <== NOT EXECUTED 3000be44: e1a03006 mov r3, r6 <== NOT EXECUTED 3000be48: e1a0e00f mov lr, pc <== NOT EXECUTED 3000be4c: e12fff19 bx r9 <== NOT EXECUTED 3000be50: eaffffef b 3000be14 <_Heap_Walk+0x350> <== 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 ?
3000be54: e596200c ldr r2, [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)(
3000be58: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000be5c: e594100c ldr r1, [r4, #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)(
3000be60: e1530002 cmp r3, r2 <== NOT EXECUTED 3000be64: 059f0274 ldreq r0, [pc, #628] ; 3000c0e0 <_Heap_Walk+0x61c><== NOT EXECUTED 3000be68: 0a000003 beq 3000be7c <_Heap_Walk+0x3b8> <== NOT EXECUTED
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
3000be6c: e59f3270 ldr r3, [pc, #624] ; 3000c0e4 <_Heap_Walk+0x620> <== NOT EXECUTED 3000be70: e1540002 cmp r4, r2 <== NOT EXECUTED 3000be74: e59f026c ldr r0, [pc, #620] ; 3000c0e8 <_Heap_Walk+0x624> <== NOT EXECUTED 3000be78: 01a00003 moveq r0, r3 <== NOT EXECUTED
block->next,
block->next == last_free_block ?
3000be7c: e5963008 ldr r3, [r6, #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)(
3000be80: e1510003 cmp r1, r3 <== NOT EXECUTED 3000be84: 059f1260 ldreq r1, [pc, #608] ; 3000c0ec <_Heap_Walk+0x628><== NOT EXECUTED 3000be88: 0a000003 beq 3000be9c <_Heap_Walk+0x3d8> <== 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)" : "")
3000be8c: e59fc25c ldr ip, [pc, #604] ; 3000c0f0 <_Heap_Walk+0x62c> <== NOT EXECUTED 3000be90: e1540003 cmp r4, r3 <== NOT EXECUTED 3000be94: e59f124c ldr r1, [pc, #588] ; 3000c0e8 <_Heap_Walk+0x624> <== NOT EXECUTED 3000be98: 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)(
3000be9c: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000bea0: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000bea4: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000bea8: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000beac: e1a03006 mov r3, r6 <== NOT EXECUTED 3000beb0: e58d7000 str r7, [sp] <== NOT EXECUTED 3000beb4: e1a0000a mov r0, sl <== NOT EXECUTED 3000beb8: e3a01000 mov r1, #0 <== NOT EXECUTED 3000bebc: e59f2230 ldr r2, [pc, #560] ; 3000c0f4 <_Heap_Walk+0x630> <== NOT EXECUTED 3000bec0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bec4: e12fff19 bx r9 <== NOT EXECUTED
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
3000bec8: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000becc: e1570003 cmp r7, r3 <== NOT EXECUTED 3000bed0: 1a000028 bne 3000bf78 <_Heap_Walk+0x4b4> <== NOT EXECUTED
);
return false;
}
if ( !prev_used ) {
3000bed4: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000bed8: 0a000031 beq 3000bfa4 <_Heap_Walk+0x4e0> <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bedc: e5943008 ldr r3, [r4, #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 ) {
3000bee0: e1540003 cmp r4, r3 <== NOT EXECUTED 3000bee4: 0a000004 beq 3000befc <_Heap_Walk+0x438> <== NOT EXECUTED
if ( free_block == block ) {
3000bee8: e1560003 cmp r6, r3 <== NOT EXECUTED 3000beec: 0affffc8 beq 3000be14 <_Heap_Walk+0x350> <== NOT EXECUTED
return true;
}
free_block = free_block->next;
3000bef0: 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 ) {
3000bef4: e1540003 cmp r4, r3 <== NOT EXECUTED 3000bef8: 1afffffa bne 3000bee8 <_Heap_Walk+0x424> <== NOT EXECUTED
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
3000befc: e1a0000a mov r0, sl <== NOT EXECUTED 3000bf00: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bf04: e59f21ec ldr r2, [pc, #492] ; 3000c0f8 <_Heap_Walk+0x634> <== NOT EXECUTED 3000bf08: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bf0c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf10: e12fff19 bx r9 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000bf14: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bf18: eafffefd b 3000bb14 <_Heap_Walk+0x50> <== 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;
3000bf1c: e155000b cmp r5, fp <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bf20: e2850008 add r0, r5, #8 <== NOT EXECUTED 3000bf24: e1a01007 mov r1, r7 <== 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;
3000bf28: 8affff7d bhi 3000bd24 <_Heap_Walk+0x260> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bf2c: ebffe463 bl 300050c0 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000bf30: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bf34: 1a000048 bne 3000c05c <_Heap_Walk+0x598> <== 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;
3000bf38: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000bf3c: e1a02006 mov r2, r6 <== NOT EXECUTED 3000bf40: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bf44: e0833005 add r3, r3, r5 <== 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;
3000bf48: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000bf4c: e1a06005 mov r6, r5 <== NOT EXECUTED 3000bf50: e3130001 tst r3, #1 <== NOT EXECUTED 3000bf54: 0affff6a beq 3000bd04 <_Heap_Walk+0x240> <== NOT EXECUTED
(*printer)(
3000bf58: e1a0000a mov r0, sl <== NOT EXECUTED 3000bf5c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bf60: e59f2194 ldr r2, [pc, #404] ; 3000c0fc <_Heap_Walk+0x638> <== NOT EXECUTED 3000bf64: e1a03005 mov r3, r5 <== NOT EXECUTED 3000bf68: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf6c: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bf70: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bf74: eafffee6 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
3000bf78: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000bf7c: e1a0000a mov r0, sl <== NOT EXECUTED 3000bf80: e58d7000 str r7, [sp] <== NOT EXECUTED 3000bf84: e58d5008 str r5, [sp, #8] <== NOT EXECUTED 3000bf88: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bf8c: e59f216c ldr r2, [pc, #364] ; 3000c100 <_Heap_Walk+0x63c> <== NOT EXECUTED 3000bf90: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bf94: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf98: e12fff19 bx r9 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000bf9c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bfa0: eafffedb b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !prev_used ) {
(*printer)(
3000bfa4: e1a0000a mov r0, sl <== NOT EXECUTED 3000bfa8: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bfac: e59f2150 ldr r2, [pc, #336] ; 3000c104 <_Heap_Walk+0x640> <== NOT EXECUTED 3000bfb0: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bfb4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bfb8: e12fff19 bx r9 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000bfbc: e1a0000b mov r0, fp <== NOT EXECUTED 3000bfc0: eafffed3 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
3000bfc4: e1a0000a mov r0, sl <== NOT EXECUTED 3000bfc8: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bfcc: e59f2134 ldr r2, [pc, #308] ; 3000c108 <_Heap_Walk+0x644> <== NOT EXECUTED 3000bfd0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bfd4: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bfd8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bfdc: eafffecc b 3000bb14 <_Heap_Walk+0x50> <== 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;
3000bfe0: e1a05006 mov r5, r6 <== NOT EXECUTED 3000bfe4: eaffff4e b 3000bd24 <_Heap_Walk+0x260> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
3000bfe8: e1a0000a mov r0, sl <== NOT EXECUTED 3000bfec: e58d7000 str r7, [sp] <== NOT EXECUTED 3000bff0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bff4: e59f2110 ldr r2, [pc, #272] ; 3000c10c <_Heap_Walk+0x648> <== NOT EXECUTED 3000bff8: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bffc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c000: e12fff19 bx r9 <== NOT EXECUTED
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
3000c004: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c008: eafffec1 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
3000c00c: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000c010: e1a0000a mov r0, sl <== NOT EXECUTED 3000c014: e58d7000 str r7, [sp] <== NOT EXECUTED 3000c018: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c01c: e59f20ec ldr r2, [pc, #236] ; 3000c110 <_Heap_Walk+0x64c> <== NOT EXECUTED 3000c020: e1a03006 mov r3, r6 <== NOT EXECUTED 3000c024: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c028: e12fff19 bx r9 <== NOT EXECUTED
block,
block_size,
min_block_size
);
return false;
3000c02c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c030: eafffeb7 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
3000c034: e1a0000a mov r0, sl <== NOT EXECUTED 3000c038: e58d5000 str r5, [sp] <== NOT EXECUTED 3000c03c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c040: e59f20cc ldr r2, [pc, #204] ; 3000c114 <_Heap_Walk+0x650> <== NOT EXECUTED 3000c044: e1a03006 mov r3, r6 <== NOT EXECUTED 3000c048: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c04c: e12fff19 bx r9 <== NOT EXECUTED
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
3000c050: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c054: eafffeae b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
);
return false;
}
if (
3000c058: e1a05006 mov r5, r6 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
3000c05c: e1a0000a mov r0, sl <== NOT EXECUTED 3000c060: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c064: e59f20ac ldr r2, [pc, #172] ; 3000c118 <_Heap_Walk+0x654> <== NOT EXECUTED 3000c068: e1a03005 mov r3, r5 <== NOT EXECUTED 3000c06c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c070: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c074: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c078: eafffea5 b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( free_block->prev != prev_block ) {
(*printer)(
3000c07c: e58d1000 str r1, [sp] <== NOT EXECUTED 3000c080: e1a0000a mov r0, sl <== NOT EXECUTED 3000c084: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c088: e59f208c ldr r2, [pc, #140] ; 3000c11c <_Heap_Walk+0x658> <== NOT EXECUTED 3000c08c: e1a03006 mov r3, r6 <== NOT EXECUTED 3000c090: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c094: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c098: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c09c: eafffe9c b 3000bb14 <_Heap_Walk+0x50> <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000c0a0: e1a05006 mov r5, r6 <== NOT EXECUTED 3000c0a4: eaffffab b 3000bf58 <_Heap_Walk+0x494> <== NOT EXECUTED
3000ba6c <_Heap_Walk_print>:
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
3000ba6c: e92d000c push {r2, r3} <== NOT EXECUTED
3000ba70: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
va_list ap;
if ( error ) {
3000ba74: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
{
/* Do nothing */
}
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
3000ba78: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000ba7c: e1a01000 mov r1, r0 <== NOT EXECUTED
va_list ap;
if ( error ) {
3000ba80: 1a00000a bne 3000bab0 <_Heap_Walk_print+0x44> <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
3000ba84: e59f0030 ldr r0, [pc, #48] ; 3000babc <_Heap_Walk_print+0x50><== NOT EXECUTED 3000ba88: ebfff02d bl 30007b44 <printk> <== NOT EXECUTED
}
va_start( ap, fmt );
3000ba8c: e28d300c add r3, sp, #12 <== NOT EXECUTED
vprintk( fmt, ap );
3000ba90: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 3000ba94: e1a01003 mov r1, r3 <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
3000ba98: e58d3000 str r3, [sp] <== NOT EXECUTED
vprintk( fmt, ap );
3000ba9c: ebfff7b9 bl 30009988 <vprintk> <== NOT EXECUTED
va_end( ap ); }
3000baa0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000baa4: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
3000baa8: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000baac: e12fff1e bx lr <== NOT EXECUTED
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
va_list ap;
if ( error ) {
printk( "FAIL[%d]: ", source );
3000bab0: e59f0008 ldr r0, [pc, #8] ; 3000bac0 <_Heap_Walk_print+0x54><== NOT EXECUTED 3000bab4: ebfff022 bl 30007b44 <printk> <== NOT EXECUTED 3000bab8: eafffff3 b 3000ba8c <_Heap_Walk_print+0x20> <== NOT EXECUTED
3000ba60 <_Heap_Walk_print_nothing>:
int source,
bool error,
const char *fmt,
...
)
{
3000ba60: e92d000c push {r2, r3} <== NOT EXECUTED
/* Do nothing */ }
3000ba64: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000ba68: e12fff1e bx lr <== NOT EXECUTED
3000ae70 <_Internal_error_Occurred>:
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
3000ae70: e59f303c ldr r3, [pc, #60] ; 3000aeb4 <_Internal_error_Occurred+0x44>
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000ae74: e201c0ff and ip, r1, #255 ; 0xff
3000ae78: e52de004 push {lr} ; (str lr, [sp, #-4]!)
_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 );
3000ae7c: e1a0100c mov r1, ip
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
3000ae80: e5830000 str r0, [r3]
_Internal_errors_What_happened.is_internal = is_internal;
3000ae84: e5c3c004 strb ip, [r3, #4]
_Internal_errors_What_happened.the_error = the_error;
3000ae88: e5832008 str r2, [r3, #8]
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000ae8c: 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 );
3000ae90: eb0007d1 bl 3000cddc <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
3000ae94: e59f301c ldr r3, [pc, #28] ; 3000aeb8 <_Internal_error_Occurred+0x48><== NOT EXECUTED 3000ae98: e3a02005 mov r2, #5 <== NOT EXECUTED 3000ae9c: e5832000 str r2, [r3] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000aea0: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000aea4: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000aea8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
3000aeac: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aeb0: eafffffe b 3000aeb0 <_Internal_error_Occurred+0x40> <== NOT EXECUTED
3000af78 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
3000af78: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000af7c: e5904034 ldr r4, [r0, #52] ; 0x34
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
3000af80: e24dd014 sub sp, sp, #20
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000af84: e3540000 cmp r4, #0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
3000af88: e1a05000 mov r5, r0
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000af8c: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000af90: 0a00009a beq 3000b200 <_Objects_Extend_information+0x288>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
3000af94: e1d081b4 ldrh r8, [r0, #20] 3000af98: e1d0a1b0 ldrh sl, [r0, #16] 3000af9c: e1a01008 mov r1, r8 3000afa0: e1a0000a mov r0, sl 3000afa4: eb0029f5 bl 30015780 <__aeabi_uidiv> 3000afa8: e1a03800 lsl r3, r0, #16
for ( ; block < block_count; block++ ) {
3000afac: e1b03823 lsrs r3, r3, #16
3000afb0: 0a000098 beq 3000b218 <_Objects_Extend_information+0x2a0>
if ( information->object_blocks[ block ] == NULL ) {
3000afb4: e5949000 ldr r9, [r4] 3000afb8: e3590000 cmp r9, #0 3000afbc: 01a01008 moveq r1, r8
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000afc0: 01a06007 moveq r6, r7
index_base = minimum_index; block = 0;
3000afc4: 01a04009 moveq r4, r9
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
3000afc8: 0a00000c beq 3000b000 <_Objects_Extend_information+0x88>
3000afcc: e1a02004 mov r2, r4 3000afd0: e1a01008 mov r1, r8
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000afd4: e1a06007 mov r6, r7
index_base = minimum_index; block = 0;
3000afd8: e3a04000 mov r4, #0 3000afdc: ea000002 b 3000afec <_Objects_Extend_information+0x74>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
3000afe0: e5b29004 ldr r9, [r2, #4]! 3000afe4: e3590000 cmp r9, #0
3000afe8: 0a000004 beq 3000b000 <_Objects_Extend_information+0x88>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
3000afec: e2844001 add r4, r4, #1 3000aff0: e1530004 cmp r3, r4
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
3000aff4: e0866008 add r6, r6, r8
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
3000aff8: 8afffff8 bhi 3000afe0 <_Objects_Extend_information+0x68>
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
3000affc: e3a09001 mov r9, #1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
3000b000: e08aa001 add sl, sl, r1
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
3000b004: e35a0801 cmp sl, #65536 ; 0x10000
3000b008: 2a000062 bcs 3000b198 <_Objects_Extend_information+0x220>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
3000b00c: e5d52012 ldrb r2, [r5, #18]
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
3000b010: e5950018 ldr r0, [r5, #24]
if ( information->auto_extend ) {
3000b014: e3520000 cmp r2, #0
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
3000b018: e0000091 mul r0, r1, r0
if ( information->auto_extend ) {
3000b01c: 1a00005f bne 3000b1a0 <_Objects_Extend_information+0x228>
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
3000b020: e58d3000 str r3, [sp] 3000b024: eb0008b4 bl 3000d2fc <_Workspace_Allocate_or_fatal_error> 3000b028: e59d3000 ldr r3, [sp] 3000b02c: e1a08000 mov r8, r0
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
3000b030: e3590000 cmp r9, #0
3000b034: 0a000038 beq 3000b11c <_Objects_Extend_information+0x1a4>
*/
/*
* Up the block count and maximum
*/
block_count++;
3000b038: e283b001 add fp, r3, #1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
3000b03c: e08b008b add r0, fp, fp, lsl #1
((maximum + minimum_index) * sizeof(Objects_Control *));
3000b040: e08a0000 add r0, sl, r0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
3000b044: e0800007 add r0, r0, r7
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
3000b048: e1a00100 lsl r0, r0, #2 3000b04c: e58d3000 str r3, [sp] 3000b050: eb00089f bl 3000d2d4 <_Workspace_Allocate>
if ( !object_blocks ) {
3000b054: e2509000 subs r9, r0, #0 3000b058: e59d3000 ldr r3, [sp]
3000b05c: 0a000072 beq 3000b22c <_Objects_Extend_information+0x2b4>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
3000b060: e1d521b0 ldrh r2, [r5, #16]
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
3000b064: e089c10b add ip, r9, fp, lsl #2 3000b068: e1570002 cmp r7, r2 3000b06c: e089b18b add fp, r9, fp, lsl #3
3000b070: 3a000050 bcc 3000b1b8 <_Objects_Extend_information+0x240>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
3000b074: e3570000 cmp r7, #0 3000b078: 13a02000 movne r2, #0 3000b07c: 11a0100b movne r1, fp
local_table[ index ] = NULL;
3000b080: 11a00002 movne r0, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
3000b084: 0a000003 beq 3000b098 <_Objects_Extend_information+0x120>
3000b088: e2822001 add r2, r2, #1 3000b08c: e1570002 cmp r7, r2
local_table[ index ] = NULL;
3000b090: e4810004 str r0, [r1], #4
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
3000b094: 8afffffb bhi 3000b088 <_Objects_Extend_information+0x110>
3000b098: e1a03103 lsl r3, r3, #2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
3000b09c: e1d511b4 ldrh r1, [r5, #20]
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
3000b0a0: e3a00000 mov r0, #0
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
3000b0a4: e0861001 add r1, r6, r1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
3000b0a8: e1560001 cmp r6, r1
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
3000b0ac: e7890003 str r0, [r9, r3]
inactive_per_block[block_count] = 0;
3000b0b0: e78c0003 str r0, [ip, r3]
for ( index=index_base ;
3000b0b4: 2a000005 bcs 3000b0d0 <_Objects_Extend_information+0x158>
3000b0b8: e08b2106 add r2, fp, r6, lsl #2
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
3000b0bc: e1a03006 mov r3, r6
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
3000b0c0: e2833001 add r3, r3, #1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
3000b0c4: e1530001 cmp r3, r1
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
3000b0c8: e4820004 str r0, [r2], #4
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
3000b0cc: 3afffffb bcc 3000b0c0 <_Objects_Extend_information+0x148>
3000b0d0: e10f3000 mrs r3, CPSR 3000b0d4: e3832080 orr r2, r3, #128 ; 0x80 3000b0d8: e129f002 msr CPSR_fc, r2
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000b0dc: e5952000 ldr r2, [r5]
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
3000b0e0: e1d510b4 ldrh r1, [r5, #4] 3000b0e4: e1a02c02 lsl r2, r2, #24
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
3000b0e8: e1a0a80a lsl sl, sl, #16 3000b0ec: e3822801 orr r2, r2, #65536 ; 0x10000 3000b0f0: e1a0a82a lsr sl, sl, #16
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000b0f4: e1822d81 orr r2, r2, r1, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000b0f8: e182200a orr r2, r2, sl
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
3000b0fc: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
3000b100: e585c030 str ip, [r5, #48] ; 0x30
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
3000b104: e5859034 str r9, [r5, #52] ; 0x34
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
3000b108: e585b01c str fp, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
3000b10c: e1c5a1b0 strh sl, [r5, #16]
information->maximum_id = _Objects_Build_id(
3000b110: e585200c str r2, [r5, #12]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b114: e129f003 msr CPSR_fc, r3
information->maximum
);
_ISR_Enable( level );
_Workspace_Free( old_tables );
3000b118: eb000873 bl 3000d2ec <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
3000b11c: e5953034 ldr r3, [r5, #52] ; 0x34
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
3000b120: e28d7008 add r7, sp, #8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
3000b124: e7838104 str r8, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
3000b128: e1a01008 mov r1, r8 3000b12c: e1a00007 mov r0, r7 3000b130: e1d521b4 ldrh r2, [r5, #20] 3000b134: e5953018 ldr r3, [r5, #24] 3000b138: eb00129a bl 3000fba8 <_Chain_Initialize>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
3000b13c: e1a04104 lsl r4, r4, #2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
3000b140: e2858020 add r8, r5, #32
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
3000b144: ea000009 b 3000b170 <_Objects_Extend_information+0x1f8> 3000b148: e5953000 ldr r3, [r5]
the_object->id = _Objects_Build_id(
3000b14c: e1d520b4 ldrh r2, [r5, #4] 3000b150: e1a03c03 lsl r3, r3, #24 3000b154: e3833801 orr r3, r3, #65536 ; 0x10000
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000b158: e1833d82 orr r3, r3, r2, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000b15c: e1833006 orr r3, r3, r6 3000b160: e5813008 str r3, [r1, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
3000b164: e1a00008 mov r0, r8 3000b168: ebfffcec bl 3000a520 <_Chain_Append>
index++;
3000b16c: e2866001 add r6, r6, #1
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
3000b170: e1a00007 mov r0, r7 3000b174: ebfffcfc bl 3000a56c <_Chain_Get> 3000b178: e2501000 subs r1, r0, #0
3000b17c: 1afffff1 bne 3000b148 <_Objects_Extend_information+0x1d0>
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
3000b180: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
3000b184: e1d531b4 ldrh r3, [r5, #20] 3000b188: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
3000b18c: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
3000b190: e7813004 str r3, [r1, r4]
information->inactive =
3000b194: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
3000b198: e28dd014 add sp, sp, #20
3000b19c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
3000b1a0: e58d3000 str r3, [sp] 3000b1a4: eb00084a bl 3000d2d4 <_Workspace_Allocate>
if ( !new_object_block )
3000b1a8: e2508000 subs r8, r0, #0 3000b1ac: e59d3000 ldr r3, [sp]
3000b1b0: 1affff9e bne 3000b030 <_Objects_Extend_information+0xb8>
3000b1b4: eafffff7 b 3000b198 <_Objects_Extend_information+0x220>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
3000b1b8: e1a03103 lsl r3, r3, #2
3000b1bc: e5951034 ldr r1, [r5, #52] ; 0x34
3000b1c0: e1a02003 mov r2, r3
3000b1c4: e88d1008 stm sp, {r3, ip}
3000b1c8: eb001dd7 bl 3001292c <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
3000b1cc: e89d1008 ldm sp, {r3, ip}
3000b1d0: e1a0000c mov r0, ip
3000b1d4: e1a02003 mov r2, r3
3000b1d8: e5951030 ldr r1, [r5, #48] ; 0x30
3000b1dc: eb001dd2 bl 3001292c <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
3000b1e0: e1d521b0 ldrh r2, [r5, #16]
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
3000b1e4: e1a0000b mov r0, fp
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
3000b1e8: e0872002 add r2, r7, r2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
3000b1ec: e595101c ldr r1, [r5, #28]
3000b1f0: e1a02102 lsl r2, r2, #2
3000b1f4: eb001dcc bl 3001292c <memcpy>
3000b1f8: e89d1008 ldm sp, {r3, ip}
3000b1fc: eaffffa6 b 3000b09c <_Objects_Extend_information+0x124>
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000b200: e1d0a1b0 ldrh sl, [r0, #16] 3000b204: e1d011b4 ldrh r1, [r0, #20]
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000b208: e1a06007 mov r6, r7
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
3000b20c: e3a09001 mov r9, #1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
3000b210: e1a03004 mov r3, r4 3000b214: eaffff79 b 3000b000 <_Objects_Extend_information+0x88>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
3000b218: e1a01008 mov r1, r8 <== NOT EXECUTED
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000b21c: e1a06007 mov r6, r7 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
3000b220: e3a09001 mov r9, #1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
3000b224: e1a04003 mov r4, r3 <== NOT EXECUTED 3000b228: eaffff74 b 3000b000 <_Objects_Extend_information+0x88> <== NOT EXECUTED
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
3000b22c: e1a00008 mov r0, r8 3000b230: eb00082d bl 3000d2ec <_Workspace_Free>
return;
3000b234: eaffffd7 b 3000b198 <_Objects_Extend_information+0x220>
3000b394 <_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;
3000b394: e590c008 ldr ip, [r0, #8]
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000b398: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* 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 ) {
3000b39c: e1d031b0 ldrh r3, [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;
3000b3a0: e26cc001 rsb ip, ip, #1 3000b3a4: e08c1001 add r1, ip, 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 ) {
3000b3a8: e1510003 cmp r1, r3
/* * 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;
3000b3ac: 83a03001 movhi r3, #1
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000b3b0: e24dd008 sub sp, sp, #8
/* * 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;
3000b3b4: 85823000 strhi r3, [r2]
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
3000b3b8: 83a00000 movhi r0, #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 ) {
3000b3bc: 8a000009 bhi 3000b3e8 <_Objects_Get+0x54>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b3c0: e59f3048 ldr r3, [pc, #72] ; 3000b410 <_Objects_Get+0x7c> 3000b3c4: e593c000 ldr ip, [r3] 3000b3c8: e28cc001 add ip, ip, #1 3000b3cc: e583c000 str ip, [r3]
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000b3d0: e590301c ldr r3, [r0, #28] 3000b3d4: e7930101 ldr r0, [r3, r1, lsl #2] 3000b3d8: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3000b3dc: 13a03000 movne r3, #0 3000b3e0: 15823000 strne r3, [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 ) {
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000b3e4: 0a000001 beq 3000b3f0 <_Objects_Get+0x5c>
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
3000b3e8: e28dd008 add sp, sp, #8
3000b3ec: e8bd8000 pop {pc}
/*
* Valid Id for this API, Class and Node but the object has not
* been allocated yet.
*/
_Thread_Enable_dispatch();
3000b3f0: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 3000b3f4: e58d2000 str r2, [sp] <== NOT EXECUTED 3000b3f8: eb000340 bl 3000c100 <_Thread_Enable_dispatch> <== NOT EXECUTED
*location = OBJECTS_ERROR;
3000b3fc: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000b400: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b404: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3000b408: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3000b40c: eafffff5 b 3000b3e8 <_Objects_Get+0x54> <== NOT EXECUTED
3000b2c0 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000b2c0: e1a01801 lsl r1, r1, #16
3000b2c4: e92d4030 push {r4, r5, lr}
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000b2c8: e1b04821 lsrs r4, r1, #16
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000b2cc: e1a05000 mov r5, r0
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
3000b2d0: 01a00004 moveq r0, r4
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000b2d4: 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 );
3000b2d8: eb0013c2 bl 300101e8 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
3000b2dc: e3500000 cmp r0, #0
3000b2e0: 08bd8030 popeq {r4, r5, pc}
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
3000b2e4: e1500004 cmp r0, r4
3000b2e8: 2a000001 bcs 3000b2f4 <_Objects_Get_information+0x34>
return NULL;
3000b2ec: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
3000b2f0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
3000b2f4: e59f3024 ldr r3, [pc, #36] ; 3000b320 <_Objects_Get_information+0x60>
3000b2f8: e7930105 ldr r0, [r3, r5, lsl #2]
3000b2fc: e3500000 cmp r0, #0
3000b300: 08bd8030 popeq {r4, r5, pc}
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
3000b304: e7900104 ldr r0, [r0, r4, lsl #2]
if ( !info )
3000b308: e3500000 cmp r0, #0
3000b30c: 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 )
3000b310: e1d031b0 ldrh r3, [r0, #16]
return NULL;
3000b314: e3530000 cmp r3, #0
3000b318: 03a00000 moveq r0, #0
3000b31c: e8bd8030 pop {r4, r5, pc}
3000b324 <_Objects_Get_isr_disable>:
{
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000b324: e590c008 ldr ip, [r0, #8]
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
3000b328: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000b32c: e26cc001 rsb ip, ip, #1 3000b330: e08cc001 add ip, ip, r1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b334: e10f4000 mrs r4, CPSR 3000b338: e3841080 orr r1, r4, #128 ; 0x80 3000b33c: e129f001 msr CPSR_fc, r1
_ISR_Disable( level );
if ( information->maximum >= index ) {
3000b340: e1d011b0 ldrh r1, [r0, #16] 3000b344: e15c0001 cmp ip, r1
3000b348: 8a000008 bhi 3000b370 <_Objects_Get_isr_disable+0x4c>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000b34c: e590101c ldr r1, [r0, #28] 3000b350: e791010c ldr r0, [r1, ip, lsl #2] 3000b354: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3000b358: 13a01000 movne r1, #0 3000b35c: 15821000 strne r1, [r2]
*level_p = level;
3000b360: 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 ) {
3000b364: 0a000006 beq 3000b384 <_Objects_Get_isr_disable+0x60>
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
3000b368: e8bd0010 pop {r4}
3000b36c: e12fff1e bx lr
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b370: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
3000b374: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b378: 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;
3000b37c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b380: eafffff8 b 3000b368 <_Objects_Get_isr_disable+0x44> <== NOT EXECUTED 3000b384: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
3000b388: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b38c: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3000b390: eafffff4 b 3000b368 <_Objects_Get_isr_disable+0x44> <== NOT EXECUTED
3000cecc <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
3000cecc: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
3000ced0: e2515000 subs r5, r1, #0 <== NOT EXECUTED
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
3000ced4: e1a04002 mov r4, r2 <== NOT EXECUTED 3000ced8: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
return NULL;
3000cedc: 01a04005 moveq r4, r5 <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
3000cee0: 1a000002 bne 3000cef0 <_Objects_Get_name_as_string+0x24> <== NOT EXECUTED
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
3000cee4: e1a00004 mov r0, r4 <== NOT EXECUTED
3000cee8: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000ceec: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
3000cef0: e3540000 cmp r4, #0 <== NOT EXECUTED 3000cef4: 0afffffa beq 3000cee4 <_Objects_Get_name_as_string+0x18> <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000cef8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000cefc: 059f30ec ldreq r3, [pc, #236] ; 3000cff0 <_Objects_Get_name_as_string+0x124><== NOT EXECUTED 3000cf00: 11a07000 movne r7, r0 <== NOT EXECUTED 3000cf04: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000cf08: 05937008 ldreq r7, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3000cf0c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000cf10: ebffffb3 bl 3000cde4 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
3000cf14: e2506000 subs r6, r0, #0 <== NOT EXECUTED
return NULL;
3000cf18: 01a04006 moveq r4, r6 <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
information = _Objects_Get_information_id( tmpId );
if ( !information )
3000cf1c: 0afffff0 beq 3000cee4 <_Objects_Get_name_as_string+0x18> <== NOT EXECUTED
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
3000cf20: e1a01007 mov r1, r7 <== NOT EXECUTED 3000cf24: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000cf28: eb000032 bl 3000cff8 <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3000cf2c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3000cf30: e3530000 cmp r3, #0 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
3000cf34: 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 ) {
3000cf38: 1affffe9 bne 3000cee4 <_Objects_Get_name_as_string+0x18> <== NOT EXECUTED
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
3000cf3c: e5d62038 ldrb r2, [r6, #56] ; 0x38 <== NOT EXECUTED 3000cf40: e3520000 cmp r2, #0 <== NOT EXECUTED 3000cf44: 0a00001c beq 3000cfbc <_Objects_Get_name_as_string+0xf0> <== NOT EXECUTED
s = the_object->name.name_p;
3000cf48: e590c00c ldr ip, [r0, #12] <== NOT EXECUTED
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
3000cf4c: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000cf50: 0a000024 beq 3000cfe8 <_Objects_Get_name_as_string+0x11c> <== NOT EXECUTED
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000cf54: e2555001 subs r5, r5, #1 <== NOT EXECUTED 3000cf58: 0a000022 beq 3000cfe8 <_Objects_Get_name_as_string+0x11c> <== NOT EXECUTED 3000cf5c: e5dc3000 ldrb r3, [ip] <== NOT EXECUTED 3000cf60: e3530000 cmp r3, #0 <== NOT EXECUTED 3000cf64: 0a00001f beq 3000cfe8 <_Objects_Get_name_as_string+0x11c> <== NOT EXECUTED 3000cf68: e59fe084 ldr lr, [pc, #132] ; 3000cff4 <_Objects_Get_name_as_string+0x128><== NOT EXECUTED 3000cf6c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000cf70: e3a02000 mov r2, #0 <== NOT EXECUTED 3000cf74: ea000002 b 3000cf84 <_Objects_Get_name_as_string+0xb8> <== NOT EXECUTED 3000cf78: e5fc3001 ldrb r3, [ip, #1]! <== NOT EXECUTED 3000cf7c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000cf80: 0a000009 beq 3000cfac <_Objects_Get_name_as_string+0xe0> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
3000cf84: e59e0000 ldr r0, [lr] <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000cf88: e2822001 add r2, r2, #1 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
3000cf8c: e0800003 add r0, r0, r3 <== NOT EXECUTED 3000cf90: e5d00001 ldrb r0, [r0, #1] <== NOT EXECUTED 3000cf94: e3100097 tst r0, #151 ; 0x97 <== NOT EXECUTED 3000cf98: 03a0302a moveq r3, #42 ; 0x2a <== NOT EXECUTED 3000cf9c: e4c13001 strb r3, [r1], #1 <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000cfa0: e1520005 cmp r2, r5 <== NOT EXECUTED 3000cfa4: e1a00001 mov r0, r1 <== NOT EXECUTED 3000cfa8: 3afffff2 bcc 3000cf78 <_Objects_Get_name_as_string+0xac> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
3000cfac: e3a03000 mov r3, #0 <== NOT EXECUTED 3000cfb0: e5c03000 strb r3, [r0] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000cfb4: eb000348 bl 3000dcdc <_Thread_Enable_dispatch> <== NOT EXECUTED
return name;
3000cfb8: eaffffc9 b 3000cee4 <_Objects_Get_name_as_string+0x18> <== 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;
3000cfbc: 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';
3000cfc0: 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;
3000cfc4: e1a00c23 lsr r0, r3, #24 <== NOT EXECUTED
lname[ 1 ] = (u32_name >> 16) & 0xff;
3000cfc8: e1a01823 lsr r1, r3, #16 <== NOT EXECUTED
lname[ 2 ] = (u32_name >> 8) & 0xff;
3000cfcc: e1a02423 lsr r2, r3, #8 <== NOT EXECUTED
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
3000cfd0: e5cd0000 strb r0, [sp] <== NOT EXECUTED
lname[ 1 ] = (u32_name >> 16) & 0xff;
3000cfd4: e5cd1001 strb r1, [sp, #1] <== NOT EXECUTED
lname[ 2 ] = (u32_name >> 8) & 0xff;
3000cfd8: e5cd2002 strb r2, [sp, #2] <== NOT EXECUTED
lname[ 3 ] = (u32_name >> 0) & 0xff;
3000cfdc: e5cd3003 strb r3, [sp, #3] <== NOT EXECUTED
lname[ 4 ] = '\0';
s = lname;
3000cfe0: e1a0c00d mov ip, sp <== NOT EXECUTED 3000cfe4: eaffffda b 3000cf54 <_Objects_Get_name_as_string+0x88> <== NOT EXECUTED
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000cfe8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cfec: eaffffee b 3000cfac <_Objects_Get_name_as_string+0xe0> <== NOT EXECUTED
3000b558 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
3000b558: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
3000b55c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
3000b560: e1a05002 mov r5, r2 <== NOT EXECUTED 3000b564: e1a08003 mov r8, r3 <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
3000b568: 01a00004 moveq r0, r4 <== NOT EXECUTED
)
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
3000b56c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return NULL;
if ( !location_p )
3000b570: e3520000 cmp r2, #0 <== NOT EXECUTED
return NULL;
3000b574: 01a00002 moveq r0, r2 <== NOT EXECUTED
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
3000b578: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return NULL;
if ( !next_id_p )
3000b57c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b580: 0a000016 beq 3000b5e0 <_Objects_Get_next+0x88> <== NOT EXECUTED
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
3000b584: e1b03801 lsls r3, r1, #16 <== NOT EXECUTED
next_id = information->minimum_id;
3000b588: 05946008 ldreq r6, [r4, #8] <== NOT EXECUTED
else
next_id = id;
3000b58c: 11a06001 movne r6, r1 <== NOT EXECUTED
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
3000b590: e1d4c1b0 ldrh ip, [r4, #16] <== NOT EXECUTED 3000b594: e1a07806 lsl r7, r6, #16 <== NOT EXECUTED 3000b598: e15c0827 cmp ip, r7, lsr #16 <== NOT EXECUTED
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
3000b59c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b5a0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b5a4: e1a02005 mov r2, r5 <== NOT EXECUTED
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
3000b5a8: 3a000006 bcc 3000b5c8 <_Objects_Get_next+0x70> <== NOT EXECUTED
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
3000b5ac: eb00000d bl 3000b5e8 <_Objects_Get> <== NOT EXECUTED
next_id++;
} while (*location_p != OBJECTS_LOCAL);
3000b5b0: e5953000 ldr r3, [r5] <== NOT EXECUTED
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
next_id++;
3000b5b4: e2866001 add r6, r6, #1 <== NOT EXECUTED
} while (*location_p != OBJECTS_LOCAL);
3000b5b8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b5bc: 1afffff3 bne 3000b590 <_Objects_Get_next+0x38> <== NOT EXECUTED
*next_id_p = next_id;
3000b5c0: e5886000 str r6, [r8] <== NOT EXECUTED
return object;
3000b5c4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
{
*location_p = OBJECTS_ERROR;
3000b5c8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b5cc: e5853000 str r3, [r5] <== NOT EXECUTED
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
3000b5d0: e3e03000 mvn r3, #0 <== NOT EXECUTED
return 0;
3000b5d4: e3a00000 mov r0, #0 <== NOT EXECUTED
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
3000b5d8: e5883000 str r3, [r8] <== NOT EXECUTED
return 0;
3000b5dc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
3000b5e0: e1a00003 mov r0, r3 <== NOT EXECUTED
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
3000b5e4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3001cf0c <_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;
3001cf0c: e590c008 ldr ip, [r0, #8]
if ( information->maximum >= index ) {
3001cf10: e1d031b0 ldrh r3, [r0, #16]
/*
* 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;
3001cf14: e26cc001 rsb ip, ip, #1 3001cf18: e08c1001 add r1, ip, r1
if ( information->maximum >= index ) {
3001cf1c: e1510003 cmp r1, r3
3001cf20: 8a000005 bhi 3001cf3c <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3001cf24: e590301c ldr r3, [r0, #28] 3001cf28: e7930101 ldr r0, [r3, r1, lsl #2] 3001cf2c: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3001cf30: 13a03000 movne r3, #0 3001cf34: 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 ) {
3001cf38: 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;
3001cf3c: e3a03001 mov r3, #1 <== NOT EXECUTED 3001cf40: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3001cf44: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3001cf48: e12fff1e bx lr <== NOT EXECUTED
3000caa8 <_Objects_Id_to_name>:
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000caa8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000caac: 059f3084 ldreq r3, [pc, #132] ; 3000cb38 <_Objects_Id_to_name+0x90><== NOT EXECUTED
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
3000cab0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000cab4: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
3000cab8: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000cabc: 05931008 ldreq r1, [r3, #8] <== NOT EXECUTED 3000cac0: 11a01000 movne r1, r0 <== NOT EXECUTED 3000cac4: e1a03c21 lsr r3, r1, #24 <== NOT EXECUTED 3000cac8: 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 )
3000cacc: e2432001 sub r2, r3, #1 <== NOT EXECUTED 3000cad0: e3520002 cmp r2, #2 <== NOT EXECUTED
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
3000cad4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000cad8: 8a00000a bhi 3000cb08 <_Objects_Id_to_name+0x60> <== 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 ] )
3000cadc: e59f2058 ldr r2, [pc, #88] ; 3000cb3c <_Objects_Id_to_name+0x94><== NOT EXECUTED 3000cae0: e7923103 ldr r3, [r2, r3, lsl #2] <== NOT EXECUTED 3000cae4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000cae8: 0a000006 beq 3000cb08 <_Objects_Id_to_name+0x60> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000caec: e1a02da1 lsr r2, r1, #27 <== NOT EXECUTED
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
3000caf0: e7930102 ldr r0, [r3, r2, lsl #2] <== NOT EXECUTED
if ( !information )
3000caf4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000caf8: 0a000002 beq 3000cb08 <_Objects_Id_to_name+0x60> <== NOT EXECUTED
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
3000cafc: e5d04038 ldrb r4, [r0, #56] ; 0x38 <== NOT EXECUTED 3000cb00: e3540000 cmp r4, #0 <== NOT EXECUTED 3000cb04: 0a000002 beq 3000cb14 <_Objects_Id_to_name+0x6c> <== 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;
3000cb08: e3a00003 mov r0, #3 <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
3000cb0c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000cb10: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
3000cb14: e1a0200d mov r2, sp <== NOT EXECUTED 3000cb18: ebffffc2 bl 3000ca28 <_Objects_Get> <== NOT EXECUTED
if ( !the_object )
3000cb1c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000cb20: 0afffff8 beq 3000cb08 <_Objects_Id_to_name+0x60> <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
3000cb24: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000cb28: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000cb2c: eb00033e bl 3000d82c <_Thread_Enable_dispatch> <== NOT EXECUTED
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000cb30: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cb34: eafffff4 b 3000cb0c <_Objects_Id_to_name+0x64> <== NOT EXECUTED
30017a88 <_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
)
{
30017a88: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
Objects_Control *the_object;
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
30017a8c: e2529000 subs r9, r2, #0
Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string(
Objects_Information *information,
const char *name,
Objects_Id *id
)
{
30017a90: e1a0a000 mov sl, r0 30017a94: e1a07001 mov r7, r1
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
30017a98: 03a00002 moveq r0, #2
Objects_Control *the_object;
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
30017a9c: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
return OBJECTS_INVALID_ADDRESS;
if ( !name )
30017aa0: e3510000 cmp r1, #0
30017aa4: 0a000012 beq 30017af4 <_Objects_Name_to_id_string+0x6c>
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
30017aa8: e1da81b0 ldrh r8, [sl, #16] 30017aac: e3580000 cmp r8, #0
30017ab0: 0a000011 beq 30017afc <_Objects_Name_to_id_string+0x74>
for ( index = 1; index <= information->maximum; index++ ) {
30017ab4: e59a601c ldr r6, [sl, #28] <== NOT EXECUTED 30017ab8: e3a04001 mov r4, #1 <== NOT EXECUTED
the_object = information->local_table[ index ];
30017abc: e5b65004 ldr r5, [r6, #4]! <== NOT EXECUTED
continue;
if ( !the_object->name.name_p )
continue;
if (!strncmp( name, the_object->name.name_p, information->name_length)) {
30017ac0: e1a00007 mov r0, r7 <== NOT EXECUTED
if ( information->maximum != 0 ) {
for ( index = 1; index <= information->maximum; index++ ) {
the_object = information->local_table[ index ];
if ( !the_object )
30017ac4: e3550000 cmp r5, #0 <== NOT EXECUTED 30017ac8: 0a000006 beq 30017ae8 <_Objects_Name_to_id_string+0x60> <== NOT EXECUTED
continue;
if ( !the_object->name.name_p )
30017acc: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 30017ad0: e2531000 subs r1, r3, #0 <== NOT EXECUTED 30017ad4: 0a000003 beq 30017ae8 <_Objects_Name_to_id_string+0x60> <== NOT EXECUTED
continue;
if (!strncmp( name, the_object->name.name_p, information->name_length)) {
30017ad8: e1da23ba ldrh r2, [sl, #58] ; 0x3a <== NOT EXECUTED 30017adc: eb000f9b bl 3001b950 <strncmp> <== NOT EXECUTED 30017ae0: e3500000 cmp r0, #0 <== NOT EXECUTED 30017ae4: 0a000006 beq 30017b04 <_Objects_Name_to_id_string+0x7c> <== NOT EXECUTED
if ( !name )
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
for ( index = 1; index <= information->maximum; index++ ) {
30017ae8: e2844001 add r4, r4, #1 <== NOT EXECUTED 30017aec: e1540008 cmp r4, r8 <== NOT EXECUTED 30017af0: 9afffff1 bls 30017abc <_Objects_Name_to_id_string+0x34> <== NOT EXECUTED
if ( !id )
return OBJECTS_INVALID_ADDRESS;
if ( !name )
return OBJECTS_INVALID_NAME;
30017af4: e3a00001 mov r0, #1
30017af8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
}
}
return OBJECTS_INVALID_NAME;
30017afc: e3a00001 mov r0, #1
}
30017b00: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
if ( !the_object->name.name_p )
continue;
if (!strncmp( name, the_object->name.name_p, information->name_length)) {
*id = the_object->id;
30017b04: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 30017b08: e5893000 str r3, [r9] <== NOT EXECUTED
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
30017b0c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
3000b514 <_Objects_Name_to_id_u32>:
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000b514: e3530000 cmp r3, #0
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
3000b518: e92d0030 push {r4, r5}
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
3000b51c: 03a00002 moveq r0, #2
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000b520: 0a000005 beq 3000b53c <_Objects_Name_to_id_u32+0x28>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
3000b524: e3510000 cmp r1, #0
3000b528: 0a000002 beq 3000b538 <_Objects_Name_to_id_u32+0x24>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
3000b52c: e1d051b0 ldrh r5, [r0, #16] 3000b530: e3550000 cmp r5, #0
3000b534: 1a000002 bne 3000b544 <_Objects_Name_to_id_u32+0x30>
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;
3000b538: e3a00001 mov r0, #1
#endif }
3000b53c: e8bd0030 pop {r4, r5}
3000b540: e12fff1e bx lr
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
3000b544: e3720106 cmn r2, #-2147483647 ; 0x80000001 3000b548: 13520000 cmpne r2, #0
3000b54c: 1a00000b bne 3000b580 <_Objects_Name_to_id_u32+0x6c>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000b550: e590c01c ldr ip, [r0, #28] 3000b554: e3a02001 mov r2, #1
the_object = information->local_table[ index ];
3000b558: e5bc0004 ldr r0, [ip, #4]!
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000b55c: e2822001 add r2, r2, #1
the_object = information->local_table[ index ];
if ( !the_object )
3000b560: e3500000 cmp r0, #0
3000b564: 0a000002 beq 3000b574 <_Objects_Name_to_id_u32+0x60>
continue;
if ( name == the_object->name.name_u32 ) {
3000b568: e590400c ldr r4, [r0, #12] 3000b56c: e1540001 cmp r4, r1
3000b570: 0a000005 beq 3000b58c <_Objects_Name_to_id_u32+0x78>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000b574: e1550002 cmp r5, r2
3000b578: 2afffff6 bcs 3000b558 <_Objects_Name_to_id_u32+0x44>
3000b57c: eaffffed b 3000b538 <_Objects_Name_to_id_u32+0x24> <== NOT EXECUTED
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
3000b580: e3520001 cmp r2, #1 <== NOT EXECUTED 3000b584: 1affffeb bne 3000b538 <_Objects_Name_to_id_u32+0x24> <== NOT EXECUTED 3000b588: eafffff0 b 3000b550 <_Objects_Name_to_id_u32+0x3c> <== NOT EXECUTED
the_object = information->local_table[ index ];
if ( !the_object )
continue;
if ( name == the_object->name.name_u32 ) {
*id = the_object->id;
3000b58c: e5902008 ldr r2, [r0, #8]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000b590: 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;
3000b594: e5832000 str r2, [r3]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000b598: eaffffe7 b 3000b53c <_Objects_Name_to_id_u32+0x28>
3000bc2c <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000bc2c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000bc30: e1a05000 mov r5, r0
3000bc34: e1a06001 mov r6, r1
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000bc38: e1a00002 mov r0, r2 3000bc3c: e1d513ba ldrh r1, [r5, #58] ; 0x3a
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000bc40: e1a08002 mov r8, r2
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000bc44: eb002242 bl 30014554 <strnlen>
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
3000bc48: e5d53038 ldrb r3, [r5, #56] ; 0x38
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000bc4c: e1a04000 mov r4, r0
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
3000bc50: e3530000 cmp r3, #0
3000bc54: 1a000017 bne 3000bcb8 <_Objects_Set_name+0x8c>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
3000bc58: e5d82000 ldrb r2, [r8] <== NOT EXECUTED 3000bc5c: e3500001 cmp r0, #1 <== NOT EXECUTED 3000bc60: e1a02c02 lsl r2, r2, #24 <== NOT EXECUTED 3000bc64: 9a00000c bls 3000bc9c <_Objects_Set_name+0x70> <== NOT EXECUTED 3000bc68: e5d83001 ldrb r3, [r8, #1] <== NOT EXECUTED 3000bc6c: e3500002 cmp r0, #2 <== NOT EXECUTED 3000bc70: e1822803 orr r2, r2, r3, lsl #16 <== NOT EXECUTED 3000bc74: 0a000009 beq 3000bca0 <_Objects_Set_name+0x74> <== NOT EXECUTED 3000bc78: e5d83002 ldrb r3, [r8, #2] <== NOT EXECUTED 3000bc7c: e3500003 cmp r0, #3 <== NOT EXECUTED 3000bc80: e1822403 orr r2, r2, r3, lsl #8 <== NOT EXECUTED 3000bc84: 15d83003 ldrbne r3, [r8, #3] <== NOT EXECUTED 3000bc88: 03a03020 moveq r3, #32 <== NOT EXECUTED 3000bc8c: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000bc90: e586300c str r3, [r6, #12] <== NOT EXECUTED
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
3000bc94: e3a00001 mov r0, #1 <== NOT EXECUTED
3000bc98: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
3000bc9c: e3822602 orr r2, r2, #2097152 ; 0x200000 <== NOT EXECUTED 3000bca0: e3822a02 orr r2, r2, #8192 ; 0x2000 <== NOT EXECUTED 3000bca4: e3a03020 mov r3, #32 <== NOT EXECUTED 3000bca8: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000bcac: e586300c str r3, [r6, #12] <== NOT EXECUTED
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
3000bcb0: e3a00001 mov r0, #1 <== NOT EXECUTED
3000bcb4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
3000bcb8: e2800001 add r0, r0, #1 3000bcbc: eb00075d bl 3000da38 <_Workspace_Allocate>
if ( !d )
3000bcc0: e2505000 subs r5, r0, #0
3000bcc4: 0a00000b beq 3000bcf8 <_Objects_Set_name+0xcc>
return false;
_Workspace_Free( (void *)the_object->name.name_p );
3000bcc8: e596000c ldr r0, [r6, #12] <== NOT EXECUTED
the_object->name.name_p = NULL;
3000bccc: e3a07000 mov r7, #0 <== NOT EXECUTED
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
_Workspace_Free( (void *)the_object->name.name_p );
3000bcd0: eb00075e bl 3000da50 <_Workspace_Free> <== NOT EXECUTED
the_object->name.name_p = NULL;
3000bcd4: e586700c str r7, [r6, #12] <== NOT EXECUTED
strncpy( d, name, length );
3000bcd8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bcdc: e1a01008 mov r1, r8 <== NOT EXECUTED 3000bce0: e1a02004 mov r2, r4 <== NOT EXECUTED 3000bce4: eb0021df bl 30014468 <strncpy> <== NOT EXECUTED
d[length] = '\0';
3000bce8: e7c57004 strb r7, [r5, r4] <== NOT EXECUTED
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
3000bcec: e3a00001 mov r0, #1 <== NOT EXECUTED
_Workspace_Free( (void *)the_object->name.name_p );
the_object->name.name_p = NULL;
strncpy( d, name, length );
d[length] = '\0';
the_object->name.name_p = d;
3000bcf0: e586500c str r5, [r6, #12] <== NOT EXECUTED
3000bcf4: 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;
3000bcf8: e1a00005 mov r0, r5
);
}
return true;
}
3000bcfc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000b59c <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
3000b59c: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
3000b5a0: e1d040b8 ldrh r4, [r0, #8]
block_count = (information->maximum - index_base) /
3000b5a4: e1d051b4 ldrh r5, [r0, #20]
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
3000b5a8: e1a06000 mov r6, r0
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
3000b5ac: e1d001b0 ldrh r0, [r0, #16] 3000b5b0: e1a01005 mov r1, r5 3000b5b4: e0640000 rsb r0, r4, r0 3000b5b8: eb002870 bl 30015780 <__aeabi_uidiv>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
3000b5bc: e3500000 cmp r0, #0
3000b5c0: 08bd80f0 popeq {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
3000b5c4: e5962030 ldr r2, [r6, #48] ; 0x30 3000b5c8: e5923000 ldr r3, [r2] 3000b5cc: e1550003 cmp r5, r3
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
3000b5d0: 13a03000 movne r3, #0
if ( information->inactive_per_block[ block ] ==
3000b5d4: 1a000005 bne 3000b5f0 <_Objects_Shrink_information+0x54>
3000b5d8: ea000008 b 3000b600 <_Objects_Shrink_information+0x64> <== NOT EXECUTED
3000b5dc: e5b21004 ldr r1, [r2, #4]!
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
3000b5e0: e0844005 add r4, r4, r5
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
3000b5e4: e1550001 cmp r5, r1
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
3000b5e8: e1a07103 lsl r7, r3, #2
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
3000b5ec: 0a000004 beq 3000b604 <_Objects_Shrink_information+0x68>
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
3000b5f0: e2833001 add r3, r3, #1 3000b5f4: e1500003 cmp r0, r3
3000b5f8: 8afffff7 bhi 3000b5dc <_Objects_Shrink_information+0x40>
3000b5fc: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
3000b600: e3a07000 mov r7, #0 <== NOT EXECUTED
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
3000b604: e5960020 ldr r0, [r6, #32] 3000b608: ea000002 b 3000b618 <_Objects_Shrink_information+0x7c>
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
3000b60c: e3550000 cmp r5, #0
3000b610: 0a00000b beq 3000b644 <_Objects_Shrink_information+0xa8>
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
3000b614: e1a00005 mov r0, r5
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
3000b618: e1d030b8 ldrh r3, [r0, #8]
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
3000b61c: e5905000 ldr r5, [r0]
if ((index >= index_base) &&
3000b620: e1530004 cmp r3, r4
3000b624: 3afffff8 bcc 3000b60c <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
3000b628: e1d621b4 ldrh r2, [r6, #20] 3000b62c: e0842002 add r2, r4, r2
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
3000b630: e1530002 cmp r3, r2
3000b634: 2afffff4 bcs 3000b60c <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
3000b638: ebfffbc3 bl 3000a54c <_Chain_Extract>
}
}
while ( the_object );
3000b63c: e3550000 cmp r5, #0
3000b640: 1afffff3 bne 3000b614 <_Objects_Shrink_information+0x78>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
3000b644: e5963034 ldr r3, [r6, #52] ; 0x34 3000b648: e7930007 ldr r0, [r3, r7] 3000b64c: eb000726 bl 3000d2ec <_Workspace_Free>
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
3000b650: e1d602bc ldrh r0, [r6, #44] ; 0x2c 3000b654: e1d631b4 ldrh r3, [r6, #20]
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
3000b658: e5961034 ldr r1, [r6, #52] ; 0x34
information->inactive_per_block[ block ] = 0;
3000b65c: e5962030 ldr r2, [r6, #48] ; 0x30
information->inactive -= information->allocation_size;
3000b660: e0633000 rsb r3, r3, r0
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
3000b664: e7815007 str r5, [r1, r7]
information->inactive_per_block[ block ] = 0;
3000b668: e7825007 str r5, [r2, r7]
information->inactive -= information->allocation_size;
3000b66c: e1c632bc strh r3, [r6, #44] ; 0x2c
return;
3000b670: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000c4ac <_POSIX_Absolute_timeout_to_ticks>:
*/
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
{
3000c4ac: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
/*
* Make sure there is always a value returned.
*/
*ticks_out = 0;
3000c4b0: e3a03000 mov r3, #0 <== NOT EXECUTED
*/
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
{
3000c4b4: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
/*
* Make sure there is always a value returned.
*/
*ticks_out = 0;
3000c4b8: 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
)
{
3000c4bc: e1a04001 mov r4, r1 <== NOT EXECUTED 3000c4c0: e1a06000 mov r6, r0 <== NOT EXECUTED
*ticks_out = 0;
/*
* Is the absolute time even valid?
*/
if ( !_Timespec_Is_valid(abstime) )
3000c4c4: eb000ff5 bl 300104a0 <_Timespec_Is_valid> <== NOT EXECUTED 3000c4c8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c4cc: 1a000001 bne 3000c4d8 <_POSIX_Absolute_timeout_to_ticks+0x2c><== NOT EXECUTED
/* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; }
3000c4d0: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000c4d4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
3000c4d8: e28d7008 add r7, sp, #8 <== NOT EXECUTED 3000c4dc: e1a00007 mov r0, r7 <== NOT EXECUTED 3000c4e0: eb00072c bl 3000e198 <_TOD_Get> <== NOT EXECUTED
if ( _Timespec_Less_than( abstime, ¤t_time ) )
3000c4e4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000c4e8: e1a01007 mov r1, r7 <== NOT EXECUTED 3000c4ec: eb000ffc bl 300104e4 <_Timespec_Less_than> <== NOT EXECUTED 3000c4f0: e3500000 cmp r0, #0 <== NOT EXECUTED
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
3000c4f4: 13a00001 movne r0, #1 <== NOT EXECUTED
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
if ( _Timespec_Less_than( abstime, ¤t_time ) )
3000c4f8: 1afffff4 bne 3000c4d0 <_POSIX_Absolute_timeout_to_ticks+0x24><== NOT EXECUTED
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
/*
* How long until the requested absolute time?
*/
_Timespec_Subtract( ¤t_time, abstime, &difference );
3000c4fc: e1a00007 mov r0, r7 <== NOT EXECUTED 3000c500: e1a01006 mov r1, r6 <== NOT EXECUTED 3000c504: e1a0200d mov r2, sp <== NOT EXECUTED 3000c508: eb001003 bl 3001051c <_Timespec_Subtract> <== NOT EXECUTED
/*
* Internally the SuperCore uses ticks, so convert to them.
*/
*ticks_out = _Timespec_To_ticks( &difference );
3000c50c: e1a0000d mov r0, sp <== NOT EXECUTED 3000c510: eb001017 bl 30010574 <_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;
3000c514: 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 );
3000c518: 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 );
3000c51c: 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;
3000c520: 13a00003 movne r0, #3 <== NOT EXECUTED 3000c524: 03a00002 moveq r0, #2 <== NOT EXECUTED 3000c528: eaffffe8 b 3000c4d0 <_POSIX_Absolute_timeout_to_ticks+0x24><== NOT EXECUTED
30010494 <_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];
30010494: e59f3004 ldr r3, [pc, #4] ; 300104a0 <_POSIX_Barrier_Translate_core_barrier_return_code+0xc><== NOT EXECUTED
}
30010498: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3001049c: e12fff1e bx lr <== NOT EXECUTED
3000accc <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
3000accc: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3000acd0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000acd4: e1a04001 mov r4, r1 <== NOT EXECUTED
3000acd8: e1a06000 mov r6, r0 <== NOT EXECUTED
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
3000acdc: e1a00001 mov r0, r1 <== NOT EXECUTED 3000ace0: e1a0100d mov r1, sp <== NOT EXECUTED
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
3000ace4: e1a08002 mov r8, r2 <== NOT EXECUTED 3000ace8: e20370ff and r7, 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 ) ) {
3000acec: eb000059 bl 3000ae58 <_POSIX_Mutex_Get> <== NOT EXECUTED 3000acf0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000acf4: 0a00000a beq 3000ad24 <_POSIX_Condition_variables_Wait_support+0x58><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000acf8: e59f30d4 ldr r3, [pc, #212] ; 3000add4 <_POSIX_Condition_variables_Wait_support+0x108><== NOT EXECUTED
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000acfc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ad00: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000ad04: e1a0100d mov r1, sp <== NOT EXECUTED 3000ad08: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000ad0c: e5832000 str r2, [r3] <== NOT EXECUTED 3000ad10: ebffff74 bl 3000aae8 <_POSIX_Condition_variables_Get> <== NOT EXECUTED
switch ( location ) {
3000ad14: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000ad18: e1a0a000 mov sl, r0 <== NOT EXECUTED
switch ( location ) {
3000ad1c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ad20: 0a000003 beq 3000ad34 <_POSIX_Condition_variables_Wait_support+0x68><== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000ad24: e3a05016 mov r5, #22 <== NOT EXECUTED
}
3000ad28: e1a00005 mov r0, r5 <== NOT EXECUTED
3000ad2c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000ad30: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
the_cond = _POSIX_Condition_variables_Get( cond, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
3000ad34: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000ad38: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ad3c: 0a000005 beq 3000ad58 <_POSIX_Condition_variables_Wait_support+0x8c><== NOT EXECUTED 3000ad40: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000ad44: e1530002 cmp r3, r2 <== NOT EXECUTED 3000ad48: 0a000002 beq 3000ad58 <_POSIX_Condition_variables_Wait_support+0x8c><== NOT EXECUTED
_Thread_Enable_dispatch();
3000ad4c: eb000d8d bl 3000e388 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EINVAL;
3000ad50: e3a05016 mov r5, #22 <== NOT EXECUTED 3000ad54: eafffff3 b 3000ad28 <_POSIX_Condition_variables_Wait_support+0x5c><== NOT EXECUTED
}
(void) pthread_mutex_unlock( mutex );
3000ad58: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ad5c: eb0000e3 bl 3000b0f0 <pthread_mutex_unlock> <== NOT EXECUTED
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
3000ad60: e3570000 cmp r7, #0 <== NOT EXECUTED 3000ad64: 0a000006 beq 3000ad84 <_POSIX_Condition_variables_Wait_support+0xb8><== NOT EXECUTED
status = _Thread_Executing->Wait.return_code;
if ( status == EINTR )
status = 0;
} else {
_Thread_Enable_dispatch();
3000ad68: eb000d86 bl 3000e388 <_Thread_Enable_dispatch> <== NOT EXECUTED
status = ETIMEDOUT;
3000ad6c: e3a05074 mov r5, #116 ; 0x74 <== NOT EXECUTED
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
3000ad70: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ad74: eb0000bc bl 3000b06c <pthread_mutex_lock> <== NOT EXECUTED
if ( mutex_status )
return EINVAL;
3000ad78: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ad7c: 13a05016 movne r5, #22 <== NOT EXECUTED 3000ad80: eaffffe8 b 3000ad28 <_POSIX_Condition_variables_Wait_support+0x5c><== NOT EXECUTED
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000ad84: e59f504c ldr r5, [pc, #76] ; 3000add8 <_POSIX_Condition_variables_Wait_support+0x10c><== NOT EXECUTED
return EINVAL;
}
*/
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
3000ad88: e5942000 ldr r2, [r4] <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000ad8c: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
return EINVAL;
}
*/
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
3000ad90: e58a2014 str r2, [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;
3000ad94: e3a02001 mov r2, #1 <== NOT EXECUTED 3000ad98: e58a2048 str r2, [sl, #72] ; 0x48 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
3000ad9c: e5837034 str r7, [r3, #52] ; 0x34 <== NOT EXECUTED
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
_Thread_Executing->Wait.id = *cond;
3000ada0: e5962000 ldr r2, [r6] <== 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;
3000ada4: e28a0018 add r0, sl, #24 <== NOT EXECUTED
_Thread_Executing->Wait.id = *cond;
3000ada8: e5832020 str r2, [r3, #32] <== 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;
3000adac: e5830044 str r0, [r3, #68] ; 0x44 <== NOT EXECUTED
_Thread_Executing->Wait.id = *cond;
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
3000adb0: e1a01008 mov r1, r8 <== NOT EXECUTED 3000adb4: e59f2020 ldr r2, [pc, #32] ; 3000addc <_POSIX_Condition_variables_Wait_support+0x110><== NOT EXECUTED 3000adb8: eb000e9e bl 3000e838 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000adbc: eb000d71 bl 3000e388 <_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;
3000adc0: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 3000adc4: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
if ( status == EINTR )
status = 0;
3000adc8: e3550004 cmp r5, #4 <== NOT EXECUTED 3000adcc: 03a05000 moveq r5, #0 <== NOT EXECUTED 3000add0: eaffffe6 b 3000ad70 <_POSIX_Condition_variables_Wait_support+0xa4><== NOT EXECUTED
30011804 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
30011804: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
30011808: e5907008 ldr r7, [r0, #8] 3001180c: e59f5084 ldr r5, [pc, #132] ; 30011898 <_POSIX_Keys_Run_destructors+0x94> 30011810: e1a0ac27 lsr sl, 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 ];
30011814: e1a07807 lsl r7, r7, #16 30011818: e20aa007 and sl, sl, #7 3001181c: e1a07727 lsr r7, r7, #14
if ( value != NULL ) {
key->Values [ thread_api ][ thread_index ] = NULL;
30011820: e3a08000 mov r8, #0
*
* 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;
30011824: e1d541b0 ldrh r4, [r5, #16]
done = true;
for ( index = 1 ; index <= max ; ++index ) {
30011828: e3540000 cmp r4, #0
3001182c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
30011830: e3a06001 mov r6, #1 <== NOT EXECUTED 30011834: e1a01006 mov r1, r6 <== NOT EXECUTED
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
30011838: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
3001183c: e28a0005 add r0, sl, #5 <== NOT EXECUTED
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
30011840: e7932106 ldr r2, [r3, r6, lsl #2] <== NOT EXECUTED
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
30011844: e3520000 cmp r2, #0 <== NOT EXECUTED 30011848: 0a00000a beq 30011878 <_POSIX_Keys_Run_destructors+0x74> <== NOT EXECUTED 3001184c: e5923010 ldr r3, [r2, #16] <== NOT EXECUTED 30011850: e3530000 cmp r3, #0 <== NOT EXECUTED 30011854: 0a000007 beq 30011878 <_POSIX_Keys_Run_destructors+0x74> <== NOT EXECUTED
void *value = key->Values [ thread_api ][ thread_index ];
30011858: e7922100 ldr r2, [r2, r0, lsl #2] <== NOT EXECUTED 3001185c: e7920007 ldr r0, [r2, r7] <== NOT EXECUTED
if ( value != NULL ) {
30011860: e3500000 cmp r0, #0 <== NOT EXECUTED 30011864: 0a000003 beq 30011878 <_POSIX_Keys_Run_destructors+0x74> <== NOT EXECUTED
key->Values [ thread_api ][ thread_index ] = NULL;
30011868: e7828007 str r8, [r2, r7] <== NOT EXECUTED
(*key->destructor)( value );
3001186c: e1a0e00f mov lr, pc <== NOT EXECUTED 30011870: e12fff13 bx r3 <== NOT EXECUTED
done = false;
30011874: e1a01008 mov r1, r8 <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
30011878: e2866001 add r6, r6, #1 <== NOT EXECUTED 3001187c: e1a06806 lsl r6, r6, #16 <== NOT EXECUTED 30011880: e1a06826 lsr r6, r6, #16 <== NOT EXECUTED 30011884: e1540006 cmp r4, r6 <== NOT EXECUTED 30011888: 2affffea bcs 30011838 <_POSIX_Keys_Run_destructors+0x34> <== NOT EXECUTED
* 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 ) {
3001188c: e3510000 cmp r1, #0 <== NOT EXECUTED
30011890: 0affffe3 beq 30011824 <_POSIX_Keys_Run_destructors+0x20> <== NOT EXECUTED
30011894: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30016160 <_POSIX_Message_queue_Create_support>:
const char *name_arg,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
30016160: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
30016164: e1a06001 mov r6, r1 <== NOT EXECUTED
30016168: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
CORE_message_queue_Attributes *the_mq_attr;
struct mq_attr attr;
char *name;
size_t n;
n = strnlen( name_arg, NAME_MAX );
3001616c: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
const char *name_arg,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
30016170: e1a04002 mov r4, r2 <== NOT EXECUTED 30016174: e58d3000 str r3, [sp] <== NOT EXECUTED 30016178: e1a0a000 mov sl, 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 );
3001617c: eb00168f bl 3001bbc0 <strnlen> <== NOT EXECUTED 30016180: e59f314c ldr r3, [pc, #332] ; 300162d4 <_POSIX_Message_queue_Create_support+0x174><== NOT EXECUTED 30016184: e1a0b000 mov fp, r0 <== NOT EXECUTED 30016188: e5932000 ldr r2, [r3] <== NOT EXECUTED 3001618c: e2822001 add r2, r2, #1 <== NOT EXECUTED 30016190: 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 ) {
30016194: e3540000 cmp r4, #0 <== NOT EXECUTED 30016198: 0a00002a beq 30016248 <_POSIX_Message_queue_Create_support+0xe8><== NOT EXECUTED
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
3001619c: e5947004 ldr r7, [r4, #4] <== NOT EXECUTED 300161a0: e3570000 cmp r7, #0 <== NOT EXECUTED 300161a4: da000035 ble 30016280 <_POSIX_Message_queue_Create_support+0x120><== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
300161a8: e5948008 ldr r8, [r4, #8] <== NOT EXECUTED 300161ac: e3580000 cmp r8, #0 <== NOT EXECUTED 300161b0: da000032 ble 30016280 <_POSIX_Message_queue_Create_support+0x120><== 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 );
300161b4: e59f511c ldr r5, [pc, #284] ; 300162d8 <_POSIX_Message_queue_Create_support+0x178><== NOT EXECUTED 300161b8: e1a00005 mov r0, r5 <== NOT EXECUTED 300161bc: ebffef9f bl 30012040 <_Objects_Allocate> <== NOT EXECUTED
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
300161c0: e2504000 subs r4, r0, #0 <== NOT EXECUTED 300161c4: 0a00003c beq 300162bc <_POSIX_Message_queue_Create_support+0x15c><== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq->process_shared = pshared;
the_mq->named = true;
300161c8: e3a03001 mov r3, #1 <== NOT EXECUTED
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
name = _Workspace_Allocate(n+1);
300161cc: e08bb003 add fp, fp, r3 <== NOT EXECUTED
if ( !the_mq ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq->process_shared = pshared;
300161d0: e5846010 str r6, [r4, #16] <== NOT EXECUTED
the_mq->named = true;
300161d4: e5c43014 strb r3, [r4, #20] <== NOT EXECUTED
the_mq->open_count = 1;
300161d8: e5843018 str r3, [r4, #24] <== NOT EXECUTED
the_mq->linked = true;
300161dc: 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);
300161e0: e1a0000b mov r0, fp <== NOT EXECUTED 300161e4: ebfff8d9 bl 30014550 <_Workspace_Allocate> <== NOT EXECUTED
if (!name) {
300161e8: e2509000 subs r9, r0, #0 <== NOT EXECUTED 300161ec: 0a000029 beq 30016298 <_POSIX_Message_queue_Create_support+0x138><== NOT EXECUTED
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
strncpy( name, name_arg, n+1 );
300161f0: e1a0100a mov r1, sl <== NOT EXECUTED 300161f4: e1a0200b mov r2, fp <== 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;
300161f8: 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 );
300161fc: eb001634 bl 3001bad4 <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;
30016200: e584605c str r6, [r4, #92] ; 0x5c <== NOT EXECUTED
if ( !_CORE_message_queue_Initialize(
30016204: e284001c add r0, r4, #28 <== NOT EXECUTED 30016208: e284105c add r1, r4, #92 ; 0x5c <== NOT EXECUTED 3001620c: e1a02007 mov r2, r7 <== NOT EXECUTED 30016210: e1a03008 mov r3, r8 <== NOT EXECUTED 30016214: eb000427 bl 300172b8 <_CORE_message_queue_Initialize> <== NOT EXECUTED 30016218: e1500006 cmp r0, r6 <== NOT EXECUTED 3001621c: 0a00000c beq 30016254 <_POSIX_Message_queue_Create_support+0xf4><== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30016220: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
30016224: e1d420b8 ldrh r2, [r4, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30016228: e7834102 str r4, [r3, r2, lsl #2] <== NOT EXECUTED
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
3001622c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
30016230: e584900c str r9, [r4, #12] <== NOT EXECUTED 30016234: e5834000 str r4, [r3] <== NOT EXECUTED
_Thread_Enable_dispatch();
30016238: ebfff40c bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3001623c: e1a00006 mov r0, r6 <== NOT EXECUTED
}
30016240: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30016244: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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;
30016248: 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;
3001624c: e3a0700a mov r7, #10 <== NOT EXECUTED 30016250: eaffffd7 b 300161b4 <_POSIX_Message_queue_Create_support+0x54><== 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 );
30016254: e1a01004 mov r1, r4 <== NOT EXECUTED 30016258: e1a00005 mov r0, r5 <== NOT EXECUTED 3001625c: ebfff051 bl 300123a8 <_Objects_Free> <== NOT EXECUTED
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
30016260: e1a00009 mov r0, r9 <== NOT EXECUTED 30016264: ebfff8bf bl 30014568 <_Workspace_Free> <== NOT EXECUTED
_Thread_Enable_dispatch();
30016268: ebfff400 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
3001626c: eb000e3e bl 30019b6c <__errno> <== NOT EXECUTED 30016270: e3a0301c mov r3, #28 <== NOT EXECUTED 30016274: e5803000 str r3, [r0] <== NOT EXECUTED 30016278: e3e00000 mvn r0, #0 <== NOT EXECUTED 3001627c: eaffffef b 30016240 <_POSIX_Message_queue_Create_support+0xe0><== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
_Thread_Enable_dispatch();
30016280: ebfff3fa bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30016284: eb000e38 bl 30019b6c <__errno> <== NOT EXECUTED 30016288: e3a03016 mov r3, #22 <== NOT EXECUTED 3001628c: e5803000 str r3, [r0] <== NOT EXECUTED 30016290: e3e00000 mvn r0, #0 <== NOT EXECUTED 30016294: eaffffe9 b 30016240 <_POSIX_Message_queue_Create_support+0xe0><== NOT EXECUTED 30016298: e1a00005 mov r0, r5 <== NOT EXECUTED 3001629c: e1a01004 mov r1, r4 <== NOT EXECUTED 300162a0: ebfff040 bl 300123a8 <_Objects_Free> <== NOT EXECUTED
* dynamically constructed.
*/
name = _Workspace_Allocate(n+1);
if (!name) {
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
300162a4: ebfff3f1 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
300162a8: eb000e2f bl 30019b6c <__errno> <== NOT EXECUTED 300162ac: e3a0300c mov r3, #12 <== NOT EXECUTED 300162b0: e5803000 str r3, [r0] <== NOT EXECUTED 300162b4: e3e00000 mvn r0, #0 <== NOT EXECUTED 300162b8: eaffffe0 b 30016240 <_POSIX_Message_queue_Create_support+0xe0><== NOT EXECUTED
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
_Thread_Enable_dispatch();
300162bc: ebfff3eb bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENFILE );
300162c0: eb000e29 bl 30019b6c <__errno> <== NOT EXECUTED 300162c4: e3a03017 mov r3, #23 <== NOT EXECUTED 300162c8: e5803000 str r3, [r0] <== NOT EXECUTED 300162cc: e3e00000 mvn r0, #0 <== NOT EXECUTED 300162d0: eaffffda b 30016240 <_POSIX_Message_queue_Create_support+0xe0><== NOT EXECUTED
3000f028 <_POSIX_Message_queue_Delete>:
void _POSIX_Message_queue_Delete(
POSIX_Message_queue_Control *the_mq
)
{
if ( !the_mq->linked && !the_mq->open_count ) {
3000f028: e5d03015 ldrb r3, [r0, #21] <== NOT EXECUTED
*/
void _POSIX_Message_queue_Delete(
POSIX_Message_queue_Control *the_mq
)
{
3000f02c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !the_mq->linked && !the_mq->open_count ) {
3000f030: e3530000 cmp r3, #0 <== NOT EXECUTED
*/
void _POSIX_Message_queue_Delete(
POSIX_Message_queue_Control *the_mq
)
{
3000f034: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( !the_mq->linked && !the_mq->open_count ) {
3000f038: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
3000f03c: e5905018 ldr r5, [r0, #24] <== NOT EXECUTED
3000f040: e3550000 cmp r5, #0 <== NOT EXECUTED
3000f044: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
);
_Workspace_Free( (void *)the_object->name.name_p );
}
#endif
_Objects_Close( &_POSIX_Message_queue_Information, the_object );
3000f048: e1a01000 mov r1, r0 <== NOT EXECUTED 3000f04c: e59f0020 ldr r0, [pc, #32] ; 3000f074 <_POSIX_Message_queue_Delete+0x4c><== NOT EXECUTED 3000f050: eb000c1f bl 300120d4 <_Objects_Close> <== NOT EXECUTED
_CORE_message_queue_Close(
3000f054: e284001c add r0, r4, #28 <== NOT EXECUTED 3000f058: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f05c: e3a02005 mov r2, #5 <== NOT EXECUTED 3000f060: eb0008e8 bl 30011408 <_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 );
3000f064: e59f0008 ldr r0, [pc, #8] ; 3000f074 <_POSIX_Message_queue_Delete+0x4c><== NOT EXECUTED 3000f068: e1a01004 mov r1, r4 <== NOT EXECUTED
);
_POSIX_Message_queue_Free( the_mq );
}
}
3000f06c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
3000f070: ea000ccc b 300123a8 <_Objects_Free> <== NOT EXECUTED
300162dc <_POSIX_Message_queue_Name_to_id>:
*/
int _POSIX_Message_queue_Name_to_id(
const char *name,
Objects_Id *id
)
{
300162dc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
300162e0: e2505000 subs r5, r0, #0 <== NOT EXECUTED
*/
int _POSIX_Message_queue_Name_to_id(
const char *name,
Objects_Id *id
)
{
300162e4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 300162e8: e1a04001 mov r4, r1 <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
300162ec: 0a000002 beq 300162fc <_POSIX_Message_queue_Name_to_id+0x20><== NOT EXECUTED
return EINVAL;
if ( !name[0] )
300162f0: e5d53000 ldrb r3, [r5] <== NOT EXECUTED 300162f4: e3530000 cmp r3, #0 <== NOT EXECUTED 300162f8: 1a000002 bne 30016308 <_POSIX_Message_queue_Name_to_id+0x2c><== NOT EXECUTED
return EINVAL;
300162fc: e3a00016 mov r0, #22 <== NOT EXECUTED
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
30016300: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30016304: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
return EINVAL;
if ( !name[0] )
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
30016308: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 3001630c: eb00162b bl 3001bbc0 <strnlen> <== NOT EXECUTED 30016310: e35000fe cmp r0, #254 ; 0xfe <== NOT EXECUTED
return ENAMETOOLONG;
30016314: 83a0005b movhi r0, #91 ; 0x5b <== NOT EXECUTED
return EINVAL;
if ( !name[0] )
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
30016318: 8afffff8 bhi 30016300 <_POSIX_Message_queue_Name_to_id+0x24><== NOT EXECUTED
return ENAMETOOLONG;
status = _Objects_Name_to_id_string(
3001631c: e59f0020 ldr r0, [pc, #32] ; 30016344 <_POSIX_Message_queue_Name_to_id+0x68><== NOT EXECUTED 30016320: e1a01005 mov r1, r5 <== NOT EXECUTED 30016324: e1a0200d mov r2, sp <== NOT EXECUTED 30016328: eb0005d6 bl 30017a88 <_Objects_Name_to_id_string> <== NOT EXECUTED
&_POSIX_Message_queue_Information,
name,
&the_id
);
*id = the_id;
3001632c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
30016330: e3500000 cmp r0, #0 <== NOT EXECUTED 30016334: 13a00002 movne r0, #2 <== NOT EXECUTED 30016338: 03a00000 moveq r0, #0 <== NOT EXECUTED
status = _Objects_Name_to_id_string(
&_POSIX_Message_queue_Information,
name,
&the_id
);
*id = the_id;
3001633c: e5843000 str r3, [r4] <== NOT EXECUTED 30016340: eaffffee b 30016300 <_POSIX_Message_queue_Name_to_id+0x24> <== NOT EXECUTED
3000f104 <_POSIX_Message_queue_Notify_handler>:
*/
void _POSIX_Message_queue_Notify_handler(
void *user_data
)
{
3000f104: e92d4010 push {r4, lr} <== NOT EXECUTED
3000f108: e1a04000 mov r4, r0 <== NOT EXECUTED
POSIX_Message_queue_Control *the_mq;
the_mq = user_data;
kill( getpid(), the_mq->notification.sigev_signo );
3000f10c: eb001a2c bl 300159c4 <getpid> <== NOT EXECUTED 3000f110: e5941094 ldr r1, [r4, #148] ; 0x94 <== NOT EXECUTED 3000f114: eb001c0f bl 30016158 <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;
3000f118: e3a03000 mov r3, #0 <== NOT EXECUTED 3000f11c: e584307c str r3, [r4, #124] ; 0x7c <== NOT EXECUTED
the_message_queue->notify_argument = the_argument;
3000f120: e5843080 str r3, [r4, #128] ; 0x80 <== NOT EXECUTED
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
}
3000f124: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000f3a0 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3000f3a0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000f3a4: e1a04000 mov r4, r0 <== NOT EXECUTED
3000f3a8: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
3000f3ac: e1a07001 mov r7, r1 <== NOT EXECUTED
3000f3b0: e1a05002 mov r5, 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(
3000f3b4: e59f0110 ldr r0, [pc, #272] ; 3000f4cc <_POSIX_Message_queue_Receive_support+0x12c><== NOT EXECUTED 3000f3b8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000f3bc: e28d200c add r2, sp, #12 <== NOT EXECUTED 3000f3c0: e1a06003 mov r6, r3 <== NOT EXECUTED 3000f3c4: e5dd8028 ldrb r8, [sp, #40] ; 0x28 <== NOT EXECUTED 3000f3c8: eb000c4d bl 30012504 <_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 ) {
3000f3cc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3000f3d0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f3d4: 0a000006 beq 3000f3f4 <_POSIX_Message_queue_Receive_support+0x54><== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000f3d8: eb0029e3 bl 30019b6c <__errno> <== NOT EXECUTED 3000f3dc: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f3e0: e5803000 str r3, [r0] <== NOT EXECUTED 3000f3e4: e3e03000 mvn r3, #0 <== NOT EXECUTED
}
3000f3e8: e1a00003 mov r0, r3 <== NOT EXECUTED
3000f3ec: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000f3f0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
3000f3f4: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000f3f8: e2032003 and r2, r3, #3 <== NOT EXECUTED 3000f3fc: e3520001 cmp r2, #1 <== NOT EXECUTED 3000f400: 0a00002b beq 3000f4b4 <_POSIX_Message_queue_Receive_support+0x114><== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
3000f404: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
3000f408: e5902068 ldr r2, [r0, #104] ; 0x68 <== NOT EXECUTED 3000f40c: e1520005 cmp r2, r5 <== NOT EXECUTED 3000f410: 8a000021 bhi 3000f49c <_POSIX_Message_queue_Receive_support+0xfc><== NOT EXECUTED
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
3000f414: e3e02000 mvn r2, #0 <== NOT EXECUTED
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000f418: e3580000 cmp r8, #0 <== NOT EXECUTED
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
3000f41c: e58d2008 str r2, [sp, #8] <== NOT EXECUTED
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000f420: 0a000002 beq 3000f430 <_POSIX_Message_queue_Receive_support+0x90><== NOT EXECUTED 3000f424: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 3000f428: 13a08000 movne r8, #0 <== NOT EXECUTED 3000f42c: 03a08001 moveq r8, #1 <== NOT EXECUTED
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
3000f430: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED 3000f434: e1a01004 mov r1, r4 <== NOT EXECUTED
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
3000f438: e59f4090 ldr r4, [pc, #144] ; 3000f4d0 <_POSIX_Message_queue_Receive_support+0x130><== NOT EXECUTED
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
3000f43c: e28d3008 add r3, sp, #8 <== NOT EXECUTED 3000f440: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000f444: e280001c add r0, r0, #28 <== NOT EXECUTED 3000f448: e1a02007 mov r2, r7 <== NOT EXECUTED 3000f44c: e58d8000 str r8, [sp] <== NOT EXECUTED 3000f450: eb00080e bl 30011490 <_CORE_message_queue_Seize> <== NOT EXECUTED
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
3000f454: eb000f85 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
3000f458: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
if ( !_Thread_Executing->Wait.return_code )
3000f45c: e5932034 ldr r2, [r3, #52] ; 0x34 <== 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);
3000f460: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 3000f464: e0213fc1 eor r3, r1, r1, asr #31 <== NOT EXECUTED 3000f468: e0433fc1 sub r3, r3, r1, asr #31 <== NOT EXECUTED 3000f46c: e3520000 cmp r2, #0 <== NOT EXECUTED
do_wait,
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
3000f470: e5863000 str r3, [r6] <== NOT EXECUTED
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
return length_out;
3000f474: 059d3008 ldreq r3, [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 )
3000f478: 0affffda beq 3000f3e8 <_POSIX_Message_queue_Receive_support+0x48><== NOT EXECUTED
return length_out;
rtems_set_errno_and_return_minus_one(
3000f47c: eb0029ba bl 30019b6c <__errno> <== NOT EXECUTED 3000f480: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3000f484: e1a05000 mov r5, r0 <== NOT EXECUTED 3000f488: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000f48c: eb0000b4 bl 3000f764 <_POSIX_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED 3000f490: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000f494: e5850000 str r0, [r5] <== NOT EXECUTED 3000f498: eaffffd2 b 3000f3e8 <_POSIX_Message_queue_Receive_support+0x48><== NOT EXECUTED
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
_Thread_Enable_dispatch();
3000f49c: eb000f73 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMSGSIZE );
3000f4a0: eb0029b1 bl 30019b6c <__errno> <== NOT EXECUTED 3000f4a4: e3a0307a mov r3, #122 ; 0x7a <== NOT EXECUTED 3000f4a8: e5803000 str r3, [r0] <== NOT EXECUTED 3000f4ac: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000f4b0: eaffffcc b 3000f3e8 <_POSIX_Message_queue_Receive_support+0x48><== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
_Thread_Enable_dispatch();
3000f4b4: eb000f6d bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
3000f4b8: eb0029ab bl 30019b6c <__errno> <== NOT EXECUTED 3000f4bc: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f4c0: e5803000 str r3, [r0] <== NOT EXECUTED 3000f4c4: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000f4c8: eaffffc6 b 3000f3e8 <_POSIX_Message_queue_Receive_support+0x48><== NOT EXECUTED
3000f4f8 <_POSIX_Message_queue_Send_support>:
size_t msg_len,
uint32_t msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3000f4f8: 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 )
3000f4fc: e3530020 cmp r3, #32 <== NOT EXECUTED
size_t msg_len,
uint32_t msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
3000f500: e24dd014 sub sp, sp, #20 <== NOT EXECUTED 3000f504: e1a04003 mov r4, r3 <== NOT EXECUTED 3000f508: e1a05000 mov r5, r0 <== NOT EXECUTED 3000f50c: e1a08001 mov r8, r1 <== NOT EXECUTED 3000f510: e1a07002 mov r7, r2 <== NOT EXECUTED 3000f514: e5dd602c ldrb r6, [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 )
3000f518: 8a00002b bhi 3000f5cc <_POSIX_Message_queue_Send_support+0xd4><== 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(
3000f51c: e59f00f0 ldr r0, [pc, #240] ; 3000f614 <_POSIX_Message_queue_Send_support+0x11c><== NOT EXECUTED 3000f520: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f524: e28d2010 add r2, sp, #16 <== NOT EXECUTED 3000f528: eb000bf5 bl 30012504 <_Objects_Get> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000f52c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000f530: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f534: 1a00001f bne 3000f5b8 <_POSIX_Message_queue_Send_support+0xc0><== NOT EXECUTED
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
3000f538: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000f53c: e3130003 tst r3, #3 <== NOT EXECUTED 3000f540: 0a000026 beq 3000f5e0 <_POSIX_Message_queue_Send_support+0xe8><== NOT EXECUTED
the_mq = the_mq_fd->Queue;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000f544: e3560000 cmp r6, #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;
3000f548: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000f54c: 1a000015 bne 3000f5a8 <_POSIX_Message_queue_Send_support+0xb0><== NOT EXECUTED
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
3000f550: e3a03000 mov r3, #0 <== NOT EXECUTED 3000f554: e58d3000 str r3, [sp] <== NOT EXECUTED 3000f558: e59d3030 ldr r3, [sp, #48] ; 0x30 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE CORE_message_queue_Submit_types _POSIX_Message_queue_Priority_to_core(
unsigned int priority
)
{
return priority * -1;
3000f55c: e2644000 rsb r4, r4, #0 <== NOT EXECUTED
3000f560: e58d300c str r3, [sp, #12] <== NOT EXECUTED
3000f564: e1a01008 mov r1, r8 <== NOT EXECUTED
3000f568: e1a03005 mov r3, r5 <== NOT EXECUTED
3000f56c: e1a02007 mov r2, r7 <== NOT EXECUTED
3000f570: e280001c add r0, r0, #28 <== NOT EXECUTED
3000f574: e98d0050 stmib sp, {r4, r6} <== NOT EXECUTED
3000f578: eb00080e bl 300115b8 <_CORE_message_queue_Submit> <== NOT EXECUTED
3000f57c: e1a04000 mov r4, r0 <== NOT EXECUTED
_POSIX_Message_queue_Priority_to_core( msg_prio ),
do_wait,
timeout /* no timeout */
);
_Thread_Enable_dispatch();
3000f580: eb000f3a bl 30013270 <_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 )
3000f584: e3540007 cmp r4, #7 <== NOT EXECUTED
msg_status = _Thread_Executing->Wait.return_code;
3000f588: 059f3088 ldreq r3, [pc, #136] ; 3000f618 <_POSIX_Message_queue_Send_support+0x120><== NOT EXECUTED 3000f58c: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000f590: 05934034 ldreq r4, [r3, #52] ; 0x34 <== NOT EXECUTED
if ( !msg_status )
3000f594: e3540000 cmp r4, #0 <== NOT EXECUTED 3000f598: 1a000016 bne 3000f5f8 <_POSIX_Message_queue_Send_support+0x100><== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
3000f59c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000f5a0: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000f5a4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
the_mq = the_mq_fd->Queue;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
3000f5a8: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 3000f5ac: 13a06000 movne r6, #0 <== NOT EXECUTED 3000f5b0: 03a06001 moveq r6, #1 <== NOT EXECUTED 3000f5b4: eaffffe5 b 3000f550 <_POSIX_Message_queue_Send_support+0x58><== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000f5b8: eb00296b bl 30019b6c <__errno> <== NOT EXECUTED 3000f5bc: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f5c0: e5803000 str r3, [r0] <== NOT EXECUTED 3000f5c4: e3e04000 mvn r4, #0 <== NOT EXECUTED 3000f5c8: eafffff3 b 3000f59c <_POSIX_Message_queue_Send_support+0xa4><== NOT EXECUTED
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
3000f5cc: eb002966 bl 30019b6c <__errno> <== NOT EXECUTED 3000f5d0: e3a03016 mov r3, #22 <== NOT EXECUTED 3000f5d4: e5803000 str r3, [r0] <== NOT EXECUTED 3000f5d8: e3e04000 mvn r4, #0 <== NOT EXECUTED 3000f5dc: eaffffee b 3000f59c <_POSIX_Message_queue_Send_support+0xa4><== NOT EXECUTED
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
_Thread_Enable_dispatch();
3000f5e0: eb000f22 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
3000f5e4: eb002960 bl 30019b6c <__errno> <== NOT EXECUTED 3000f5e8: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f5ec: e5803000 str r3, [r0] <== NOT EXECUTED 3000f5f0: e3e04000 mvn r4, #0 <== NOT EXECUTED 3000f5f4: eaffffe8 b 3000f59c <_POSIX_Message_queue_Send_support+0xa4><== NOT EXECUTED
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
return msg_status;
rtems_set_errno_and_return_minus_one(
3000f5f8: eb00295b bl 30019b6c <__errno> <== NOT EXECUTED 3000f5fc: e1a05000 mov r5, r0 <== NOT EXECUTED 3000f600: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f604: eb000056 bl 3000f764 <_POSIX_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED 3000f608: e3e04000 mvn r4, #0 <== NOT EXECUTED 3000f60c: e5850000 str r0, [r5] <== NOT EXECUTED 3000f610: eaffffe1 b 3000f59c <_POSIX_Message_queue_Send_support+0xa4><== NOT EXECUTED
3000f764 <_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];
3000f764: e59f3004 ldr r3, [pc, #4] ; 3000f770 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0xc><== NOT EXECUTED
}
3000f768: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3000f76c: e12fff1e bx lr <== NOT EXECUTED
30010648 <_POSIX_Priority_Is_valid>:
bool _POSIX_Priority_Is_valid(
int priority
)
{
return ((priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY) &&
30010648: e3500000 cmp r0, #0
3001064c: da000005 ble 30010668 <_POSIX_Priority_Is_valid+0x20>
(priority <= POSIX_SCHEDULER_MAXIMUM_PRIORITY));
30010650: e59f3018 ldr r3, [pc, #24] ; 30010670 <_POSIX_Priority_Is_valid+0x28> 30010654: e5d33000 ldrb r3, [r3]
#endif
#include <rtems/system.h>
#include <rtems/posix/priority.h>
bool _POSIX_Priority_Is_valid(
30010658: e1500003 cmp r0, r3 3001065c: a3a00000 movge r0, #0 30010660: b3a00001 movlt r0, #1 30010664: e12fff1e bx lr
int priority
)
{
return ((priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY) &&
30010668: e3a00000 mov r0, #0 <== NOT EXECUTED
(priority <= POSIX_SCHEDULER_MAXIMUM_PRIORITY));
}
3001066c: e12fff1e bx lr <== NOT EXECUTED
3000b44c <_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];
3000b44c: e59f3004 ldr r3, [pc, #4] ; 3000b458 <_POSIX_RWLock_Translate_core_RWLock_return_code+0xc><== NOT EXECUTED
}
3000b450: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3000b454: e12fff1e bx lr <== NOT EXECUTED
30013190 <_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)
30013190: e3510000 cmp r1, #0 <== NOT EXECUTED
const char *name,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
30013194: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30013198: e1a04000 mov r4, r0 <== NOT EXECUTED
3001319c: e1a08002 mov r8, r2 <== NOT EXECUTED
300131a0: 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)
300131a4: 1a000028 bne 3001324c <_POSIX_Semaphore_Create_support+0xbc><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
if ( name ) {
300131a8: e3500000 cmp r0, #0 <== NOT EXECUTED 300131ac: 0a000003 beq 300131c0 <_POSIX_Semaphore_Create_support+0x30><== NOT EXECUTED
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
300131b0: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 300131b4: eb001266 bl 30017b54 <strnlen> <== NOT EXECUTED 300131b8: e35000fe cmp r0, #254 ; 0xfe <== NOT EXECUTED 300131bc: 8a000027 bhi 30013260 <_POSIX_Semaphore_Create_support+0xd0><== NOT EXECUTED 300131c0: e59f30c4 ldr r3, [pc, #196] ; 3001328c <_POSIX_Semaphore_Create_support+0xfc><== NOT EXECUTED 300131c4: e5932000 ldr r2, [r3] <== NOT EXECUTED 300131c8: e2822001 add r2, r2, #1 <== NOT EXECUTED 300131cc: 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 );
300131d0: e59f00b8 ldr r0, [pc, #184] ; 30013290 <_POSIX_Semaphore_Create_support+0x100><== NOT EXECUTED 300131d4: ebffed43 bl 3000e6e8 <_Objects_Allocate> <== NOT EXECUTED
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
300131d8: e2505000 subs r5, r0, #0 <== NOT EXECUTED 300131dc: 0a000024 beq 30013274 <_POSIX_Semaphore_Create_support+0xe4><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
}
the_semaphore->process_shared = pshared;
if ( name ) {
300131e0: e3540000 cmp r4, #0 <== NOT EXECUTED
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOSPC );
}
the_semaphore->process_shared = pshared;
300131e4: e3a03000 mov r3, #0 <== NOT EXECUTED 300131e8: e5853010 str r3, [r5, #16] <== NOT EXECUTED
if ( name ) {
the_semaphore->named = true;
300131ec: 13a03001 movne r3, #1 <== NOT EXECUTED 300131f0: 15c53014 strbne r3, [r5, #20] <== NOT EXECUTED
the_semaphore->open_count = 1;
300131f4: 15853018 strne r3, [r5, #24] <== NOT EXECUTED
the_semaphore->linked = true;
300131f8: 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;
300131fc: e3a06000 mov r6, #0 <== NOT EXECUTED
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
30013200: e3e03000 mvn r3, #0 <== NOT EXECUTED
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
30013204: 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;
30013208: 05c54014 strbeq r4, [r5, #20] <== NOT EXECUTED
the_semaphore->open_count = 0;
3001320c: 05854018 streq r4, [r5, #24] <== NOT EXECUTED
the_semaphore->linked = false;
30013210: 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;
30013214: e585305c str r3, [r5, #92] ; 0x5c <== NOT EXECUTED
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
30013218: e285105c add r1, r5, #92 ; 0x5c <== NOT EXECUTED 3001321c: 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;
30013220: 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 );
30013224: ebffebae bl 3000e0e4 <_CORE_semaphore_Initialize> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30013228: e59f3060 ldr r3, [pc, #96] ; 30013290 <_POSIX_Semaphore_Create_support+0x100><== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
3001322c: e1d520b8 ldrh r2, [r5, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30013230: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 30013234: 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;
30013238: e585400c str r4, [r5, #12] <== NOT EXECUTED
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name_p
);
*the_sem = the_semaphore;
3001323c: e5875000 str r5, [r7] <== NOT EXECUTED
_Thread_Enable_dispatch();
30013240: ebfff1b4 bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30013244: e1a00006 mov r0, r6 <== NOT EXECUTED
}
30013248: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
CORE_semaphore_Attributes *the_sem_attr;
char *name_p = (char *)name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
rtems_set_errno_and_return_minus_one( ENOSYS );
3001324c: eb000c05 bl 30016268 <__errno> <== NOT EXECUTED
30013250: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED
30013254: e5803000 str r3, [r0] <== NOT EXECUTED
30013258: e3e00000 mvn r0, #0 <== NOT EXECUTED
3001325c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if ( name ) {
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
30013260: eb000c00 bl 30016268 <__errno> <== NOT EXECUTED
30013264: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED
30013268: e5803000 str r3, [r0] <== NOT EXECUTED
3001326c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30013270: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
30013274: ebfff1a7 bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
30013278: eb000bfa bl 30016268 <__errno> <== NOT EXECUTED
3001327c: e3a0301c mov r3, #28 <== NOT EXECUTED
30013280: e5803000 str r3, [r0] <== NOT EXECUTED
30013284: e3e00000 mvn r0, #0 <== NOT EXECUTED
30013288: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30013294 <_POSIX_Semaphore_Delete>:
void _POSIX_Semaphore_Delete(
POSIX_Semaphore_Control *the_semaphore
)
{
if ( !the_semaphore->linked && !the_semaphore->open_count ) {
30013294: e5d03015 ldrb r3, [r0, #21] <== NOT EXECUTED
*/
void _POSIX_Semaphore_Delete(
POSIX_Semaphore_Control *the_semaphore
)
{
30013298: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !the_semaphore->linked && !the_semaphore->open_count ) {
3001329c: e3530000 cmp r3, #0 <== NOT EXECUTED
*/
void _POSIX_Semaphore_Delete(
POSIX_Semaphore_Control *the_semaphore
)
{
300132a0: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( !the_semaphore->linked && !the_semaphore->open_count ) {
300132a4: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
300132a8: e5905018 ldr r5, [r0, #24] <== NOT EXECUTED
300132ac: e3550000 cmp r5, #0 <== NOT EXECUTED
300132b0: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
_Objects_Close( &_POSIX_Semaphore_Information, &the_semaphore->Object );
300132b4: e1a01000 mov r1, r0 <== NOT EXECUTED 300132b8: e59f0020 ldr r0, [pc, #32] ; 300132e0 <_POSIX_Semaphore_Delete+0x4c><== NOT EXECUTED 300132bc: ebffed2e bl 3000e77c <_Objects_Close> <== NOT EXECUTED
_CORE_semaphore_Flush(
300132c0: e284001c add r0, r4, #28 <== NOT EXECUTED 300132c4: e1a01005 mov r1, r5 <== NOT EXECUTED 300132c8: e3e02000 mvn r2, #0 <== NOT EXECUTED 300132cc: ebffeb83 bl 3000e0e0 <_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 );
300132d0: e59f0008 ldr r0, [pc, #8] ; 300132e0 <_POSIX_Semaphore_Delete+0x4c><== NOT EXECUTED 300132d4: e1a01004 mov r1, r4 <== NOT EXECUTED
-1
);
_POSIX_Semaphore_Free( the_semaphore );
}
}
300132d8: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
300132dc: eaffeddb b 3000ea50 <_Objects_Free> <== NOT EXECUTED
300132e4 <_POSIX_Semaphore_Name_to_id>:
int _POSIX_Semaphore_Name_to_id(
const char *name,
sem_t *id
)
{
300132e4: e92d4010 push {r4, lr} <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
300132e8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
int _POSIX_Semaphore_Name_to_id(
const char *name,
sem_t *id
)
{
300132ec: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 300132f0: e1a04001 mov r4, r1 <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
300132f4: 0a000002 beq 30013304 <_POSIX_Semaphore_Name_to_id+0x20> <== NOT EXECUTED
return EINVAL;
if ( !name[0] )
300132f8: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 300132fc: e3520000 cmp r2, #0 <== NOT EXECUTED 30013300: 1a000002 bne 30013310 <_POSIX_Semaphore_Name_to_id+0x2c> <== NOT EXECUTED
return EINVAL;
30013304: e3a00016 mov r0, #22 <== NOT EXECUTED
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
30013308: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3001330c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
return EINVAL;
if ( !name[0] )
return EINVAL;
status = _Objects_Name_to_id_string(
30013310: e1a01003 mov r1, r3 <== NOT EXECUTED 30013314: e59f001c ldr r0, [pc, #28] ; 30013338 <_POSIX_Semaphore_Name_to_id+0x54><== NOT EXECUTED 30013318: e1a0200d mov r2, sp <== NOT EXECUTED 3001331c: eb0003ab bl 300141d0 <_Objects_Name_to_id_string> <== NOT EXECUTED
&_POSIX_Semaphore_Information,
name,
&the_id
);
*id = the_id;
30013320: e59d3000 ldr r3, [sp] <== NOT EXECUTED
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
30013324: e3500000 cmp r0, #0 <== NOT EXECUTED 30013328: 13a00002 movne r0, #2 <== NOT EXECUTED 3001332c: 03a00000 moveq r0, #0 <== NOT EXECUTED
status = _Objects_Name_to_id_string(
&_POSIX_Semaphore_Information,
name,
&the_id
);
*id = the_id;
30013330: e5843000 str r3, [r4] <== NOT EXECUTED 30013334: eafffff3 b 30013308 <_POSIX_Semaphore_Name_to_id+0x24> <== NOT EXECUTED
30015d2c <_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];
30015d2c: e59f3004 ldr r3, [pc, #4] ; 30015d38 <_POSIX_Semaphore_Translate_core_semaphore_return_code+0xc><== NOT EXECUTED
}
30015d30: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 30015d34: e12fff1e bx lr <== NOT EXECUTED
30013384 <_POSIX_Semaphore_Wait_support>:
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,
Watchdog_Interval timeout
)
{
30013384: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
_Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location );
30013388: e5903000 ldr r3, [r0] <== NOT EXECUTED 3001338c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30013390: e1a05001 mov r5, r1 <== NOT EXECUTED 30013394: e1a04002 mov r4, r2 <== NOT EXECUTED 30013398: e1a01003 mov r1, r3 <== NOT EXECUTED 3001339c: e1a0200d mov r2, sp <== NOT EXECUTED 300133a0: e59f007c ldr r0, [pc, #124] ; 30013424 <_POSIX_Semaphore_Wait_support+0xa0><== NOT EXECUTED 300133a4: ebffee00 bl 3000ebac <_Objects_Get> <== NOT EXECUTED
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
300133a8: e59d2000 ldr r2, [sp] <== NOT EXECUTED
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,
Watchdog_Interval timeout
)
{
300133ac: e20550ff and r5, r5, #255 ; 0xff <== NOT EXECUTED
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
300133b0: e3520000 cmp r2, #0 <== NOT EXECUTED 300133b4: e1a03000 mov r3, r0 <== NOT EXECUTED 300133b8: 0a000006 beq 300133d8 <_POSIX_Semaphore_Wait_support+0x54> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
300133bc: eb000ba9 bl 30016268 <__errno> <== NOT EXECUTED 300133c0: e3a03016 mov r3, #22 <== NOT EXECUTED 300133c4: e5803000 str r3, [r0] <== NOT EXECUTED 300133c8: e3e03000 mvn r3, #0 <== NOT EXECUTED
}
300133cc: e1a00003 mov r0, r3 <== NOT EXECUTED
300133d0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300133d4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
300133d8: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED 300133dc: e1a03004 mov r3, r4 <== NOT EXECUTED
blocking,
timeout
);
_Thread_Enable_dispatch();
if ( !_Thread_Executing->Wait.return_code )
300133e0: e59f4040 ldr r4, [pc, #64] ; 30013428 <_POSIX_Semaphore_Wait_support+0xa4><== NOT EXECUTED
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
300133e4: e280001c add r0, r0, #28 <== NOT EXECUTED 300133e8: e1a02005 mov r2, r5 <== NOT EXECUTED 300133ec: eb0001f7 bl 30013bd0 <_CORE_semaphore_Seize> <== NOT EXECUTED
&the_semaphore->Semaphore,
the_semaphore->Object.id,
blocking,
timeout
);
_Thread_Enable_dispatch();
300133f0: ebfff148 bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !_Thread_Executing->Wait.return_code )
300133f4: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 300133f8: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 300133fc: e3530000 cmp r3, #0 <== NOT EXECUTED 30013400: 0afffff1 beq 300133cc <_POSIX_Semaphore_Wait_support+0x48> <== NOT EXECUTED
return 0;
rtems_set_errno_and_return_minus_one(
30013404: eb000b97 bl 30016268 <__errno> <== NOT EXECUTED 30013408: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3001340c: e1a05000 mov r5, r0 <== NOT EXECUTED 30013410: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 30013414: eb000a44 bl 30015d2c <_POSIX_Semaphore_Translate_core_semaphore_return_code><== NOT EXECUTED 30013418: e3e03000 mvn r3, #0 <== NOT EXECUTED 3001341c: e5850000 str r0, [r5] <== NOT EXECUTED 30013420: eaffffe9 b 300133cc <_POSIX_Semaphore_Wait_support+0x48> <== NOT EXECUTED
30009fec <_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];
30009fec: e59f3004 ldr r3, [pc, #4] ; 30009ff8 <_POSIX_Spinlock_Translate_core_spinlock_return_code+0xc><== NOT EXECUTED
}
30009ff0: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 30009ff4: e12fff1e bx lr <== NOT EXECUTED
3000f11c <_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 ];
3000f11c: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
3000f120: e59320d8 ldr r2, [r3, #216] ; 0xd8 <== NOT EXECUTED 3000f124: e3520000 cmp r2, #0 <== NOT EXECUTED 3000f128: 1a000002 bne 3000f138 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x1c><== NOT EXECUTED 3000f12c: e59320dc ldr r2, [r3, #220] ; 0xdc <== NOT EXECUTED 3000f130: e3520001 cmp r2, #1 <== NOT EXECUTED 3000f134: 0a000000 beq 3000f13c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x20><== NOT EXECUTED
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
3000f138: eafff4e7 b 3000c4dc <_Thread_Enable_dispatch> <== NOT EXECUTED
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
3000f13c: e59330e0 ldr r3, [r3, #224] ; 0xe0 <== NOT EXECUTED 3000f140: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f144: 0afffffb beq 3000f138 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x1c><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000f148: e59f3010 ldr r3, [pc, #16] ; 3000f160 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NOT EXECUTED
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
3000f14c: e3e01000 mvn r1, #0 <== NOT EXECUTED 3000f150: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000f154: e0822001 add r2, r2, r1 <== NOT EXECUTED 3000f158: e5832000 str r2, [r3] <== NOT EXECUTED 3000f15c: ea000224 b 3000f9f4 <_POSIX_Thread_Exit> <== NOT EXECUTED
30010674 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
30010674: e92d40f0 push {r4, r5, r6, r7, lr}
30010678: e1a04000 mov r4, r0
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
3001067c: e5910000 ldr r0, [r1]
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
30010680: e1a05001 mov r5, r1 30010684: e1a06002 mov r6, r2 30010688: e1a07003 mov r7, r3
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
3001068c: ebffffed bl 30010648 <_POSIX_Priority_Is_valid> 30010690: e3500000 cmp r0, #0
30010694: 0a00000e beq 300106d4 <_POSIX_Thread_Translate_sched_param+0x60>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
30010698: e3a00000 mov r0, #0
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
3001069c: e1540000 cmp r4, r0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
300106a0: 03a03001 moveq r3, #1
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
300106a4: e5860000 str r0, [r6]
*budget_callout = NULL;
300106a8: e5870000 str r0, [r7]
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
300106ac: 05863000 streq r3, [r6]
return 0;
300106b0: 01a00004 moveq r0, r4
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
300106b4: 08bd80f0 popeq {r4, r5, r6, r7, pc}
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
300106b8: e3540001 cmp r4, #1
300106bc: 08bd80f0 popeq {r4, r5, r6, r7, pc}
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
300106c0: e3540002 cmp r4, #2 <== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
300106c4: 05864000 streq r4, [r6] <== NOT EXECUTED
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
300106c8: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
300106cc: e3540004 cmp r4, #4 <== NOT EXECUTED 300106d0: 0a000001 beq 300106dc <_POSIX_Thread_Translate_sched_param+0x68><== 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;
300106d4: e3a00016 mov r0, #22 <== NOT EXECUTED
300106d8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
300106dc: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 300106e0: e3530000 cmp r3, #0 <== NOT EXECUTED 300106e4: 1a000002 bne 300106f4 <_POSIX_Thread_Translate_sched_param+0x80><== NOT EXECUTED 300106e8: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 300106ec: e3530000 cmp r3, #0 <== NOT EXECUTED 300106f0: 0afffff7 beq 300106d4 <_POSIX_Thread_Translate_sched_param+0x60><== NOT EXECUTED
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
300106f4: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED 300106f8: e3530000 cmp r3, #0 <== NOT EXECUTED 300106fc: 1a000002 bne 3001070c <_POSIX_Thread_Translate_sched_param+0x98><== NOT EXECUTED 30010700: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 30010704: e3530000 cmp r3, #0 <== NOT EXECUTED 30010708: 0afffff1 beq 300106d4 <_POSIX_Thread_Translate_sched_param+0x60><== NOT EXECUTED
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
3001070c: e2850008 add r0, r5, #8 <== NOT EXECUTED 30010710: ebfff5fc bl 3000df08 <_Timespec_To_ticks> <== NOT EXECUTED 30010714: e1a04000 mov r4, r0 <== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
30010718: e2850010 add r0, r5, #16 <== NOT EXECUTED 3001071c: ebfff5f9 bl 3000df08 <_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 ) <
30010720: e1540000 cmp r4, r0 <== NOT EXECUTED 30010724: 3affffea bcc 300106d4 <_POSIX_Thread_Translate_sched_param+0x60><== NOT EXECUTED
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
30010728: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 3001072c: ebffffc5 bl 30010648 <_POSIX_Priority_Is_valid> <== NOT EXECUTED 30010730: e3500000 cmp r0, #0 <== NOT EXECUTED 30010734: 0a000005 beq 30010750 <_POSIX_Thread_Translate_sched_param+0xdc><== NOT EXECUTED
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
30010738: e3a03003 mov r3, #3 <== NOT EXECUTED 3001073c: e5863000 str r3, [r6] <== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
30010740: e59f3010 ldr r3, [pc, #16] ; 30010758 <_POSIX_Thread_Translate_sched_param+0xe4><== NOT EXECUTED
return 0;
30010744: 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;
30010748: e5873000 str r3, [r7] <== NOT EXECUTED
return 0;
3001074c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
30010750: e3a00016 mov r0, #22 <== NOT EXECUTED
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
30010754: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000f2a0 <_POSIX_Threads_Delete_extension>:
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
3000f2a0: e92d40f0 push {r4, r5, r6, r7, lr}
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
3000f2a4: e1a00001 mov r0, r1
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
3000f2a8: e1a06001 mov r6, r1
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
3000f2ac: e59170fc ldr r7, [r1, #252] ; 0xfc
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
3000f2b0: eb00093a bl 300117a0 <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
3000f2b4: e1a00006 mov r0, r6 3000f2b8: eb000951 bl 30011804 <_POSIX_Keys_Run_destructors> 3000f2bc: e2874044 add r4, r7, #68 ; 0x44
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
3000f2c0: e5965028 ldr r5, [r6, #40] ; 0x28
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
3000f2c4: ea000001 b 3000f2d0 <_POSIX_Threads_Delete_extension+0x30>
*(void **)the_thread->Wait.return_argument = value_ptr;
3000f2c8: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 3000f2cc: e5835000 str r5, [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 )) )
3000f2d0: e1a00004 mov r0, r4 3000f2d4: ebfff457 bl 3000c438 <_Thread_queue_Dequeue> 3000f2d8: e3500000 cmp r0, #0
3000f2dc: 1afffff9 bne 3000f2c8 <_POSIX_Threads_Delete_extension+0x28>
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
3000f2e0: e5973084 ldr r3, [r7, #132] ; 0x84 3000f2e4: e3530004 cmp r3, #4
3000f2e8: 0a000004 beq 3000f300 <_POSIX_Threads_Delete_extension+0x60>
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
3000f2ec: e3a03000 mov r3, #0
_Workspace_Free( api );
3000f2f0: e1a00007 mov r0, r7
*(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;
3000f2f4: e58630fc str r3, [r6, #252] ; 0xfc
_Workspace_Free( api );
}
3000f2f8: 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 );
3000f2fc: eafff7fa b 3000d2ec <_Workspace_Free>
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
3000f300: e28700a8 add r0, r7, #168 ; 0xa8 <== NOT EXECUTED 3000f304: ebfff786 bl 3000d124 <_Watchdog_Remove> <== NOT EXECUTED 3000f308: eafffff7 b 3000f2ec <_POSIX_Threads_Delete_extension+0x4c> <== NOT EXECUTED
3000f428 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
3000f428: 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 ];
3000f42c: e59140fc ldr r4, [r1, #252] ; 0xfc <== NOT EXECUTED
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
3000f430: 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 );
3000f434: e2840098 add r0, r4, #152 ; 0x98 <== NOT EXECUTED 3000f438: eb000420 bl 300104c0 <_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);
3000f43c: e59f3054 ldr r3, [pc, #84] ; 3000f498 <_POSIX_Threads_Sporadic_budget_TSR+0x70><== NOT EXECUTED 3000f440: e5942088 ldr r2, [r4, #136] ; 0x88 <== NOT EXECUTED 3000f444: e5d31000 ldrb r1, [r3] <== 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 ) {
3000f448: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3000f44c: e0621001 rsb r1, r2, r1 <== NOT EXECUTED 3000f450: e3530000 cmp r3, #0 <== NOT EXECUTED
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 );
the_thread->cpu_time_budget = ticks;
3000f454: e5850078 str r0, [r5, #120] ; 0x78 <== NOT EXECUTED
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
3000f458: 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 ) {
3000f45c: 1a000002 bne 3000f46c <_POSIX_Threads_Sporadic_budget_TSR+0x44><== NOT EXECUTED
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
3000f460: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 3000f464: e1530001 cmp r3, r1 <== NOT EXECUTED 3000f468: 8a000006 bhi 3000f488 <_POSIX_Threads_Sporadic_budget_TSR+0x60><== NOT EXECUTED
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
3000f46c: e2840090 add r0, r4, #144 ; 0x90 <== NOT EXECUTED 3000f470: eb000412 bl 300104c0 <_Timespec_To_ticks> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000f474: e58400b4 str r0, [r4, #180] ; 0xb4 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000f478: e59f001c ldr r0, [pc, #28] ; 3000f49c <_POSIX_Threads_Sporadic_budget_TSR+0x74><== NOT EXECUTED 3000f47c: e28410a8 add r1, r4, #168 ; 0xa8 <== NOT EXECUTED
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
3000f480: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
3000f484: eafff6b7 b 3000cf68 <_Watchdog_Insert> <== NOT EXECUTED
if ( the_thread->resource_count == 0 ) {
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
_Thread_Change_priority( the_thread, new_priority, true );
3000f488: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f48c: e3a02001 mov r2, #1 <== NOT EXECUTED 3000f490: ebfff1fd bl 3000bc8c <_Thread_Change_priority> <== NOT EXECUTED 3000f494: eafffff4 b 3000f46c <_POSIX_Threads_Sporadic_budget_TSR+0x44><== NOT EXECUTED
3000f4a0 <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000f4a0: e59020fc ldr r2, [r0, #252] ; 0xfc <== NOT EXECUTED 3000f4a4: e592108c ldr r1, [r2, #140] ; 0x8c <== NOT EXECUTED 3000f4a8: e59f2030 ldr r2, [pc, #48] ; 3000f4e0 <_POSIX_Threads_Sporadic_budget_callout+0x40><== NOT EXECUTED 3000f4ac: e5d2c000 ldrb ip, [r2] <== 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 ) {
3000f4b0: e590201c ldr r2, [r0, #28] <== NOT EXECUTED 3000f4b4: e061100c rsb r1, r1, ip <== NOT EXECUTED 3000f4b8: e3520000 cmp r2, #0 <== 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 */
3000f4bc: e3e02000 mvn r2, #0 <== NOT EXECUTED 3000f4c0: e5802078 str r2, [r0, #120] ; 0x78 <== NOT EXECUTED
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
3000f4c4: 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 ) {
3000f4c8: 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 ) {
3000f4cc: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000f4d0: e1530001 cmp r3, r1 <== NOT EXECUTED 3000f4d4: 212fff1e bxcs lr <== NOT EXECUTED
_Thread_Change_priority( the_thread, new_priority, true );
3000f4d8: e3a02001 mov r2, #1 <== NOT EXECUTED 3000f4dc: eafff1ea b 3000bc8c <_Thread_Change_priority> <== NOT EXECUTED
300117a0 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
300117a0: 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 ];
300117a4: e59050fc ldr r5, [r0, #252] ; 0xfc
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
300117a8: e59530e4 ldr r3, [r5, #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 );
300117ac: e28560e8 add r6, r5, #232 ; 0xe8 300117b0: e1530006 cmp r3, r6
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
300117b4: e3a03001 mov r3, #1 300117b8: e58530d8 str r3, [r5, #216] ; 0xd8
while ( !_Chain_Is_empty( handler_stack ) ) {
300117bc: 08bd8070 popeq {r4, r5, r6, pc}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300117c0: e10f1000 mrs r1, CPSR <== NOT EXECUTED 300117c4: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 300117c8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Disable( level );
handler = (POSIX_Cancel_Handler_control *)
300117cc: e59540ec ldr r4, [r5, #236] ; 0xec <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
300117d0: e894000c ldm r4, {r2, r3} <== NOT EXECUTED
previous = the_node->previous; next->previous = previous;
300117d4: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
300117d8: e5832000 str r2, [r3] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300117dc: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
(*handler->routine)( handler->arg );
300117e0: e594000c ldr r0, [r4, #12] <== NOT EXECUTED 300117e4: e1a0e00f mov lr, pc <== NOT EXECUTED 300117e8: e594f008 ldr pc, [r4, #8] <== NOT EXECUTED
_Workspace_Free( handler );
300117ec: e1a00004 mov r0, r4 <== NOT EXECUTED 300117f0: ebffeebd bl 3000d2ec <_Workspace_Free> <== NOT EXECUTED
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
300117f4: e59530e4 ldr r3, [r5, #228] ; 0xe4 <== NOT EXECUTED
300117f8: e1530006 cmp r3, r6 <== NOT EXECUTED
300117fc: 1affffef bne 300117c0 <_POSIX_Threads_cancel_run+0x20> <== NOT EXECUTED
30011800: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3001024c <_POSIX_Timer_Insert_helper>:
Watchdog_Interval ticks,
Objects_Id id,
Watchdog_Service_routine_entry TSR,
void *arg
)
{
3001024c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30010250: e1a04000 mov r4, r0 <== NOT EXECUTED
30010254: e1a05001 mov r5, r1 <== NOT EXECUTED
30010258: e1a07002 mov r7, r2 <== NOT EXECUTED
3001025c: e1a08003 mov r8, r3 <== NOT EXECUTED
ISR_Level level;
(void) _Watchdog_Remove( timer );
30010260: ebfff663 bl 3000dbf4 <_Watchdog_Remove> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30010264: e10f6000 mrs r6, CPSR <== NOT EXECUTED 30010268: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3001026c: 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 ) {
30010270: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30010274: e3530000 cmp r3, #0 <== NOT EXECUTED 30010278: 0a000002 beq 30010288 <_POSIX_Timer_Insert_helper+0x3c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001027c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
return false;
30010280: e3a00000 mov r0, #0 <== NOT EXECUTED
30010284: 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;
30010288: e5843008 str r3, [r4, #8] <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3001028c: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30010290: e584801c str r8, [r4, #28] <== NOT EXECUTED
the_watchdog->id = id;
30010294: e5847020 str r7, [r4, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
30010298: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001029c: e584500c str r5, [r4, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
300102a0: e59f0010 ldr r0, [pc, #16] ; 300102b8 <_POSIX_Timer_Insert_helper+0x6c><== NOT EXECUTED 300102a4: e1a01004 mov r1, r4 <== NOT EXECUTED 300102a8: ebfff5e2 bl 3000da38 <_Watchdog_Insert> <== NOT EXECUTED 300102ac: 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;
300102b0: e3a00001 mov r0, #1 <== NOT EXECUTED
}
300102b4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30009d60 <_POSIX_Timer_TSR>:
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
30009d60: e92d4010 push {r4, lr} <== NOT EXECUTED
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
30009d64: e5913068 ldr r3, [r1, #104] ; 0x68 <== NOT EXECUTED
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
30009d68: e5912054 ldr r2, [r1, #84] ; 0x54 <== NOT EXECUTED
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
30009d6c: e2833001 add r3, r3, #1 <== NOT EXECUTED
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
30009d70: e3520000 cmp r2, #0 <== NOT EXECUTED
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
30009d74: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30009d78: e1a04001 mov r4, r1 <== NOT EXECUTED
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
30009d7c: e5813068 str r3, [r1, #104] ; 0x68 <== NOT EXECUTED
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
30009d80: 1a000004 bne 30009d98 <_POSIX_Timer_TSR+0x38> <== NOT EXECUTED 30009d84: e5913058 ldr r3, [r1, #88] ; 0x58 <== NOT EXECUTED 30009d88: 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;
30009d8c: 03a03004 moveq r3, #4 <== NOT EXECUTED 30009d90: 05c1303c strbeq r3, [r1, #60] ; 0x3c <== 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 ) ||
30009d94: 0a00000d beq 30009dd0 <_POSIX_Timer_TSR+0x70> <== NOT EXECUTED
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
30009d98: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED 30009d9c: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 30009da0: e59f3040 ldr r3, [pc, #64] ; 30009de8 <_POSIX_Timer_TSR+0x88><== NOT EXECUTED 30009da4: e2840010 add r0, r4, #16 <== NOT EXECUTED 30009da8: e58d4000 str r4, [sp] <== NOT EXECUTED 30009dac: eb001926 bl 3001024c <_POSIX_Timer_Insert_helper> <== NOT EXECUTED
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
30009db0: e3500000 cmp r0, #0 <== NOT EXECUTED 30009db4: 1a000001 bne 30009dc0 <_POSIX_Timer_TSR+0x60> <== NOT EXECUTED
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
}
30009db8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30009dbc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
);
if ( !activated )
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
30009dc0: e284006c add r0, r4, #108 ; 0x6c <== NOT EXECUTED 30009dc4: eb000581 bl 3000b3d0 <_TOD_Get> <== NOT EXECUTED
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
30009dc8: e3a03003 mov r3, #3 <== NOT EXECUTED 30009dcc: 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 ) ) {
30009dd0: e5940038 ldr r0, [r4, #56] ; 0x38 <== NOT EXECUTED 30009dd4: e5941044 ldr r1, [r4, #68] ; 0x44 <== NOT EXECUTED 30009dd8: eb0017fe bl 3000fdd8 <pthread_kill> <== NOT EXECUTED
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
30009ddc: e3a03000 mov r3, #0 <== NOT EXECUTED 30009de0: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED 30009de4: eafffff3 b 30009db8 <_POSIX_Timer_TSR+0x58> <== NOT EXECUTED
3000ef48 <_POSIX_signals_Abnormal_termination_handler>:
sigset_t _POSIX_signals_Pending;
void _POSIX_signals_Abnormal_termination_handler(
int signo __attribute__((unused)) )
{
3000ef48: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
exit( 1 );
3000ef4c: e3a00001 mov r0, #1 <== NOT EXECUTED 3000ef50: eb000c4b bl 30012084 <exit> <== NOT EXECUTED
3000bb70 <_POSIX_signals_Alarm_TSR>:
void _POSIX_signals_Alarm_TSR(
Objects_Id id __attribute__((unused)),
void *argument __attribute__((unused))
)
{
3000bb70: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
int status;
status = kill( getpid(), SIGALRM );
3000bb74: ebfff41b bl 30008be8 <getpid> <== NOT EXECUTED 3000bb78: e3a0100e mov r1, #14 <== NOT EXECUTED
/* XXX can't print from an ISR, should this be fatal? */ }
3000bb7c: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
void *argument __attribute__((unused))
)
{
int status;
status = kill( getpid(), SIGALRM );
3000bb80: ea00004c b 3000bcb8 <kill> <== NOT EXECUTED
3001189c <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
3001189c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
300118a0: e24dd040 sub sp, sp, #64 ; 0x40 <== NOT EXECUTED
300118a4: 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,
300118a8: e28d6034 add r6, sp, #52 ; 0x34 <== NOT EXECUTED 300118ac: e3a02001 mov r2, #1 <== NOT EXECUTED 300118b0: e58d2000 str r2, [sp] <== NOT EXECUTED 300118b4: e1a02006 mov r2, r6 <== NOT EXECUTED
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
300118b8: e1a05000 mov r5, r0 <== NOT EXECUTED 300118bc: e1a04001 mov r4, 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,
300118c0: eb000038 bl 300119a8 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 300118c4: e2503000 subs r3, r0, #0 <== NOT EXECUTED 300118c8: 0a00002b beq 3001197c <_POSIX_signals_Check_signal+0xe0> <== NOT EXECUTED
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
300118cc: e59fa0cc ldr sl, [pc, #204] ; 300119a0 <_POSIX_signals_Check_signal+0x104><== NOT EXECUTED 300118d0: e0849084 add r9, r4, r4, lsl #1 <== NOT EXECUTED 300118d4: e1a09109 lsl r9, r9, #2 <== NOT EXECUTED 300118d8: e08a8009 add r8, sl, r9 <== NOT EXECUTED 300118dc: e598b008 ldr fp, [r8, #8] <== NOT EXECUTED 300118e0: e35b0001 cmp fp, #1 <== NOT EXECUTED
return false;
300118e4: 03a03000 moveq r3, #0 <== NOT EXECUTED
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
300118e8: 0a000023 beq 3001197c <_POSIX_signals_Check_signal+0xe0> <== 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,
300118ec: e59f70b0 ldr r7, [pc, #176] ; 300119a4 <_POSIX_signals_Check_signal+0x108><== NOT EXECUTED 300118f0: e28d200c add r2, sp, #12 <== NOT EXECUTED 300118f4: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 300118f8: e597c004 ldr ip, [r7, #4] <== NOT EXECUTED
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
300118fc: e59530d0 ldr r3, [r5, #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,
30011900: e59de004 ldr lr, [sp, #4] <== NOT EXECUTED 30011904: e28cc020 add ip, ip, #32 <== NOT EXECUTED
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
30011908: e58d3008 str r3, [sp, #8] <== 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,
3001190c: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30011910: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30011914: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30011918: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
3001191c: e89c0003 ldm ip, {r0, r1} <== NOT EXECUTED
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
30011920: e5983004 ldr r3, [r8, #4] <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
30011924: e79a2009 ldr r2, [sl, r9] <== NOT EXECUTED
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
30011928: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
3001192c: e3520002 cmp r2, #2 <== NOT EXECUTED
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
30011930: e183300c orr r3, r3, ip <== NOT EXECUTED 30011934: e58530d0 str r3, [r5, #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,
30011938: e88e0003 stm lr, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
3001193c: 0a000011 beq 30011988 <_POSIX_signals_Check_signal+0xec> <== NOT EXECUTED
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
30011940: e1a00004 mov r0, r4 <== NOT EXECUTED 30011944: e1a0e00f mov lr, pc <== NOT EXECUTED 30011948: e12fff1b bx fp <== NOT EXECUTED
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
3001194c: e597c004 ldr ip, [r7, #4] <== NOT EXECUTED
30011950: e59d4004 ldr r4, [sp, #4] <== NOT EXECUTED
30011954: e28cc020 add ip, ip, #32 <== NOT EXECUTED
30011958: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3001195c: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30011960: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
30011964: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30011968: e8940003 ldm r4, {r0, r1} <== NOT EXECUTED
3001196c: e88c0003 stm ip, {r0, r1} <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
30011970: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
return true;
30011974: e3a03001 mov r3, #1 <== NOT EXECUTED
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
30011978: e58520d0 str r2, [r5, #208] ; 0xd0 <== NOT EXECUTED
return true;
}
3001197c: e1a00003 mov r0, r3 <== NOT EXECUTED
30011980: e28dd040 add sp, sp, #64 ; 0x40 <== NOT EXECUTED
30011984: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
30011988: e1a00004 mov r0, r4 <== NOT EXECUTED 3001198c: e1a01006 mov r1, r6 <== NOT EXECUTED 30011990: e3a02000 mov r2, #0 <== NOT EXECUTED 30011994: e1a0e00f mov lr, pc <== NOT EXECUTED 30011998: e12fff1b bx fp <== NOT EXECUTED
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
3001199c: eaffffea b 3001194c <_POSIX_signals_Check_signal+0xb0> <== NOT EXECUTED
30011ff0 <_POSIX_signals_Clear_process_signals>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30011ff0: e10f2000 mrs r2, CPSR <== NOT EXECUTED 30011ff4: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 30011ff8: 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 ) {
30011ffc: e59f1050 ldr r1, [pc, #80] ; 30012054 <_POSIX_signals_Clear_process_signals+0x64><== NOT EXECUTED 30012000: e0803080 add r3, r0, r0, lsl #1 <== NOT EXECUTED 30012004: e1a03103 lsl r3, r3, #2 <== NOT EXECUTED 30012008: e7911003 ldr r1, [r1, r3] <== NOT EXECUTED 3001200c: e3510002 cmp r1, #2 <== NOT EXECUTED 30012010: 0a000007 beq 30012034 <_POSIX_signals_Clear_process_signals+0x44><== NOT EXECUTED
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
30012014: e59f303c ldr r3, [pc, #60] ; 30012058 <_POSIX_signals_Clear_process_signals+0x68><== NOT EXECUTED 30012018: e3a0c001 mov ip, #1 <== NOT EXECUTED 3001201c: e5931000 ldr r1, [r3] <== NOT EXECUTED 30012020: e2400001 sub r0, r0, #1 <== NOT EXECUTED 30012024: e1c1001c bic r0, r1, ip, lsl r0 <== NOT EXECUTED 30012028: e5830000 str r0, [r3] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001202c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
_ISR_Enable( level );
}
30012030: e12fff1e bx lr <== NOT EXECUTED 30012034: e59f1020 ldr r1, [pc, #32] ; 3001205c <_POSIX_signals_Clear_process_signals+0x6c><== 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 );
30012038: 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 ] ) )
3001203c: e7913003 ldr r3, [r1, r3] <== NOT EXECUTED 30012040: e08c1001 add r1, ip, r1 <== NOT EXECUTED 30012044: e1530001 cmp r3, r1 <== NOT EXECUTED 30012048: 0afffff1 beq 30012014 <_POSIX_signals_Clear_process_signals+0x24><== NOT EXECUTED 3001204c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
}
30012050: e12fff1e bx lr <== NOT EXECUTED
300119a8 <_POSIX_signals_Clear_signals>:
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
300119a8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
300119ac: e5ddc018 ldrb ip, [sp, #24] <== NOT EXECUTED
300119b0: 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 )
300119b4: e35c0000 cmp ip, #0 <== NOT EXECUTED
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
300119b8: e1a06002 mov r6, r2 <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
300119bc: e2411001 sub r1, r1, #1 <== NOT EXECUTED 300119c0: e3a02001 mov r2, #1 <== NOT EXECUTED 300119c4: e1a01112 lsl r1, r2, 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 )
signals_blocked = ~api->signals_blocked;
300119c8: 159020d0 ldrne r2, [r0, #208] ; 0xd0 <== NOT EXECUTED
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
300119cc: 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;
300119d0: 11e02002 mvnne r2, r2 <== NOT EXECUTED
else
signals_blocked = SIGNAL_ALL_MASK;
300119d4: 03e02000 mvneq r2, #0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300119d8: e10f5000 mrs r5, CPSR <== NOT EXECUTED 300119dc: e385c080 orr ip, r5, #128 ; 0x80 <== NOT EXECUTED 300119e0: 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 ) {
300119e4: e3530000 cmp r3, #0 <== NOT EXECUTED 300119e8: 0a00000f beq 30011a2c <_POSIX_signals_Clear_signals+0x84> <== NOT EXECUTED
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
300119ec: e59f30c4 ldr r3, [pc, #196] ; 30011ab8 <_POSIX_signals_Clear_signals+0x110><== NOT EXECUTED 300119f0: e5930000 ldr r0, [r3] <== NOT EXECUTED 300119f4: e0011000 and r1, r1, r0 <== NOT EXECUTED 300119f8: e0110002 ands r0, r1, r2 <== NOT EXECUTED 300119fc: 0a000008 beq 30011a24 <_POSIX_signals_Clear_signals+0x7c> <== NOT EXECUTED
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
30011a00: e0843084 add r3, r4, r4, lsl #1 <== NOT EXECUTED 30011a04: e59f20b0 ldr r2, [pc, #176] ; 30011abc <_POSIX_signals_Clear_signals+0x114><== NOT EXECUTED 30011a08: e1a03103 lsl r3, r3, #2 <== NOT EXECUTED 30011a0c: e7922003 ldr r2, [r2, r3] <== NOT EXECUTED 30011a10: e3520002 cmp r2, #2 <== NOT EXECUTED 30011a14: 0a00000d beq 30011a50 <_POSIX_signals_Clear_signals+0xa8> <== NOT EXECUTED
&psiginfo->Node
);
} else
do_callout = false;
}
_POSIX_signals_Clear_process_signals( signo );
30011a18: e1a00004 mov r0, r4 <== NOT EXECUTED 30011a1c: eb000173 bl 30011ff0 <_POSIX_signals_Clear_process_signals><== NOT EXECUTED
do_callout = true;
30011a20: e3a00001 mov r0, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30011a24: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
do_callout = true;
}
}
_ISR_Enable( level );
return do_callout;
}
30011a28: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
_POSIX_signals_Clear_process_signals( signo );
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
30011a2c: e590c0d4 ldr ip, [r0, #212] ; 0xd4 <== NOT EXECUTED 30011a30: e001400c and r4, r1, ip <== NOT EXECUTED 30011a34: e1140002 tst r4, r2 <== NOT EXECUTED
api->signals_pending &= ~mask;
30011a38: 11cc1001 bicne r1, ip, r1 <== NOT EXECUTED 30011a3c: 158010d4 strne r1, [r0, #212] ; 0xd4 <== NOT EXECUTED
bool do_callout;
POSIX_signals_Siginfo_node *psiginfo;
mask = signo_to_mask( signo );
do_callout = false;
30011a40: 01a00003 moveq r0, r3 <== NOT EXECUTED
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
api->signals_pending &= ~mask;
do_callout = true;
30011a44: 13a00001 movne r0, #1 <== NOT EXECUTED 30011a48: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
}
}
_ISR_Enable( level );
return do_callout;
}
30011a4c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30011a50: e59f2068 ldr r2, [pc, #104] ; 30011ac0 <_POSIX_signals_Clear_signals+0x118><== 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 );
30011a54: e2831004 add r1, r3, #4 <== NOT EXECUTED 30011a58: e7927003 ldr r7, [r2, r3] <== NOT EXECUTED 30011a5c: 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))
30011a60: e1570001 cmp r7, r1 <== NOT EXECUTED 30011a64: e082c003 add ip, r2, r3 <== NOT EXECUTED 30011a68: 0a00000f beq 30011aac <_POSIX_signals_Clear_signals+0x104> <== 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;
30011a6c: e1a08007 mov r8, r7 <== NOT EXECUTED 30011a70: e4981008 ldr r1, [r8], #8 <== 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 );
30011a74: e1a00004 mov r0, r4 <== NOT EXECUTED
head->next = new_first;
30011a78: e7821003 str r1, [r2, r3] <== NOT EXECUTED
new_first->previous = head;
30011a7c: e581c004 str ip, [r1, #4] <== NOT EXECUTED 30011a80: eb00015a bl 30011ff0 <_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 ) {
*info = psiginfo->Info;
30011a84: e8980007 ldm r8, {r0, r1, r2} <== NOT EXECUTED
30011a88: e8860007 stm r6, {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;
30011a8c: e59f3030 ldr r3, [pc, #48] ; 30011ac4 <_POSIX_signals_Clear_signals+0x11c><== NOT EXECUTED 30011a90: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
the_node->next = tail;
30011a94: e2831004 add r1, r3, #4 <== NOT EXECUTED 30011a98: e5871000 str r1, [r7] <== NOT EXECUTED
tail->previous = the_node;
30011a9c: e5837008 str r7, [r3, #8] <== NOT EXECUTED
old_last->next = the_node;
30011aa0: e5827000 str r7, [r2] <== NOT EXECUTED
the_node->previous = old_last;
30011aa4: e5872004 str r2, [r7, #4] <== NOT EXECUTED 30011aa8: eaffffda b 30011a18 <_POSIX_signals_Clear_signals+0x70> <== 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 );
30011aac: e1a00004 mov r0, r4 <== NOT EXECUTED 30011ab0: eb00014e bl 30011ff0 <_POSIX_signals_Clear_process_signals><== NOT EXECUTED 30011ab4: eaffffd7 b 30011a18 <_POSIX_signals_Clear_signals+0x70> <== NOT EXECUTED
3000a94c <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000a94c: e3a0301b mov r3, #27 <== NOT EXECUTED 3000a950: e3a01001 mov r1, #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(
3000a954: e2432001 sub r2, r3, #1 <== NOT EXECUTED
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
3000a958: e0102211 ands r2, r0, r1, lsl r2 <== NOT EXECUTED 3000a95c: 1a00000b bne 3000a990 <_POSIX_signals_Get_lowest+0x44> <== NOT EXECUTED
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000a960: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000a964: e3530020 cmp r3, #32 <== NOT EXECUTED 3000a968: 1afffff9 bne 3000a954 <_POSIX_signals_Get_lowest+0x8> <== NOT EXECUTED 3000a96c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a970: e1a01003 mov r1, r3 <== NOT EXECUTED 3000a974: ea000002 b 3000a984 <_POSIX_signals_Get_lowest+0x38> <== NOT EXECUTED
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
3000a978: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000a97c: e353001b cmp r3, #27 <== NOT EXECUTED 3000a980: 0a000002 beq 3000a990 <_POSIX_signals_Get_lowest+0x44> <== 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(
3000a984: e2432001 sub r2, 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 ) ) {
3000a988: e0102211 ands r2, r0, r1, lsl r2 <== NOT EXECUTED 3000a98c: 0afffff9 beq 3000a978 <_POSIX_signals_Get_lowest+0x2c> <== 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; }
3000a990: e1a00003 mov r0, r3 <== NOT EXECUTED 3000a994: e12fff1e bx lr <== NOT EXECUTED
3000ef54 <_POSIX_signals_Post_switch_extension>:
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
3000ef54: e92d4070 push {r4, r5, r6, lr}
POSIX_API_Control *api;
int signo;
ISR_Level level;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000ef58: e59050fc ldr r5, [r0, #252] ; 0xfc
/*
* api may be NULL in case of a thread close in progress
*/
if ( !api )
3000ef5c: e3550000 cmp r5, #0
3000ef60: 08bd8070 popeq {r4, r5, r6, pc}
3000ef64: e59f6094 ldr r6, [pc, #148] ; 3000f000 <_POSIX_signals_Post_switch_extension+0xac>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ef68: e10f3000 mrs r3, CPSR 3000ef6c: e3832080 orr r2, r3, #128 ; 0x80 3000ef70: e129f002 msr CPSR_fc, r2
* 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)) ) {
3000ef74: e5960000 ldr r0, [r6] 3000ef78: e59520d4 ldr r2, [r5, #212] ; 0xd4
* 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 &
3000ef7c: e59510d0 ldr r1, [r5, #208] ; 0xd0 3000ef80: e1802002 orr r2, r0, r2 3000ef84: e1c22001 bic r2, r2, r1 3000ef88: e3520000 cmp r2, #0
3000ef8c: 0a000019 beq 3000eff8 <_POSIX_signals_Post_switch_extension+0xa4>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ef90: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000ef94: e3a0401b mov r4, #27 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
3000ef98: e1a01004 mov r1, r4 <== NOT EXECUTED 3000ef9c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000efa0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000efa4: eb000a3c bl 3001189c <_POSIX_signals_Check_signal> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, true );
3000efa8: e3a02001 mov r2, #1 <== NOT EXECUTED 3000efac: e1a01004 mov r1, r4 <== NOT EXECUTED 3000efb0: e1a00005 mov r0, r5 <== NOT EXECUTED
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000efb4: e0844002 add r4, r4, r2 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
3000efb8: eb000a37 bl 3001189c <_POSIX_signals_Check_signal> <== NOT EXECUTED
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
3000efbc: e3540020 cmp r4, #32 <== NOT EXECUTED 3000efc0: 1afffff4 bne 3000ef98 <_POSIX_signals_Post_switch_extension+0x44><== NOT EXECUTED 3000efc4: e3a04001 mov r4, #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 );
3000efc8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000efcc: e3a02000 mov r2, #0 <== NOT EXECUTED 3000efd0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000efd4: eb000a30 bl 3001189c <_POSIX_signals_Check_signal> <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, true );
3000efd8: e3a02001 mov r2, #1 <== NOT EXECUTED 3000efdc: e1a01004 mov r1, r4 <== NOT EXECUTED 3000efe0: e1a00005 mov r0, r5 <== 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++ ) {
3000efe4: e0844002 add r4, r4, r2 <== NOT EXECUTED
_POSIX_signals_Check_signal( api, signo, false );
_POSIX_signals_Check_signal( api, signo, true );
3000efe8: eb000a2b bl 3001189c <_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++ ) {
3000efec: e354001b cmp r4, #27 <== NOT EXECUTED 3000eff0: 1afffff4 bne 3000efc8 <_POSIX_signals_Post_switch_extension+0x74><== NOT EXECUTED 3000eff4: eaffffdb b 3000ef68 <_POSIX_signals_Post_switch_extension+0x14><== NOT EXECUTED
3000eff8: e129f003 msr CPSR_fc, r3
3000effc: e8bd8070 pop {r4, r5, r6, pc}
30026f90 <_POSIX_signals_Set_process_signals>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30026f90: e10f2000 mrs r2, CPSR <== NOT EXECUTED 30026f94: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 30026f98: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
)
{
ISR_Level level;
_ISR_Disable( level );
_POSIX_signals_Pending |= mask;
30026f9c: e59f3010 ldr r3, [pc, #16] ; 30026fb4 <_POSIX_signals_Set_process_signals+0x24><== NOT EXECUTED 30026fa0: e5931000 ldr r1, [r3] <== NOT EXECUTED 30026fa4: e1800001 orr r0, r0, r1 <== NOT EXECUTED 30026fa8: e5830000 str r0, [r3] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30026fac: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level ); }
30026fb0: e12fff1e bx lr <== NOT EXECUTED
300099a4 <_POSIX_signals_Ualarm_TSR>:
void _POSIX_signals_Ualarm_TSR(
Objects_Id id __attribute__((unused)),
void *argument __attribute__((unused))
)
{
300099a4: e92d4010 push {r4, lr} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Reset(
Watchdog_Control *the_watchdog
)
{
(void) _Watchdog_Remove( the_watchdog );
300099a8: e59f4020 ldr r4, [pc, #32] ; 300099d0 <_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 );
300099ac: ebfff372 bl 3000677c <getpid> <== NOT EXECUTED 300099b0: e3a0100e mov r1, #14 <== NOT EXECUTED 300099b4: ebffff79 bl 300097a0 <kill> <== NOT EXECUTED 300099b8: e1a00004 mov r0, r4 <== NOT EXECUTED 300099bc: eb000f7e bl 3000d7bc <_Watchdog_Remove> <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
300099c0: e59f000c ldr r0, [pc, #12] ; 300099d4 <_POSIX_signals_Ualarm_TSR+0x30><== NOT EXECUTED 300099c4: e1a01004 mov r1, r4 <== NOT EXECUTED
/*
* If the reset interval is non-zero, reschedule ourselves.
*/
_Watchdog_Reset( &_POSIX_signals_Ualarm_timer );
}
300099c8: e8bd4010 pop {r4, lr} <== NOT EXECUTED
300099cc: ea000f0b b 3000d600 <_Watchdog_Insert> <== NOT EXECUTED
30026fb8 <_POSIX_signals_Unblock_thread>:
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
30026fb8: e590c010 ldr ip, [r0, #16] <== NOT EXECUTED 30026fbc: e59f3110 ldr r3, [pc, #272] ; 300270d4 <_POSIX_signals_Unblock_thread+0x11c><== NOT EXECUTED
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
30026fc0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
30026fc4: e59f7108 ldr r7, [pc, #264] ; 300270d4 <_POSIX_signals_Unblock_thread+0x11c><== NOT EXECUTED 30026fc8: e00c3003 and r3, ip, r3 <== NOT EXECUTED 30026fcc: e2416001 sub r6, r1, #1 <== NOT EXECUTED 30026fd0: e3a05001 mov r5, #1 <== NOT EXECUTED 30026fd4: e1530007 cmp r3, r7 <== NOT EXECUTED
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
30026fd8: 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 ];
30026fdc: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED 30026fe0: e1a06615 lsl r6, r5, r6 <== NOT EXECUTED
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
30026fe4: 0a000017 beq 30027048 <_POSIX_signals_Unblock_thread+0x90> <== NOT EXECUTED
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
30026fe8: e59330d0 ldr r3, [r3, #208] ; 0xd0 <== NOT EXECUTED 30026fec: e1d66003 bics r6, r6, r3 <== NOT EXECUTED 30026ff0: 0a000012 beq 30027040 <_POSIX_signals_Unblock_thread+0x88> <== 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 ) ) {
30026ff4: e21c6201 ands r6, ip, #268435456 ; 0x10000000 <== NOT EXECUTED 30026ff8: 0a00000e beq 30027038 <_POSIX_signals_Unblock_thread+0x80> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
30026ffc: e59f50d4 ldr r5, [pc, #212] ; 300270d8 <_POSIX_signals_Unblock_thread+0x120><== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
30027000: e3a03004 mov r3, #4 <== NOT EXECUTED 30027004: e00c5005 and r5, ip, 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) )
30027008: 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;
3002700c: e5803034 str r3, [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) )
30027010: 1a00002c bne 300270c8 <_POSIX_signals_Unblock_thread+0x110><== NOT EXECUTED
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
30027014: e21c0008 ands r0, ip, #8 <== NOT EXECUTED
30027018: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
3002701c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30027020: ebffadc3 bl 30012734 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30027024: e1a00004 mov r0, r4 <== NOT EXECUTED 30027028: e59f10ac ldr r1, [pc, #172] ; 300270dc <_POSIX_signals_Unblock_thread+0x124><== NOT EXECUTED 3002702c: ebffa8da bl 3001139c <_Thread_Clear_state> <== 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;
30027030: e1a00005 mov r0, r5 <== NOT EXECUTED
30027034: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
30027038: e35c0000 cmp ip, #0 <== NOT EXECUTED 3002703c: 0a000016 beq 3002709c <_POSIX_signals_Unblock_thread+0xe4> <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
30027040: e1a00006 mov r0, r6 <== NOT EXECUTED
30027044: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
30027048: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED 3002704c: e1160000 tst r6, r0 <== NOT EXECUTED 30027050: 0a00000d beq 3002708c <_POSIX_signals_Unblock_thread+0xd4> <== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
30027054: e3a03004 mov r3, #4 <== NOT EXECUTED 30027058: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
the_info = (siginfo_t *) the_thread->Wait.return_argument;
3002705c: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
if ( !info ) {
30027060: e3520000 cmp r2, #0 <== NOT EXECUTED
the_info->si_signo = signo;
30027064: 05831000 streq r1, [r3] <== NOT EXECUTED
the_info->si_code = SI_USER;
30027068: 03a01001 moveq r1, #1 <== NOT EXECUTED
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
3002706c: 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;
30027070: 05831004 streq r1, [r3, #4] <== NOT EXECUTED
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
30027074: 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;
30027078: 05832008 streq r2, [r3, #8] <== NOT EXECUTED
} else {
*the_info = *info;
}
_Thread_queue_Extract_with_proxy( the_thread );
3002707c: e1a00004 mov r0, r4 <== NOT EXECUTED 30027080: ebffab66 bl 30011e20 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED
return true;
30027084: e3a00001 mov r0, #1 <== NOT EXECUTED
30027088: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
3002708c: e59300d0 ldr r0, [r3, #208] ; 0xd0 <== NOT EXECUTED
30027090: e1d60000 bics r0, r6, r0 <== NOT EXECUTED
30027094: 1affffee bne 30027054 <_POSIX_signals_Unblock_thread+0x9c> <== NOT EXECUTED
30027098: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
3002709c: e59f203c ldr r2, [pc, #60] ; 300270e0 <_POSIX_signals_Unblock_thread+0x128><== NOT EXECUTED
300270a0: e5920000 ldr r0, [r2] <== NOT EXECUTED
300270a4: e3500000 cmp r0, #0 <== NOT EXECUTED
300270a8: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
300270ac: e5923004 ldr r3, [r2, #4] <== NOT EXECUTED
300270b0: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
300270b4: 05c25010 strbeq r5, [r2, #16] <== NOT EXECUTED
}
}
return false;
300270b8: 01a0000c moveq r0, ip <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
300270bc: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
}
}
return false;
300270c0: e1a0000c mov r0, ip <== NOT EXECUTED
}
300270c4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== 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 );
300270c8: ebffab54 bl 30011e20 <_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;
300270cc: e3a00000 mov r0, #0 <== NOT EXECUTED
300270d0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000b994 <_Protected_heap_Extend>:
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000b994: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
bool extend_ok;
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000b998: e59f4040 ldr r4, [pc, #64] ; 3000b9e0 <_Protected_heap_Extend+0x4c><== NOT EXECUTED
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000b99c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000b9a0: e1a05000 mov r5, r0 <== NOT EXECUTED 3000b9a4: e1a07001 mov r7, r1 <== NOT EXECUTED 3000b9a8: e1a06002 mov r6, r2 <== NOT EXECUTED
bool extend_ok;
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000b9ac: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000b9b0: ebfffb88 bl 3000a7d8 <_API_Mutex_Lock> <== NOT EXECUTED
extend_ok = _Heap_Extend(the_heap, starting_address, size, &amount_extended);
3000b9b4: e1a01007 mov r1, r7 <== NOT EXECUTED 3000b9b8: e1a02006 mov r2, r6 <== NOT EXECUTED 3000b9bc: e1a0300d mov r3, sp <== NOT EXECUTED 3000b9c0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b9c4: eb001266 bl 30010364 <_Heap_Extend> <== NOT EXECUTED 3000b9c8: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
3000b9cc: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000b9d0: ebfffb9c bl 3000a848 <_API_Mutex_Unlock> <== NOT EXECUTED
return extend_ok; }
3000b9d4: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b9d8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b9dc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000be24 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
3000be24: e92d4070 push {r4, r5, r6, lr}
if ( !the_heap )
3000be28: e2505000 subs r5, r0, #0
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
3000be2c: e1a06001 mov r6, r1
if ( !the_heap )
return false;
3000be30: 01a00005 moveq r0, r5
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
if ( !the_heap )
3000be34: 08bd8070 popeq {r4, r5, r6, pc}
return false;
if ( !the_info )
3000be38: e3510000 cmp r1, #0
3000be3c: 0a000009 beq 3000be68 <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
3000be40: e59f4028 ldr r4, [pc, #40] ; 3000be70 <_Protected_heap_Get_information+0x4c> 3000be44: e5940000 ldr r0, [r4] 3000be48: ebfffb77 bl 3000ac2c <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
3000be4c: e1a00005 mov r0, r5 3000be50: e1a01006 mov r1, r6 3000be54: eb001389 bl 30010c80 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
3000be58: e5940000 ldr r0, [r4] 3000be5c: ebfffb8e bl 3000ac9c <_API_Mutex_Unlock>
return true;
3000be60: e3a00001 mov r0, #1
3000be64: e8bd8070 pop {r4, r5, r6, pc}
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
3000be68: e1a00001 mov r0, r1 <== NOT EXECUTED
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
3000be6c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30010dd0 <_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 ) {
30010dd0: e59f3054 ldr r3, [pc, #84] ; 30010e2c <_Protected_heap_Walk+0x5c><== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
30010dd4: 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 ) {
30010dd8: e5933000 ldr r3, [r3] <== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
30010ddc: e1a07000 mov r7, 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 ) {
30010de0: e3530000 cmp r3, #0 <== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
30010de4: e1a06001 mov r6, r1 <== NOT EXECUTED 30010de8: e20250ff and r5, 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 ) {
30010dec: 0a000002 beq 30010dfc <_Protected_heap_Walk+0x2c> <== NOT EXECUTED
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
30010df0: e1a02005 mov r2, r5 <== NOT EXECUTED
} return status; }
30010df4: 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 );
30010df8: eafffbda b 3000fd68 <_Heap_Walk> <== NOT EXECUTED
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
30010dfc: e59f402c ldr r4, [pc, #44] ; 30010e30 <_Protected_heap_Walk+0x60><== NOT EXECUTED 30010e00: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010e04: ebfff7d1 bl 3000ed50 <_API_Mutex_Lock> <== NOT EXECUTED
status = _Heap_Walk( the_heap, source, do_dump );
30010e08: e1a02005 mov r2, r5 <== NOT EXECUTED 30010e0c: e1a01006 mov r1, r6 <== NOT EXECUTED 30010e10: e1a00007 mov r0, r7 <== NOT EXECUTED 30010e14: ebfffbd3 bl 3000fd68 <_Heap_Walk> <== NOT EXECUTED 30010e18: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
30010e1c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010e20: ebfff7e6 bl 3000edc0 <_API_Mutex_Unlock> <== NOT EXECUTED
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
30010e24: e1a00005 mov r0, r5 <== NOT EXECUTED
30010e28: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000fab0 <_RTEMS_Tasks_Invoke_task_variable_dtor>:
{
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
3000fab0: e59f303c ldr r3, [pc, #60] ; 3000faf4 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x44><== NOT EXECUTED
void _RTEMS_Tasks_Invoke_task_variable_dtor(
Thread_Control *the_thread,
rtems_task_variable_t *tvp
)
{
3000fab4: e92d4010 push {r4, lr} <== NOT EXECUTED
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
3000fab8: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
void _RTEMS_Tasks_Invoke_task_variable_dtor(
Thread_Control *the_thread,
rtems_task_variable_t *tvp
)
{
3000fabc: e1a04001 mov r4, r1 <== NOT EXECUTED
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
3000fac0: e1520000 cmp r2, r0 <== NOT EXECUTED
value = *tvp->ptr;
3000fac4: 05912004 ldreq r2, [r1, #4] <== NOT EXECUTED
)
{
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
3000fac8: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
if (_Thread_Is_executing(the_thread)) {
value = *tvp->ptr;
*tvp->ptr = tvp->gval;
3000facc: 05911008 ldreq r1, [r1, #8] <== NOT EXECUTED
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
value = *tvp->ptr;
3000fad0: 05920000 ldreq r0, [r2] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
} else {
value = tvp->tval;
3000fad4: 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;
3000fad8: 05821000 streq r1, [r2] <== NOT EXECUTED
} else {
value = tvp->tval;
}
if ( dtor )
3000fadc: e3530000 cmp r3, #0 <== NOT EXECUTED
(*dtor)(value);
3000fae0: 11a0e00f movne lr, pc <== NOT EXECUTED 3000fae4: 112fff13 bxne r3 <== NOT EXECUTED
_Workspace_Free(tvp);
3000fae8: e1a00004 mov r0, r4 <== NOT EXECUTED
}
3000faec: e8bd4010 pop {r4, lr} <== NOT EXECUTED
}
if ( dtor )
(*dtor)(value);
_Workspace_Free(tvp);
3000faf0: eafff5fd b 3000d2ec <_Workspace_Free> <== NOT EXECUTED
3000f97c <_RTEMS_tasks_Delete_extension>:
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
3000f97c: e92d4030 push {r4, r5, lr}
3000f980: e1a05001 mov r5, r1
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
3000f984: e5911104 ldr r1, [r1, #260] ; 0x104
deleted->task_variables = NULL;
3000f988: e3a03000 mov r3, #0
while (tvp) {
3000f98c: e3510000 cmp r1, #0
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
3000f990: e5853104 str r3, [r5, #260] ; 0x104
while (tvp) {
3000f994: 1a000001 bne 3000f9a0 <_RTEMS_tasks_Delete_extension+0x24>
3000f998: ea000005 b 3000f9b4 <_RTEMS_tasks_Delete_extension+0x38>
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
tvp = next;
3000f99c: e1a01004 mov r1, r4 <== NOT EXECUTED
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
3000f9a0: e5914000 ldr r4, [r1] <== NOT EXECUTED
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
3000f9a4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f9a8: eb000040 bl 3000fab0 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
3000f9ac: e3540000 cmp r4, #0 <== NOT EXECUTED 3000f9b0: 1afffff9 bne 3000f99c <_RTEMS_tasks_Delete_extension+0x20> <== NOT EXECUTED
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
3000f9b4: e59500f8 ldr r0, [r5, #248] ; 0xf8 3000f9b8: ebfff64b bl 3000d2ec <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
3000f9bc: e3a03000 mov r3, #0 3000f9c0: e58530f8 str r3, [r5, #248] ; 0xf8
}
3000f9c4: e8bd8030 pop {r4, r5, pc}
3000f870 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
3000f870: e5903104 ldr r3, [r0, #260] ; 0x104
while (tvp) {
3000f874: e3530000 cmp r3, #0
3000f878: 0a000007 beq 3000f89c <_RTEMS_tasks_Switch_extension+0x2c>
tvp->tval = *tvp->ptr;
3000f87c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
3000f880: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
3000f884: e592c000 ldr ip, [r2] <== NOT EXECUTED 3000f888: e583c00c str ip, [r3, #12] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
3000f88c: e5933000 ldr r3, [r3] <== NOT EXECUTED
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
3000f890: e5820000 str r0, [r2] <== NOT EXECUTED
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
3000f894: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f898: 1afffff7 bne 3000f87c <_RTEMS_tasks_Switch_extension+0xc> <== NOT EXECUTED
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
3000f89c: e5913104 ldr r3, [r1, #260] ; 0x104
while (tvp) {
3000f8a0: e3530000 cmp r3, #0 3000f8a4: 012fff1e bxeq lr
tvp->gval = *tvp->ptr;
3000f8a8: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
*tvp->ptr = tvp->tval;
3000f8ac: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
3000f8b0: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000f8b4: e5830008 str r0, [r3, #8] <== NOT EXECUTED
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
3000f8b8: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
3000f8bc: e5821000 str r1, [r2] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
3000f8c0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f8c4: 1afffff7 bne 3000f8a8 <_RTEMS_tasks_Switch_extension+0x38> <== NOT EXECUTED 3000f8c8: e12fff1e bx lr <== NOT EXECUTED
3000b140 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
3000b140: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b144: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000b148: e1a01000 mov r1, r0 <== NOT EXECUTED
3000b14c: e1a0200d mov r2, sp <== NOT EXECUTED
3000b150: e59f0094 ldr r0, [pc, #148] ; 3000b1ec <_Rate_monotonic_Timeout+0xac><== NOT EXECUTED
3000b154: eb0007a0 bl 3000cfdc <_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 ) {
3000b158: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000b15c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000b160: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b164: 1a000010 bne 3000b1ac <_Rate_monotonic_Timeout+0x6c> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_thread = the_period->owner;
3000b168: 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);
3000b16c: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
3000b170: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 3000b174: 0a000003 beq 3000b188 <_Rate_monotonic_Timeout+0x48> <== NOT EXECUTED 3000b178: e5902020 ldr r2, [r0, #32] <== NOT EXECUTED 3000b17c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000b180: e1520003 cmp r2, r3 <== NOT EXECUTED 3000b184: 0a000014 beq 3000b1dc <_Rate_monotonic_Timeout+0x9c> <== 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 ) {
3000b188: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 3000b18c: 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;
3000b190: 13a03004 movne r3, #4 <== NOT EXECUTED 3000b194: 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 ) {
3000b198: 0a000005 beq 3000b1b4 <_Rate_monotonic_Timeout+0x74> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000b19c: e59f304c ldr r3, [pc, #76] ; 3000b1f0 <_Rate_monotonic_Timeout+0xb0><== NOT EXECUTED 3000b1a0: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b1a4: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000b1a8: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
3000b1ac: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b1b0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
_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 ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
3000b1b4: e3a03003 mov r3, #3 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
3000b1b8: e1a00004 mov r0, r4 <== NOT EXECUTED
_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 ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
3000b1bc: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
3000b1c0: ebfffe54 bl 3000ab18 <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000b1c4: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000b1c8: e59f0024 ldr r0, [pc, #36] ; 3000b1f4 <_Rate_monotonic_Timeout+0xb4><== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000b1cc: e584301c str r3, [r4, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000b1d0: e2841010 add r1, r4, #16 <== NOT EXECUTED 3000b1d4: eb000ec2 bl 3000ece4 <_Watchdog_Insert> <== NOT EXECUTED 3000b1d8: eaffffef b 3000b19c <_Rate_monotonic_Timeout+0x5c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000b1dc: e59f1014 ldr r1, [pc, #20] ; 3000b1f8 <_Rate_monotonic_Timeout+0xb8><== NOT EXECUTED 3000b1e0: eb0009fb bl 3000d9d4 <_Thread_Clear_state> <== NOT EXECUTED
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
3000b1e4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b1e8: eafffff4 b 3000b1c0 <_Rate_monotonic_Timeout+0x80> <== NOT EXECUTED
3000ad88 <_TOD_Get_uptime_as_timespec>:
*/
void _TOD_Get_uptime_as_timespec(
struct timespec *uptime
)
{
3000ad88: e92d4010 push {r4, lr} <== NOT EXECUTED
3000ad8c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
3000ad90: e1a04000 mov r4, r0 <== NOT EXECUTED
Timestamp_Control uptime_ts;
/* assume time checked for NULL by caller */
_TOD_Get_uptime( &uptime_ts );
3000ad94: e1a0000d mov r0, sp <== NOT EXECUTED 3000ad98: eb001524 bl 30010230 <_TOD_Get_uptime> <== NOT EXECUTED
_Timestamp_To_timespec( &uptime_ts, uptime );
3000ad9c: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
3000ada0: e884000c stm r4, {r2, r3} <== NOT EXECUTED
}
3000ada4: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000ada8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c434 <_TOD_Set>:
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000c434: e59f3068 ldr r3, [pc, #104] ; 3000c4a4 <_TOD_Set+0x70>
*/
void _TOD_Set(
const struct timespec *time
)
{
3000c438: e92d4030 push {r4, r5, lr}
3000c43c: e5932000 ldr r2, [r3]
3000c440: e1a05000 mov r5, r0
3000c444: e2822001 add r2, r2, #1
3000c448: e5832000 str r2, [r3]
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
3000c44c: e59f4054 ldr r4, [pc, #84] ; 3000c4a8 <_TOD_Set+0x74>
if ( time->tv_sec < seconds )
3000c450: e5902000 ldr r2, [r0]
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
3000c454: e5943000 ldr r3, [r4]
if ( time->tv_sec < seconds )
3000c458: e1530002 cmp r3, r2
3000c45c: ca00000b bgt 3000c490 <_TOD_Set+0x5c>
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
_Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );
3000c460: e59f0044 ldr r0, [pc, #68] ; 3000c4ac <_TOD_Set+0x78> 3000c464: e3a01000 mov r1, #0 3000c468: e0632002 rsb r2, r3, r2 3000c46c: eb000a0d bl 3000eca8 <_Watchdog_Adjust>
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
else
_Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
/* POSIX format TOD (timespec) */
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
3000c470: e895000c ldm r5, {r2, r3}
3000c474: e5843004 str r3, [r4, #4]
_TOD_Is_set = true;
3000c478: e59f3030 ldr r3, [pc, #48] ; 3000c4b0 <_TOD_Set+0x7c>
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
else
_Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
/* POSIX format TOD (timespec) */
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
3000c47c: e5842000 str r2, [r4]
_TOD_Is_set = true;
3000c480: e3a02001 mov r2, #1 3000c484: e5c32000 strb r2, [r3]
_TOD_Activate();
_Thread_Enable_dispatch();
}
3000c488: e8bd4030 pop {r4, r5, lr}
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
_TOD_Is_set = true;
_TOD_Activate();
_Thread_Enable_dispatch();
3000c48c: ea000612 b 3000dcdc <_Thread_Enable_dispatch>
3000c490: e59f0014 ldr r0, [pc, #20] ; 3000c4ac <_TOD_Set+0x78> <== NOT EXECUTED 3000c494: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c498: e0622003 rsb r2, r2, r3 <== NOT EXECUTED 3000c49c: eb000a01 bl 3000eca8 <_Watchdog_Adjust> <== NOT EXECUTED 3000c4a0: eafffff2 b 3000c470 <_TOD_Set+0x3c> <== NOT EXECUTED
3000a9e8 <_TOD_Tickle_ticks>:
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
3000a9e8: e92d4010 push {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() );
3000a9ec: e59f2064 ldr r2, [pc, #100] ; 3000aa58 <_TOD_Tickle_ticks+0x70>
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000a9f0: e59f3064 ldr r3, [pc, #100] ; 3000aa5c <_TOD_Tickle_ticks+0x74>
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000a9f4: e592100c ldr r1, [r2, #12]
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000a9f8: e5932000 ldr r2, [r3]
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000a9fc: e061c281 rsb ip, r1, r1, lsl #5
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
3000aa00: e24dd008 sub sp, sp, #8
/* 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;
3000aa04: e2822001 add r2, r2, #1
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000aa08: e081c10c add ip, r1, ip, lsl #2 3000aa0c: e1a0c18c lsl ip, ip, #3 3000aa10: e3a0e000 mov lr, #0
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000aa14: e1a0100d mov r1, sp
/* 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;
3000aa18: e5832000 str r2, [r3]
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000aa1c: e59f003c ldr r0, [pc, #60] ; 3000aa60 <_TOD_Tickle_ticks+0x78>
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000aa20: e58de000 str lr, [sp] 3000aa24: e58dc004 str ip, [sp, #4]
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000aa28: eb000873 bl 3000cbfc <_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 );
3000aa2c: e59f0030 ldr r0, [pc, #48] ; 3000aa64 <_TOD_Tickle_ticks+0x7c> 3000aa30: e1a0100d mov r1, sp 3000aa34: eb000870 bl 3000cbfc <_Timespec_Add_to>
while ( seconds ) {
3000aa38: e2504000 subs r4, r0, #0
3000aa3c: 0a000003 beq 3000aa50 <_TOD_Tickle_ticks+0x68>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
3000aa40: e59f0020 ldr r0, [pc, #32] ; 3000aa68 <_TOD_Tickle_ticks+0x80><== NOT EXECUTED 3000aa44: eb0009e1 bl 3000d1d0 <_Watchdog_Tickle> <== NOT EXECUTED 3000aa48: e2544001 subs r4, r4, #1 <== NOT EXECUTED 3000aa4c: 1afffffb bne 3000aa40 <_TOD_Tickle_ticks+0x58> <== NOT EXECUTED
_Watchdog_Tickle_seconds();
seconds--;
}
}
3000aa50: e28dd008 add sp, sp, #8
3000aa54: e8bd8010 pop {r4, pc}
3000abd4 <_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();
3000abd4: e59f30b0 ldr r3, [pc, #176] ; 3000ac8c <_TOD_Validate+0xb8>
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
3000abd8: 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) ||
3000abdc: 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();
3000abe0: 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;
3000abe4: 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) ||
3000abe8: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
3000abec: e59f009c ldr r0, [pc, #156] ; 3000ac90 <_TOD_Validate+0xbc> 3000abf0: eb004a50 bl 3001d538 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
3000abf4: e5943018 ldr r3, [r4, #24] 3000abf8: e1500003 cmp r0, r3
3000abfc: 9a00001e bls 3000ac7c <_TOD_Validate+0xa8>
(the_tod->ticks >= ticks_per_second) ||
3000ac00: e5943014 ldr r3, [r4, #20] 3000ac04: e353003b cmp r3, #59 ; 0x3b
3000ac08: 8a00001b bhi 3000ac7c <_TOD_Validate+0xa8>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
3000ac0c: e5943010 ldr r3, [r4, #16] 3000ac10: e353003b cmp r3, #59 ; 0x3b
3000ac14: 8a000018 bhi 3000ac7c <_TOD_Validate+0xa8>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
3000ac18: e594300c ldr r3, [r4, #12] 3000ac1c: e3530017 cmp r3, #23
3000ac20: 8a000015 bhi 3000ac7c <_TOD_Validate+0xa8>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
3000ac24: e5940004 ldr r0, [r4, #4]
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
3000ac28: e3500000 cmp r0, #0
3000ac2c: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
3000ac30: e350000c cmp r0, #12
3000ac34: 8a000010 bhi 3000ac7c <_TOD_Validate+0xa8>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000ac38: e5943000 ldr r3, [r4]
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
3000ac3c: e59f2050 ldr r2, [pc, #80] ; 3000ac94 <_TOD_Validate+0xc0> 3000ac40: e1530002 cmp r3, r2
3000ac44: 9a00000c bls 3000ac7c <_TOD_Validate+0xa8>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
3000ac48: e5944008 ldr r4, [r4, #8]
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000ac4c: e3540000 cmp r4, #0
3000ac50: 0a00000b beq 3000ac84 <_TOD_Validate+0xb0>
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
3000ac54: e3130003 tst r3, #3
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
3000ac58: 059f3038 ldreq r3, [pc, #56] ; 3000ac98 <_TOD_Validate+0xc4>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000ac5c: 159f3034 ldrne r3, [pc, #52] ; 3000ac98 <_TOD_Validate+0xc4>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
3000ac60: 0280000d addeq r0, r0, #13 3000ac64: 07930100 ldreq r0, [r3, r0, lsl #2]
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000ac68: 17930100 ldrne r0, [r3, r0, lsl #2]
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
3000ac6c: e1500004 cmp r0, r4
3000ac70: 33a00000 movcc r0, #0
3000ac74: 23a00001 movcs r0, #1
3000ac78: 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;
3000ac7c: e3a00000 mov r0, #0 <== NOT EXECUTED
3000ac80: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ac84: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
3000ac88: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000bc8c <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
3000bc8c: e92d40f0 push {r4, r5, r6, r7, lr}
3000bc90: e1a04000 mov r4, r0
3000bc94: e1a07001 mov r7, r1
3000bc98: e20260ff and r6, r2, #255 ; 0xff
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
3000bc9c: e5905010 ldr r5, [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 );
3000bca0: eb000350 bl 3000c9e8 <_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 )
3000bca4: e5943014 ldr r3, [r4, #20] 3000bca8: e1530007 cmp r3, r7
_Thread_Set_priority( the_thread, new_priority );
3000bcac: 11a00004 movne r0, r4 3000bcb0: 11a01007 movne r1, r7 3000bcb4: 1b000332 blne 3000c984 <_Thread_Set_priority>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bcb8: e10f7000 mrs r7, CPSR 3000bcbc: e3873080 orr r3, r7, #128 ; 0x80 3000bcc0: 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;
3000bcc4: e5943010 ldr r3, [r4, #16]
if ( state != STATES_TRANSIENT ) {
3000bcc8: e3530004 cmp r3, #4
3000bccc: 0a00000b beq 3000bd00 <_Thread_Change_priority+0x74>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
3000bcd0: e3150004 tst r5, #4 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
3000bcd4: 03c32004 biceq r2, r3, #4 <== NOT EXECUTED
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
3000bcd8: 05842010 streq r2, [r4, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bcdc: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
3000bce0: e59f2098 ldr r2, [pc, #152] ; 3000bd80 <_Thread_Change_priority+0xf4><== NOT EXECUTED 3000bce4: e0032002 and r2, r3, r2 <== NOT EXECUTED
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
3000bce8: e3520000 cmp r2, #0 <== NOT EXECUTED
3000bcec: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
3000bcf0: e5940044 ldr r0, [r4, #68] ; 0x44 <== NOT EXECUTED 3000bcf4: e1a01004 mov r1, r4 <== NOT EXECUTED
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
3000bcf8: 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 );
3000bcfc: ea0002f4 b 3000c8d4 <_Thread_queue_Requeue> <== NOT EXECUTED
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
3000bd00: e2155004 ands r5, r5, #4 3000bd04: 159f5078 ldrne r5, [pc, #120] ; 3000bd84 <_Thread_Change_priority+0xf8>
3000bd08: 0a00000f beq 3000bd4c <_Thread_Change_priority+0xc0>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000bd0c: e10f3000 mrs r3, CPSR 3000bd10: e129f007 msr CPSR_fc, r7 3000bd14: 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();
3000bd18: e1a0e00f mov lr, pc 3000bd1c: e595f008 ldr pc, [r5, #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 );
3000bd20: e59f3060 ldr r3, [pc, #96] ; 3000bd88 <_Thread_Change_priority+0xfc> 3000bd24: 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() &&
3000bd28: e5931008 ldr r1, [r3, #8] 3000bd2c: e1520001 cmp r2, r1
3000bd30: 0a000003 beq 3000bd44 <_Thread_Change_priority+0xb8>
3000bd34: e5d22074 ldrb r2, [r2, #116] ; 0x74 3000bd38: e3520000 cmp r2, #0
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
3000bd3c: 13a02001 movne r2, #1 3000bd40: 15c32010 strbne r2, [r3, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bd44: e129f007 msr CPSR_fc, r7
3000bd48: e8bd80f0 pop {r4, r5, r6, r7, pc}
* 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 )
3000bd4c: 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 );
3000bd50: e5845010 str r5, [r4, #16]
if ( prepend_it )
3000bd54: 0a000004 beq 3000bd6c <_Thread_Change_priority+0xe0>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
3000bd58: e59f5024 ldr r5, [pc, #36] ; 3000bd84 <_Thread_Change_priority+0xf8> 3000bd5c: e1a00004 mov r0, r4 3000bd60: e1a0e00f mov lr, pc 3000bd64: e595f028 ldr pc, [r5, #40] ; 0x28 3000bd68: eaffffe7 b 3000bd0c <_Thread_Change_priority+0x80>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
3000bd6c: e59f5010 ldr r5, [pc, #16] ; 3000bd84 <_Thread_Change_priority+0xf8> 3000bd70: e1a00004 mov r0, r4 3000bd74: e1a0e00f mov lr, pc 3000bd78: e595f024 ldr pc, [r5, #36] ; 0x24 3000bd7c: eaffffe2 b 3000bd0c <_Thread_Change_priority+0x80>
3000bdd8 <_Thread_Close>:
RTEMS_INLINE_ROUTINE void _Objects_Invalidate_Id(
Objects_Information *information,
Objects_Control *the_object
)
{
_Objects_Set_local_object(
3000bdd8: e1d120b8 ldrh r2, [r1, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000bddc: e590301c ldr r3, [r0, #28]
void _Thread_Close(
Objects_Information *information,
Thread_Control *the_thread
)
{
3000bde0: e92d4070 push {r4, r5, r6, lr}
3000bde4: e1a04001 mov r4, r1
3000bde8: e3a01000 mov r1, #0
3000bdec: e7831102 str r1, [r3, r2, lsl #2]
3000bdf0: e1a05000 mov r5, r0
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000bdf4: e59f608c ldr r6, [pc, #140] ; 3000be88 <_Thread_Close+0xb0>
* disappear and set a transient state on it. So we temporarily
* unnest dispatching.
*/
_Thread_Unnest_dispatch();
_User_extensions_Thread_delete( the_thread );
3000bdf8: e1a00004 mov r0, r4 3000bdfc: e5963000 ldr r3, [r6] 3000be00: e2433001 sub r3, r3, #1 3000be04: e5863000 str r3, [r6] 3000be08: eb000420 bl 3000ce90 <_User_extensions_Thread_delete>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000be0c: e5963000 ldr r3, [r6] 3000be10: e2833001 add r3, r3, #1 3000be14: e5863000 str r3, [r6]
/* * Now we are in a dispatching critical section again and we * can take the thread OUT of the published set. It is invalid * to use this thread's Id OR name after this call. */ _Objects_Close( information, &the_thread->Object );
3000be18: e1a01004 mov r1, r4 3000be1c: e1a00005 mov r0, r5 3000be20: ebfffc4f bl 3000af64 <_Objects_Close>
/*
* By setting the dormant state, the thread will not be considered
* for scheduling when we remove any blocking states.
*/
_Thread_Set_state( the_thread, STATES_DORMANT );
3000be24: e1a00004 mov r0, r4 3000be28: e3a01001 mov r1, #1 3000be2c: eb0002db bl 3000c9a0 <_Thread_Set_state>
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
3000be30: e1a00004 mov r0, r4 3000be34: eb000275 bl 3000c810 <_Thread_queue_Extract_with_proxy> 3000be38: e3500000 cmp r0, #0
3000be3c: 1a000002 bne 3000be4c <_Thread_Close+0x74>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
3000be40: e5943050 ldr r3, [r4, #80] ; 0x50 3000be44: e3530002 cmp r3, #2
3000be48: 0a00000b beq 3000be7c <_Thread_Close+0xa4>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Free(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.free( the_thread );
3000be4c: e59f3038 ldr r3, [pc, #56] ; 3000be8c <_Thread_Close+0xb4> 3000be50: e1a00004 mov r0, r4 3000be54: e1a0e00f mov lr, pc 3000be58: e593f01c ldr pc, [r3, #28]
/* * Free the rest of the memory associated with this task * and set the associated pointers to NULL for safety. */ _Thread_Stack_Free( the_thread ); the_thread->Start.stack = NULL;
3000be5c: e3a05000 mov r5, #0
/*
* Free the rest of the memory associated with this task
* and set the associated pointers to NULL for safety.
*/
_Thread_Stack_Free( the_thread );
3000be60: e1a00004 mov r0, r4 3000be64: eb000309 bl 3000ca90 <_Thread_Stack_Free>
the_thread->Start.stack = NULL;
3000be68: e58450c0 str r5, [r4, #192] ; 0xc0
_Workspace_Free( the_thread->extensions );
3000be6c: e5940100 ldr r0, [r4, #256] ; 0x100 3000be70: eb00051d bl 3000d2ec <_Workspace_Free>
the_thread->extensions = NULL;
3000be74: e5845100 str r5, [r4, #256] ; 0x100
}
3000be78: e8bd8070 pop {r4, r5, r6, pc}
*/
_Thread_Set_state( the_thread, STATES_DORMANT );
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
3000be7c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000be80: eb0004a7 bl 3000d124 <_Watchdog_Remove> <== NOT EXECUTED 3000be84: eafffff0 b 3000be4c <_Thread_Close+0x74> <== NOT EXECUTED
3000bf64 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000bf64: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000bf68: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000bf6c: e1a0100d mov r1, sp <== NOT EXECUTED 3000bf70: eb00006b bl 3000c124 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000bf74: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000bf78: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf7c: 1a000005 bne 3000bf98 <_Thread_Delay_ended+0x34> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
3000bf80: e59f1018 ldr r1, [pc, #24] ; 3000bfa0 <_Thread_Delay_ended+0x3c><== NOT EXECUTED 3000bf84: ebffff80 bl 3000bd8c <_Thread_Clear_state> <== NOT EXECUTED 3000bf88: e59f3014 ldr r3, [pc, #20] ; 3000bfa4 <_Thread_Delay_ended+0x40><== NOT EXECUTED 3000bf8c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000bf90: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000bf94: e5832000 str r2, [r3] <== NOT EXECUTED
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
3000bf98: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000bf9c: e8bd8000 pop {pc} <== NOT EXECUTED
3000bfa8 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
3000bfa8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
3000bfac: e59f7138 ldr r7, [pc, #312] ; 3000c0ec <_Thread_Dispatch+0x144>
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
3000bfb0: e24dd010 sub sp, sp, #16
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
3000bfb4: e5975004 ldr r5, [r7, #4]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bfb8: e10f2000 mrs r2, CPSR 3000bfbc: e3823080 orr r3, r2, #128 ; 0x80 3000bfc0: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
3000bfc4: e5d71010 ldrb r1, [r7, #16] 3000bfc8: e3510000 cmp r1, #0
3000bfcc: 0a000043 beq 3000c0e0 <_Thread_Dispatch+0x138>
heir = _Thread_Heir;
3000bfd0: e5974008 ldr r4, [r7, #8]
_Thread_Dispatch_disable_level = 1;
3000bfd4: e59f9114 ldr r9, [pc, #276] ; 3000c0f0 <_Thread_Dispatch+0x148> 3000bfd8: e3a00001 mov r0, #1
_Thread_Dispatch_necessary = false;
3000bfdc: e3a01000 mov r1, #0
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000bfe0: e1550004 cmp r5, r4
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
3000bfe4: e5890000 str r0, [r9]
_Thread_Dispatch_necessary = false;
_Thread_Executing = heir;
3000bfe8: e5874004 str r4, [r7, #4]
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
_Thread_Dispatch_necessary = false;
3000bfec: e5c71010 strb r1, [r7, #16]
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
3000bff0: 01a03002 moveq r3, r2
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000bff4: 0a000033 beq 3000c0c8 <_Thread_Dispatch+0x120>
3000bff8: e28da008 add sl, sp, #8 3000bffc: e1a0800d mov r8, sp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
3000c000: e1a06007 mov r6, r7 3000c004: ea000007 b 3000c028 <_Thread_Dispatch+0x80>
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
3000c008: e5964008 ldr r4, [r6, #8] <== NOT EXECUTED
_Thread_Dispatch_disable_level = 1;
3000c00c: e3a01001 mov r1, #1 <== NOT EXECUTED
_Thread_Dispatch_necessary = false;
3000c010: e3a0b000 mov fp, #0 <== NOT EXECUTED
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000c014: e1540005 cmp r4, r5 <== NOT EXECUTED
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
3000c018: e5891000 str r1, [r9] <== NOT EXECUTED
_Thread_Dispatch_necessary = false;
_Thread_Executing = heir;
3000c01c: e5864004 str r4, [r6, #4] <== NOT EXECUTED
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
_Thread_Dispatch_necessary = false;
3000c020: e5c6b010 strb fp, [r6, #16] <== NOT EXECUTED
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000c024: 0a000027 beq 3000c0c8 <_Thread_Dispatch+0x120> <== NOT EXECUTED
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
3000c028: e594307c ldr r3, [r4, #124] ; 0x7c 3000c02c: e3530001 cmp r3, #1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000c030: 059fc0bc ldreq ip, [pc, #188] ; 3000c0f4 <_Thread_Dispatch+0x14c> 3000c034: 059c3000 ldreq r3, [ip] 3000c038: 05843078 streq r3, [r4, #120] ; 0x78
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c03c: e129f002 msr CPSR_fc, r2
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
3000c040: e1a0000a mov r0, sl 3000c044: eb000f4b bl 3000fd78 <_TOD_Get_uptime>
_Timestamp_Subtract(
3000c048: e1a0200d mov r2, sp 3000c04c: e1a0100a mov r1, sl 3000c050: e59f00a0 ldr r0, [pc, #160] ; 3000c0f8 <_Thread_Dispatch+0x150> 3000c054: eb0002ff bl 3000cc58 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
3000c058: e1a0100d mov r1, sp 3000c05c: e2850084 add r0, r5, #132 ; 0x84 3000c060: eb0002e5 bl 3000cbfc <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
3000c064: e28dc008 add ip, sp, #8
3000c068: e89c1800 ldm ip, {fp, ip}
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
3000c06c: e59f2088 ldr r2, [pc, #136] ; 3000c0fc <_Thread_Dispatch+0x154>
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
3000c070: e1a00005 mov r0, r5
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
3000c074: e5923000 ldr r3, [r2]
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
3000c078: e59f2078 ldr r2, [pc, #120] ; 3000c0f8 <_Thread_Dispatch+0x150>
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
3000c07c: e3530000 cmp r3, #0
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
3000c080: e8821800 stm r2, {fp, ip}
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
3000c084: 15932000 ldrne r2, [r3]
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
3000c088: e1a01004 mov r1, r4
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
3000c08c: 158520f4 strne r2, [r5, #244] ; 0xf4
*_Thread_libc_reent = heir->libc_reent;
3000c090: 159420f4 ldrne r2, [r4, #244] ; 0xf4 3000c094: 15832000 strne r2, [r3]
}
_User_extensions_Thread_switch( executing, heir );
3000c098: eb0003a2 bl 3000cf28 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
3000c09c: e28500c4 add r0, r5, #196 ; 0xc4 3000c0a0: e28410c4 add r1, r4, #196 ; 0xc4 3000c0a4: eb000570 bl 3000d66c <_CPU_Context_switch>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
3000c0a8: e5975004 ldr r5, [r7, #4]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c0ac: e10f3000 mrs r3, CPSR 3000c0b0: e3832080 orr r2, r3, #128 ; 0x80 3000c0b4: e129f002 msr CPSR_fc, r2
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
3000c0b8: e5d71010 ldrb r1, [r7, #16] 3000c0bc: e1a02003 mov r2, r3 3000c0c0: e3510000 cmp r1, #0
3000c0c4: 1affffcf bne 3000c008 <_Thread_Dispatch+0x60>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
3000c0c8: e3a01000 mov r1, #0 3000c0cc: e5891000 str r1, [r9]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c0d0: e129f003 msr CPSR_fc, r3
_ISR_Enable( level );
_API_extensions_Run_postswitch();
3000c0d4: ebfff8bf bl 3000a3d8 <_API_extensions_Run_postswitch>
}
3000c0d8: e28dd010 add sp, sp, #16
3000c0dc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
3000c0e0: e1a03002 mov r3, r2 3000c0e4: e59f9004 ldr r9, [pc, #4] ; 3000c0f0 <_Thread_Dispatch+0x148> 3000c0e8: eafffff6 b 3000c0c8 <_Thread_Dispatch+0x120>
3000c124 <_Thread_Get>:
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 ) ) {
3000c124: e2503000 subs r3, r0, #0
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
3000c128: 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 ) ) {
3000c12c: 0a000014 beq 3000c184 <_Thread_Get+0x60>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
3000c130: e1a01c23 lsr r1, r3, #24 3000c134: e2011007 and r1, r1, #7
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000c138: e2410001 sub r0, r1, #1 3000c13c: e3500002 cmp r0, #2
3000c140: 8a00000b bhi 3000c174 <_Thread_Get+0x50>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000c144: e1a0cda3 lsr ip, r3, #27
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
3000c148: e35c0001 cmp ip, #1
3000c14c: 1a000008 bne 3000c174 <_Thread_Get+0x50>
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
3000c150: e59f0054 ldr r0, [pc, #84] ; 3000c1ac <_Thread_Get+0x88> 3000c154: e7900101 ldr r0, [r0, r1, 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 ) {
3000c158: e3500000 cmp r0, #0
3000c15c: 0a000010 beq 3000c1a4 <_Thread_Get+0x80>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
3000c160: e5900004 ldr r0, [r0, #4]
if ( !information ) {
3000c164: e3500000 cmp r0, #0
3000c168: 0a00000d beq 3000c1a4 <_Thread_Get+0x80>
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
3000c16c: e1a01003 mov r1, r3 3000c170: eafffc87 b 3000b394 <_Objects_Get>
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
3000c174: e3a03001 mov r3, #1 3000c178: 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;
3000c17c: e3a00000 mov r0, #0
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
3000c180: e12fff1e bx lr
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000c184: e59f1024 ldr r1, [pc, #36] ; 3000c1b0 <_Thread_Get+0x8c> 3000c188: e5910000 ldr r0, [r1] 3000c18c: e2800001 add r0, r0, #1 3000c190: e5810000 str r0, [r1]
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;
3000c194: e5823000 str r3, [r2]
tp = _Thread_Executing;
3000c198: e59f3014 ldr r3, [pc, #20] ; 3000c1b4 <_Thread_Get+0x90> 3000c19c: e5930004 ldr r0, [r3, #4]
goto done;
3000c1a0: e12fff1e bx lr
goto done;
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
3000c1a4: e582c000 str ip, [r2] <== NOT EXECUTED
goto done;
3000c1a8: e12fff1e bx lr <== NOT EXECUTED
3000c394 <_Thread_Handler_initialization>:
uint32_t maximum_extensions;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies;
#endif
ticks_per_timeslice = Configuration.ticks_per_timeslice;
3000c394: e59f2088 ldr r2, [pc, #136] ; 3000c424 <_Thread_Handler_initialization+0x90>
*
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
3000c398: e52de004 push {lr} ; (str lr, [sp, #-4]!)
#endif
/*
* BOTH stacks hooks must be set or both must be NULL.
* Do not allow mixture.
*/
if ( !( (!Configuration.stack_allocate_hook)
3000c39c: e592c020 ldr ip, [r2, #32]
== (!Configuration.stack_free_hook) ) )
3000c3a0: e5923024 ldr r3, [r2, #36] ; 0x24
#endif
/*
* BOTH stacks hooks must be set or both must be NULL.
* Do not allow mixture.
*/
if ( !( (!Configuration.stack_allocate_hook)
3000c3a4: e27cc001 rsbs ip, ip, #1 3000c3a8: 33a0c000 movcc ip, #0 3000c3ac: e3530000 cmp r3, #0 3000c3b0: 022cc001 eoreq ip, ip, #1 3000c3b4: e35c0000 cmp ip, #0
uint32_t maximum_extensions;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies;
#endif
ticks_per_timeslice = Configuration.ticks_per_timeslice;
3000c3b8: e5923010 ldr r3, [r2, #16]
*
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
3000c3bc: e24dd00c sub sp, sp, #12
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies;
#endif
ticks_per_timeslice = Configuration.ticks_per_timeslice;
maximum_extensions = Configuration.maximum_extensions;
3000c3c0: e5922008 ldr r2, [r2, #8]
#endif
/*
* BOTH stacks hooks must be set or both must be NULL.
* Do not allow mixture.
*/
if ( !( (!Configuration.stack_allocate_hook)
3000c3c4: 1a000012 bne 3000c414 <_Thread_Handler_initialization+0x80>
_Thread_Heir = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
#endif
_Thread_Maximum_extensions = maximum_extensions;
3000c3c8: e59f0058 ldr r0, [pc, #88] ; 3000c428 <_Thread_Handler_initialization+0x94>
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
_Thread_Dispatch_necessary = false;
3000c3cc: e59fe058 ldr lr, [pc, #88] ; 3000c42c <_Thread_Handler_initialization+0x98>
_Thread_Heir = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
#endif
_Thread_Maximum_extensions = maximum_extensions;
3000c3d0: e5802000 str r2, [r0]
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
3000c3d4: e59f2054 ldr r2, [pc, #84] ; 3000c430 <_Thread_Handler_initialization+0x9c>
/*
* Initialize this class of objects.
*/
_Objects_Initialize_information(
3000c3d8: e3a01001 mov r1, #1
_Thread_Allocated_fp = NULL;
#endif
_Thread_Maximum_extensions = maximum_extensions;
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
3000c3dc: e5823000 str r3, [r2]
/*
* Initialize this class of objects.
*/
_Objects_Initialize_information(
3000c3e0: e3a03f42 mov r3, #264 ; 0x108
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
_Thread_Dispatch_necessary = false;
_Thread_Executing = NULL;
3000c3e4: e58ec004 str ip, [lr, #4]
_Thread_Heir = NULL;
3000c3e8: e58ec008 str ip, [lr, #8]
/*
* Initialize this class of objects.
*/
_Objects_Initialize_information(
3000c3ec: e59f0040 ldr r0, [pc, #64] ; 3000c434 <_Thread_Handler_initialization+0xa0>
3000c3f0: e88d1008 stm sp, {r3, ip}
3000c3f4: e1a02001 mov r2, r1
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
_Thread_Dispatch_necessary = false;
3000c3f8: e5cec010 strb ip, [lr, #16]
/*
* Initialize this class of objects.
*/
_Objects_Initialize_information(
3000c3fc: e1a03001 mov r3, r1 3000c400: e3a0c008 mov ip, #8 3000c404: e58dc008 str ip, [sp, #8] 3000c408: ebfffc01 bl 3000b414 <_Objects_Initialize_information>
false, /* true if this is a global object class */
NULL /* Proxy extraction support callout */
#endif
);
}
3000c40c: e28dd00c add sp, sp, #12
3000c410: e8bd8000 pop {pc}
* BOTH stacks hooks must be set or both must be NULL.
* Do not allow mixture.
*/
if ( !( (!Configuration.stack_allocate_hook)
== (!Configuration.stack_free_hook) ) )
_Internal_error_Occurred(
3000c414: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c418: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c41c: e3a0200e mov r2, #14 <== NOT EXECUTED 3000c420: ebfffa92 bl 3000ae70 <_Internal_error_Occurred> <== NOT EXECUTED
30011334 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
30011334: e92d4030 push {r4, r5, lr}
the_thread->resource_count = 0; the_thread->is_preemptible = the_thread->Start.is_preemptible; the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
30011338: e590c0a4 ldr ip, [r0, #164] ; 0xa4
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
the_thread->resource_count = 0;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
3001133c: e5d0e0a0 ldrb lr, [r0, #160] ; 0xa0
the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout;
30011340: e59030a8 ldr r3, [r0, #168] ; 0xa8
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
the_thread->resource_count = 0;
30011344: e3a05000 mov r5, #0 30011348: e580501c str r5, [r0, #28]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
3001134c: e5c0e074 strb lr, [r0, #116] ; 0x74
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
30011350: e580c07c str ip, [r0, #124] ; 0x7c
the_thread->budget_callout = the_thread->Start.budget_callout;
30011354: e5803080 str r3, [r0, #128] ; 0x80
the_thread->Start.pointer_argument = pointer_argument;
30011358: e5801098 str r1, [r0, #152] ; 0x98
the_thread->Start.numeric_argument = numeric_argument;
3001135c: e580209c str r2, [r0, #156] ; 0x9c
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
30011360: e1a04000 mov r4, r0
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->Start.pointer_argument = pointer_argument;
the_thread->Start.numeric_argument = numeric_argument;
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
30011364: ebfff06e bl 3000d524 <_Thread_queue_Extract_with_proxy> 30011368: e1500005 cmp r0, r5
3001136c: 1a000002 bne 3001137c <_Thread_Reset+0x48>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
30011370: e5943050 ldr r3, [r4, #80] ; 0x50 30011374: e3530002 cmp r3, #2
30011378: 0a000007 beq 3001139c <_Thread_Reset+0x68>
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
3001137c: e59410b0 ldr r1, [r4, #176] ; 0xb0
30011380: e5943014 ldr r3, [r4, #20]
30011384: e1530001 cmp r3, r1
30011388: 08bd8030 popeq {r4, r5, pc}
the_thread->real_priority = the_thread->Start.initial_priority;
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
3001138c: e1a00004 mov r0, r4
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
the_thread->real_priority = the_thread->Start.initial_priority;
30011390: e5841018 str r1, [r4, #24]
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
}
}
30011394: e8bd4030 pop {r4, r5, lr}
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
the_thread->real_priority = the_thread->Start.initial_priority;
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
30011398: eafff0da b 3000d708 <_Thread_Set_priority>
the_thread->Start.numeric_argument = numeric_argument;
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
3001139c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 300113a0: ebfff2d3 bl 3000def4 <_Watchdog_Remove> <== NOT EXECUTED 300113a4: eafffff4 b 3001137c <_Thread_Reset+0x48> <== NOT EXECUTED
30010140 <_Thread_Resume>:
*/
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
30010140: e92d4010 push {r4, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30010144: e10f4000 mrs r4, CPSR 30010148: e3842080 orr r2, r4, #128 ; 0x80 3001014c: e129f002 msr CPSR_fc, r2
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
current_state = the_thread->current_state;
30010150: e5902010 ldr r2, [r0, #16]
if ( current_state & STATES_SUSPENDED ) {
30010154: e3120002 tst r2, #2
30010158: 0a000003 beq 3001016c <_Thread_Resume+0x2c>
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
3001015c: e3c22002 bic r2, r2, #2
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
if ( _States_Is_ready( current_state ) ) {
30010160: e3520000 cmp r2, #0
_ISR_Disable( level );
current_state = the_thread->current_state;
if ( current_state & STATES_SUSPENDED ) {
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
30010164: e5802010 str r2, [r0, #16]
if ( _States_Is_ready( current_state ) ) {
30010168: 0a000001 beq 30010174 <_Thread_Resume+0x34>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001016c: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
}
30010170: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
30010174: e59f300c ldr r3, [pc, #12] ; 30010188 <_Thread_Resume+0x48>
30010178: e1a0e00f mov lr, pc
3001017c: e593f014 ldr pc, [r3, #20]
30010180: e129f004 msr CPSR_fc, r4
30010184: e8bd8010 pop {r4, pc}
3000cb10 <_Thread_Start>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
3000cb10: e590c010 ldr ip, [r0, #16]
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000cb14: e92d4010 push {r4, lr}
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000cb18: e21cc001 ands ip, ip, #1
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000cb1c: e1a04000 mov r4, r0
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000cb20: 1a000001 bne 3000cb2c <_Thread_Start+0x1c>
_User_extensions_Thread_start( the_thread );
return true;
}
return false;
3000cb24: e1a0000c mov r0, ip <== NOT EXECUTED
}
3000cb28: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( _States_Is_dormant( the_thread->current_state ) ) {
the_thread->Start.entry_point = (Thread_Entry) entry_point;
the_thread->Start.prototype = the_prototype;
the_thread->Start.pointer_argument = pointer_argument;
3000cb2c: e5803098 str r3, [r0, #152] ; 0x98
the_thread->Start.numeric_argument = numeric_argument;
3000cb30: 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;
3000cb34: e5802090 str r2, [r0, #144] ; 0x90
the_thread->Start.prototype = the_prototype;
3000cb38: e5801094 str r1, [r0, #148] ; 0x94
the_thread->Start.pointer_argument = pointer_argument;
the_thread->Start.numeric_argument = numeric_argument;
3000cb3c: e580309c str r3, [r0, #156] ; 0x9c
_Thread_Load_environment( the_thread );
3000cb40: eb000daf bl 30010204 <_Thread_Load_environment>
_Thread_Ready( the_thread );
3000cb44: e1a00004 mov r0, r4 3000cb48: eb000e50 bl 30010490 <_Thread_Ready>
_User_extensions_Thread_start( the_thread );
3000cb4c: e1a00004 mov r0, r4 3000cb50: eb0000e1 bl 3000cedc <_User_extensions_Thread_start>
return true;
3000cb54: e3a00001 mov r0, #1
3000cb58: e8bd8010 pop {r4, pc}
300104ec <_Thread_Suspend>:
* select map
*/
void _Thread_Suspend(
Thread_Control *the_thread
)
{
300104ec: e92d4010 push {r4, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300104f0: e10f4000 mrs r4, CPSR 300104f4: e3842080 orr r2, r4, #128 ; 0x80 300104f8: e129f002 msr CPSR_fc, r2
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_ready( the_thread->current_state ) ) {
300104fc: e5902010 ldr r2, [r0, #16] 30010500: e3520000 cmp r2, #0
30010504: 0a000003 beq 30010518 <_Thread_Suspend+0x2c>
RTEMS_INLINE_ROUTINE States_Control _States_Set (
States_Control states_to_set,
States_Control current_state
)
{
return (current_state | states_to_set);
30010508: e3822002 orr r2, r2, #2 <== NOT EXECUTED
the_thread->current_state =
3001050c: e5802010 str r2, [r0, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30010510: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
30010514: e8bd8010 pop {r4, pc} <== NOT EXECUTED
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
return;
}
the_thread->current_state = STATES_SUSPENDED;
30010518: e3a02002 mov r2, #2 3001051c: e5802010 str r2, [r0, #16]
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Block(
Thread_Control *the_thread
)
{
_Scheduler.Operations.block( the_thread );
30010520: e59f300c ldr r3, [pc, #12] ; 30010534 <_Thread_Suspend+0x48>
30010524: e1a0e00f mov lr, pc
30010528: e593f010 ldr pc, [r3, #16]
3001052c: e129f004 msr CPSR_fc, r4
30010530: e8bd8010 pop {r4, pc}
3000cb5c <_Thread_Tickle_timeslice>:
void _Thread_Tickle_timeslice( void )
{
Thread_Control *executing;
executing = _Thread_Executing;
3000cb5c: e59f308c ldr r3, [pc, #140] ; 3000cbf0 <_Thread_Tickle_timeslice+0x94>
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
3000cb60: e92d4010 push {r4, lr}
Thread_Control *executing;
executing = _Thread_Executing;
3000cb64: e5934004 ldr r4, [r3, #4]
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
3000cb68: e5d43074 ldrb r3, [r4, #116] ; 0x74
3000cb6c: e3530000 cmp r3, #0
3000cb70: 08bd8010 popeq {r4, pc}
return;
if ( !_States_Is_ready( executing->current_state ) )
3000cb74: e5943010 ldr r3, [r4, #16]
3000cb78: e3530000 cmp r3, #0
3000cb7c: 18bd8010 popne {r4, pc}
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
3000cb80: e594307c ldr r3, [r4, #124] ; 0x7c
3000cb84: e3530001 cmp r3, #1
3000cb88: 38bd8010 popcc {r4, pc}
3000cb8c: e3530002 cmp r3, #2 <== NOT EXECUTED
3000cb90: 9a00000a bls 3000cbc0 <_Thread_Tickle_timeslice+0x64> <== NOT EXECUTED
3000cb94: e3530003 cmp r3, #3 <== NOT EXECUTED
3000cb98: 18bd8010 popne {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 )
3000cb9c: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000cba0: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000cba4: e3530000 cmp r3, #0 <== NOT EXECUTED
3000cba8: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000cbac: 18bd8010 popne {r4, pc} <== NOT EXECUTED
(*executing->budget_callout)( executing );
3000cbb0: e1a00004 mov r0, r4 <== NOT EXECUTED
3000cbb4: e1a0e00f mov lr, pc <== NOT EXECUTED
3000cbb8: e594f080 ldr pc, [r4, #128] ; 0x80 <== NOT EXECUTED
3000cbbc: e8bd8010 pop {r4, pc} <== 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 ) {
3000cbc0: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000cbc4: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000cbc8: e3530000 cmp r3, #0 <== NOT EXECUTED
3000cbcc: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000cbd0: 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();
3000cbd4: e59f3018 ldr r3, [pc, #24] ; 3000cbf4 <_Thread_Tickle_timeslice+0x98><== NOT EXECUTED 3000cbd8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cbdc: 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;
3000cbe0: e59f3010 ldr r3, [pc, #16] ; 3000cbf8 <_Thread_Tickle_timeslice+0x9c><== NOT EXECUTED
3000cbe4: e5933000 ldr r3, [r3] <== NOT EXECUTED
3000cbe8: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000cbec: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000bc34 <_Thread_blocking_operation_Cancel>:
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000bc34: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== 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 ) ) {
3000bc38: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000bc3c: e24dd004 sub sp, sp, #4 <== 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 ) ) {
3000bc40: e3530002 cmp r3, #2 <== NOT EXECUTED
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000bc44: e3a03000 mov r3, #0 <== NOT EXECUTED 3000bc48: 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 ) ) {
3000bc4c: 0a000005 beq 3000bc68 <_Thread_blocking_operation_Cancel+0x34><== NOT EXECUTED 3000bc50: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000bc54: e1a00001 mov r0, r1 <== NOT EXECUTED 3000bc58: e59f1028 ldr r1, [pc, #40] ; 3000bc88 <_Thread_blocking_operation_Cancel+0x54><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000bc5c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000bc60: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
3000bc64: ea000048 b 3000bd8c <_Thread_Clear_state> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000bc68: e3a03003 mov r3, #3 <== NOT EXECUTED 3000bc6c: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000bc70: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000bc74: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3000bc78: e58d1000 str r1, [sp] <== NOT EXECUTED 3000bc7c: eb000528 bl 3000d124 <_Watchdog_Remove> <== NOT EXECUTED 3000bc80: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000bc84: eafffff2 b 3000bc54 <_Thread_blocking_operation_Cancel+0x20><== NOT EXECUTED
30010254 <_Thread_queue_Dequeue_fifo>:
*/
Thread_Control *_Thread_queue_Dequeue_fifo(
Thread_queue_Control *the_thread_queue
)
{
30010254: e92d4030 push {r4, r5, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30010258: e10f2000 mrs r2, CPSR 3001025c: e3823080 orr r3, r2, #128 ; 0x80 30010260: e129f003 msr CPSR_fc, r3
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
30010264: e1a03000 mov r3, r0 30010268: e4934004 ldr r4, [r3], #4
{
ISR_Level level;
Thread_Control *the_thread;
_ISR_Disable( level );
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
3001026c: e1540003 cmp r4, r3
30010270: 0a000018 beq 300102d8 <_Thread_queue_Dequeue_fifo+0x84>
the_thread = (Thread_Control *)
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30010274: e5941050 ldr r1, [r4, #80] ; 0x50
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
30010278: e5943000 ldr r3, [r4] 3001027c: e3510002 cmp r1, #2
head->next = new_first;
30010280: e5803000 str r3, [r0]
new_first->previous = head;
30010284: e5830004 str r0, [r3, #4]
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
the_thread = (Thread_Control *)
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
30010288: e3a03000 mov r3, #0
Thread_Control *the_thread;
_ISR_Disable( level );
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
the_thread = (Thread_Control *)
3001028c: e1a05004 mov r5, r4
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
30010290: e5843044 str r3, [r4, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30010294: 0a000005 beq 300102b0 <_Thread_queue_Dequeue_fifo+0x5c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30010298: e129f002 msr CPSR_fc, r2
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3001029c: e59f1040 ldr r1, [pc, #64] ; 300102e4 <_Thread_queue_Dequeue_fifo+0x90> 300102a0: e1a00004 mov r0, r4 300102a4: ebffeeb8 bl 3000bd8c <_Thread_Clear_state>
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
300102a8: e1a00005 mov r0, r5
300102ac: e8bd8030 pop {r4, r5, pc}
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
300102b0: e3a03003 mov r3, #3 <== NOT EXECUTED 300102b4: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 300102b8: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
300102bc: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 300102c0: ebfff397 bl 3000d124 <_Watchdog_Remove> <== NOT EXECUTED 300102c4: e1a00004 mov r0, r4 <== NOT EXECUTED 300102c8: e59f1014 ldr r1, [pc, #20] ; 300102e4 <_Thread_queue_Dequeue_fifo+0x90><== NOT EXECUTED 300102cc: ebffeeae bl 3000bd8c <_Thread_Clear_state> <== NOT EXECUTED
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
300102d0: e1a00005 mov r0, r5 <== NOT EXECUTED
300102d4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
300102d8: e129f002 msr CPSR_fc, r2
return the_thread;
}
_ISR_Enable( level );
return NULL;
300102dc: e3a05000 mov r5, #0 300102e0: eafffff0 b 300102a8 <_Thread_queue_Dequeue_fifo+0x54>
3000c4a8 <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
3000c4a8: e92d4030 push {r4, r5, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c4ac: e10fc000 mrs ip, CPSR 3000c4b0: e38c3080 orr r3, ip, #128 ; 0x80 3000c4b4: 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 );
3000c4b8: e3a02000 mov r2, #0
for( index=0 ;
3000c4bc: 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 );
3000c4c0: e0831083 add r1, r3, r3, lsl #1
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000c4c4: e7904002 ldr r4, [r0, r2] 3000c4c8: e0801101 add r1, r0, r1, lsl #2 3000c4cc: e2811004 add r1, r1, #4
_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 ] ) ) {
3000c4d0: e1540001 cmp r4, r1
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000c4d4: e2833001 add r3, r3, #1
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
3000c4d8: 1a000006 bne 3000c4f8 <_Thread_queue_Dequeue_priority+0x50>
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000c4dc: e3530004 cmp r3, #4
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000c4e0: e282200c add r2, r2, #12
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000c4e4: 1afffff5 bne 3000c4c0 <_Thread_queue_Dequeue_priority+0x18>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c4e8: e129f00c msr CPSR_fc, ip
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
return NULL;
3000c4ec: e3a05000 mov r5, #0
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000c4f0: e1a00005 mov r0, r5
3000c4f4: e8bd8030 pop {r4, r5, pc}
3000c4f8: e5943038 ldr r3, [r4, #56] ; 0x38
3000c4fc: e284203c add r2, r4, #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 ) ) {
3000c500: e1530002 cmp r3, r2
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
3000c504: e3a02000 mov r2, #0 3000c508: e5842044 str r2, [r4, #68] ; 0x44
_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(
3000c50c: e1a05004 mov r5, r4
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;
3000c510: e5942000 ldr r2, [r4]
previous_node = the_thread->Object.Node.previous;
3000c514: e5941004 ldr r1, [r4, #4]
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000c518: 0a000020 beq 3000c5a0 <_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 );
}
3000c51c: e5940040 ldr r0, [r4, #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;
3000c520: e593e000 ldr lr, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000c524: 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;
3000c528: e5813000 str r3, [r1] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000c52c: e5831004 str r1, [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;
3000c530: e5832000 str r2, [r3] <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000c534: e5941038 ldr r1, [r4, #56] ; 0x38 <== NOT EXECUTED 3000c538: e5942040 ldr r2, [r4, #64] ; 0x40 <== NOT EXECUTED 3000c53c: e1510002 cmp r1, r2 <== NOT EXECUTED 3000c540: 0a000005 beq 3000c55c <_Thread_queue_Dequeue_priority+0xb4><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000c544: e2831038 add r1, r3, #56 ; 0x38 <== NOT EXECUTED
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
3000c548: e283203c add r2, r3, #60 ; 0x3c <== NOT EXECUTED
new_second_node->previous = head;
3000c54c: e58e1004 str r1, [lr, #4] <== NOT EXECUTED
head->next = new_second_node;
3000c550: e583e038 str lr, [r3, #56] ; 0x38 <== NOT EXECUTED
tail->previous = last_node;
3000c554: e5830040 str r0, [r3, #64] ; 0x40 <== NOT EXECUTED
last_node->next = tail;
3000c558: e5802000 str r2, [r0] <== NOT EXECUTED
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000c55c: e5943050 ldr r3, [r4, #80] ; 0x50 3000c560: e3530002 cmp r3, #2
3000c564: 0a000004 beq 3000c57c <_Thread_queue_Dequeue_priority+0xd4>
3000c568: e129f00c msr CPSR_fc, ip
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000c56c: e59f1038 ldr r1, [pc, #56] ; 3000c5ac <_Thread_queue_Dequeue_priority+0x104> 3000c570: e1a00004 mov r0, r4 3000c574: ebfffe04 bl 3000bd8c <_Thread_Clear_state> 3000c578: eaffffdc b 3000c4f0 <_Thread_queue_Dequeue_priority+0x48>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000c57c: e3a03003 mov r3, #3 <== NOT EXECUTED 3000c580: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000c584: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000c588: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000c58c: eb0002e4 bl 3000d124 <_Watchdog_Remove> <== NOT EXECUTED 3000c590: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c594: e59f1010 ldr r1, [pc, #16] ; 3000c5ac <_Thread_queue_Dequeue_priority+0x104><== NOT EXECUTED 3000c598: ebfffdfb bl 3000bd8c <_Thread_Clear_state> <== NOT EXECUTED 3000c59c: eaffffd3 b 3000c4f0 <_Thread_queue_Dequeue_priority+0x48> <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
3000c5a0: e5812000 str r2, [r1]
next_node->previous = previous_node;
3000c5a4: e5821004 str r1, [r2, #4] 3000c5a8: eaffffeb b 3000c55c <_Thread_queue_Dequeue_priority+0xb4>
3000c65c <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
3000c65c: e5913014 ldr r3, [r1, #20]
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
3000c660: e92d05f0 push {r4, r5, r6, r7, r8, sl}
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 );
3000c664: e281403c add r4, r1, #60 ; 0x3c
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3000c668: e281c038 add ip, r1, #56 ; 0x38
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000c66c: e5814038 str r4, [r1, #56] ; 0x38
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
3000c670: e3130020 tst r3, #32
head->previous = NULL;
3000c674: e3a04000 mov r4, #0 3000c678: e581403c str r4, [r1, #60] ; 0x3c
tail->previous = head;
3000c67c: e581c040 str ip, [r1, #64] ; 0x40
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
3000c680: e1a07323 lsr r7, r3, #6
_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;
3000c684: e5905038 ldr r5, [r0, #56] ; 0x38
if ( _Thread_queue_Is_reverse_search( priority ) )
3000c688: 1a00001e bne 3000c708 <_Thread_queue_Enqueue_priority+0xac>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
3000c68c: e0877087 add r7, r7, r7, lsl #1 3000c690: e1a0c107 lsl ip, r7, #2
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
3000c694: e28c7004 add r7, ip, #4 3000c698: e080a00c add sl, r0, ip 3000c69c: e0807007 add r7, r0, r7
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c6a0: e10f8000 mrs r8, CPSR 3000c6a4: e388c080 orr ip, r8, #128 ; 0x80 3000c6a8: e129f00c msr CPSR_fc, ip 3000c6ac: e59ac000 ldr ip, [sl]
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 ) ) {
3000c6b0: e15c0007 cmp ip, r7
3000c6b4: 1a000009 bne 3000c6e0 <_Thread_queue_Enqueue_priority+0x84>
3000c6b8: ea000051 b 3000c804 <_Thread_queue_Enqueue_priority+0x1a8>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000c6bc: e10f6000 mrs r6, CPSR 3000c6c0: e129f008 msr CPSR_fc, r8 3000c6c4: e129f006 msr CPSR_fc, r6
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
3000c6c8: e59c6010 ldr r6, [ip, #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) ) {
3000c6cc: e1150006 tst r5, r6
3000c6d0: 0a000034 beq 3000c7a8 <_Thread_queue_Enqueue_priority+0x14c>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
3000c6d4: e59cc000 ldr ip, [ip]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
3000c6d8: e15c0007 cmp ip, r7
3000c6dc: 0a000002 beq 3000c6ec <_Thread_queue_Enqueue_priority+0x90>
search_priority = search_thread->current_priority;
3000c6e0: e59c4014 ldr r4, [ip, #20]
if ( priority <= search_priority )
3000c6e4: e1530004 cmp r3, r4
3000c6e8: 8afffff3 bhi 3000c6bc <_Thread_queue_Enqueue_priority+0x60>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
3000c6ec: e5905030 ldr r5, [r0, #48] ; 0x30 3000c6f0: e3550001 cmp r5, #1
3000c6f4: 0a00002d beq 3000c7b0 <_Thread_queue_Enqueue_priority+0x154> * 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;
3000c6f8: e5828000 str r8, [r2] <== NOT EXECUTED
return the_thread_queue->sync_state; }
3000c6fc: e1a00005 mov r0, r5
3000c700: e8bd05f0 pop {r4, r5, r6, r7, r8, sl}
3000c704: e12fff1e bx lr
3000c708: e0877087 add r7, r7, r7, lsl #1
3000c70c: e59fa0f8 ldr sl, [pc, #248] ; 3000c80c <_Thread_queue_Enqueue_priority+0x1b0>
3000c710: e0807107 add r7, r0, r7, lsl #2
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
3000c714: e5da4000 ldrb r4, [sl] 3000c718: e2844001 add r4, r4, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c71c: e10f8000 mrs r8, CPSR 3000c720: e388c080 orr ip, r8, #128 ; 0x80 3000c724: e129f00c msr CPSR_fc, ip
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
3000c728: e597c008 ldr ip, [r7, #8]
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 ) ) {
3000c72c: e15c0007 cmp ip, r7
3000c730: 1a000009 bne 3000c75c <_Thread_queue_Enqueue_priority+0x100>
3000c734: ea00000b b 3000c768 <_Thread_queue_Enqueue_priority+0x10c>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000c738: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000c73c: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED 3000c740: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000c744: e59c6010 ldr r6, [ip, #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) ) {
3000c748: e1150006 tst r5, r6 <== NOT EXECUTED 3000c74c: 0a000013 beq 3000c7a0 <_Thread_queue_Enqueue_priority+0x144><== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
3000c750: e59cc004 ldr ip, [ip, #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 ) ) {
3000c754: e15c0007 cmp ip, r7 <== NOT EXECUTED 3000c758: 0a000002 beq 3000c768 <_Thread_queue_Enqueue_priority+0x10c><== NOT EXECUTED
search_priority = search_thread->current_priority;
3000c75c: e59c4014 ldr r4, [ip, #20]
if ( priority >= search_priority )
3000c760: e1530004 cmp r3, r4
3000c764: 3afffff3 bcc 3000c738 <_Thread_queue_Enqueue_priority+0xdc>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
3000c768: e5905030 ldr r5, [r0, #48] ; 0x30 3000c76c: e3550001 cmp r5, #1
3000c770: 1affffe0 bne 3000c6f8 <_Thread_queue_Enqueue_priority+0x9c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
3000c774: e1530004 cmp r3, r4
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000c778: e3a03000 mov r3, #0 3000c77c: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
3000c780: 0a000016 beq 3000c7e0 <_Thread_queue_Enqueue_priority+0x184>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
3000c784: e59c3000 ldr r3, [ip]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
3000c788: e8811008 stm r1, {r3, ip}
search_node->next = the_node; next_node->previous = the_node;
3000c78c: e5831004 str r1, [r3, #4]
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
3000c790: e58c1000 str r1, [ip]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
3000c794: e5810044 str r0, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c798: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000c79c: eaffffd6 b 3000c6fc <_Thread_queue_Enqueue_priority+0xa0>
3000c7a0: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED 3000c7a4: eaffffda b 3000c714 <_Thread_queue_Enqueue_priority+0xb8> <== NOT EXECUTED 3000c7a8: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED 3000c7ac: eaffffbb b 3000c6a0 <_Thread_queue_Enqueue_priority+0x44> <== NOT EXECUTED
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
3000c7b0: e1530004 cmp r3, r4
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000c7b4: e3a03000 mov r3, #0 3000c7b8: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
3000c7bc: 0a000007 beq 3000c7e0 <_Thread_queue_Enqueue_priority+0x184>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
3000c7c0: e59c3004 ldr r3, [ip, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000c7c4: e581c000 str ip, [r1]
the_node->previous = previous_node;
3000c7c8: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
3000c7cc: e5831000 str r1, [r3]
search_node->previous = the_node;
3000c7d0: e58c1004 str r1, [ip, #4]
the_thread->Wait.queue = the_thread_queue;
3000c7d4: e5810044 str r0, [r1, #68] ; 0x44 3000c7d8: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000c7dc: eaffffc6 b 3000c6fc <_Thread_queue_Enqueue_priority+0xa0>
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
3000c7e0: e59c3040 ldr r3, [ip, #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 );
3000c7e4: e28c203c add r2, ip, #60 ; 0x3c <== NOT EXECUTED
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000c7e8: e881000c stm r1, {r2, r3} <== NOT EXECUTED
the_node->previous = previous_node; previous_node->next = the_node;
3000c7ec: e5831000 str r1, [r3] <== NOT EXECUTED
search_node->previous = the_node;
3000c7f0: e58c1040 str r1, [ip, #64] ; 0x40 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
3000c7f4: e5810044 str r0, [r1, #68] ; 0x44 <== NOT EXECUTED 3000c7f8: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000c7fc: e3a05001 mov r5, #1 <== NOT EXECUTED 3000c800: eaffffbd b 3000c6fc <_Thread_queue_Enqueue_priority+0xa0> <== NOT EXECUTED
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
3000c804: e3e04000 mvn r4, #0 3000c808: eaffffb7 b 3000c6ec <_Thread_queue_Enqueue_priority+0x90>
30011f24 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
30011f24: e52de004 push {lr} ; (str lr, [sp, #-4]!)
30011f28: e24dd004 sub sp, sp, #4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30011f2c: e10f0000 mrs r0, CPSR 30011f30: e3803080 orr r3, r0, #128 ; 0x80 30011f34: e129f003 msr CPSR_fc, r3 30011f38: e59f3070 ldr r3, [pc, #112] ; 30011fb0 <_Thread_queue_Extract_fifo+0x8c> 30011f3c: e5912010 ldr r2, [r1, #16] 30011f40: e0023003 and r3, r2, r3
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
30011f44: e3530000 cmp r3, #0
30011f48: 0a00000d beq 30011f84 <_Thread_queue_Extract_fifo+0x60>
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30011f4c: e591c050 ldr ip, [r1, #80] ; 0x50
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
30011f50: e891000c ldm r1, {r2, r3}
30011f54: e35c0002 cmp ip, #2
next->previous = previous;
30011f58: e5823004 str r3, [r2, #4]
previous->next = next;
30011f5c: e5832000 str r2, [r3]
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
30011f60: e3a03000 mov r3, #0 30011f64: e5813044 str r3, [r1, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30011f68: 0a000008 beq 30011f90 <_Thread_queue_Extract_fifo+0x6c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30011f6c: e129f000 msr CPSR_fc, r0
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30011f70: e1a00001 mov r0, r1 30011f74: e59f1038 ldr r1, [pc, #56] ; 30011fb4 <_Thread_queue_Extract_fifo+0x90>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
30011f78: e28dd004 add sp, sp, #4
30011f7c: e49de004 pop {lr} ; (ldr lr, [sp], #4)
30011f80: eaffe781 b 3000bd8c <_Thread_Clear_state>
30011f84: e129f000 msr CPSR_fc, r0
30011f88: e28dd004 add sp, sp, #4
30011f8c: e8bd8000 pop {pc}
30011f90: e3a03003 mov r3, #3 <== NOT EXECUTED 30011f94: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 30011f98: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
30011f9c: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 30011fa0: e58d1000 str r1, [sp] <== NOT EXECUTED 30011fa4: ebffec5e bl 3000d124 <_Watchdog_Remove> <== NOT EXECUTED 30011fa8: e59d1000 ldr r1, [sp] <== NOT EXECUTED 30011fac: eaffffef b 30011f70 <_Thread_queue_Extract_fifo+0x4c> <== NOT EXECUTED
30010358 <_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
)
{
30010358: e92d4070 push {r4, r5, r6, lr}
3001035c: e20220ff and r2, r2, #255 ; 0xff
30010360: e24dd004 sub sp, sp, #4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30010364: e10fc000 mrs ip, CPSR 30010368: e38c3080 orr r3, ip, #128 ; 0x80 3001036c: 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);
30010370: e59f30c4 ldr r3, [pc, #196] ; 3001043c <_Thread_queue_Extract_priority_helper+0xe4> 30010374: e5910010 ldr r0, [r1, #16] 30010378: 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 ) ) {
3001037c: e3530000 cmp r3, #0
30010380: 0a000023 beq 30010414 <_Thread_queue_Extract_priority_helper+0xbc>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
30010384: e5913038 ldr r3, [r1, #56] ; 0x38 <== 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 );
30010388: e281003c add r0, r1, #60 ; 0x3c <== NOT EXECUTED
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3001038c: e1530000 cmp r3, r0 <== NOT EXECUTED
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
previous_node = the_node->previous;
30010390: e8910011 ldm r1, {r0, r4} <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
30010394: 05840000 streq r0, [r4] <== NOT EXECUTED
next_node->previous = previous_node;
30010398: 05804004 streq r4, [r0, #4] <== NOT EXECUTED
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3001039c: 0a00000e beq 300103dc <_Thread_queue_Extract_priority_helper+0x84><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
300103a0: e5915040 ldr r5, [r1, #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;
300103a4: e5936000 ldr r6, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
300103a8: 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;
300103ac: e5843000 str r3, [r4] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
300103b0: e8830011 stm r3, {r0, r4} <== NOT EXECUTED
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
300103b4: e5914038 ldr r4, [r1, #56] ; 0x38 <== NOT EXECUTED 300103b8: e5910040 ldr r0, [r1, #64] ; 0x40 <== NOT EXECUTED 300103bc: e1540000 cmp r4, r0 <== NOT EXECUTED 300103c0: 0a000005 beq 300103dc <_Thread_queue_Extract_priority_helper+0x84><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
300103c4: e2834038 add r4, r3, #56 ; 0x38 <== NOT EXECUTED
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
300103c8: e283003c add r0, r3, #60 ; 0x3c <== NOT EXECUTED
new_second_node->previous = head;
300103cc: e5864004 str r4, [r6, #4] <== NOT EXECUTED
head->next = new_second_node;
300103d0: e5836038 str r6, [r3, #56] ; 0x38 <== NOT EXECUTED
tail->previous = last_node;
300103d4: e5835040 str r5, [r3, #64] ; 0x40 <== NOT EXECUTED
last_node->next = tail;
300103d8: e5850000 str r0, [r5] <== NOT EXECUTED
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
300103dc: e3520000 cmp r2, #0 <== NOT EXECUTED 300103e0: 1a000008 bne 30010408 <_Thread_queue_Extract_priority_helper+0xb0><== NOT EXECUTED
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
300103e4: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED 300103e8: e3530002 cmp r3, #2 <== NOT EXECUTED 300103ec: 0a00000a beq 3001041c <_Thread_queue_Extract_priority_helper+0xc4><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300103f0: e129f00c msr CPSR_fc, ip <== NOT EXECUTED 300103f4: e1a00001 mov r0, r1 <== NOT EXECUTED 300103f8: e59f1040 ldr r1, [pc, #64] ; 30010440 <_Thread_queue_Extract_priority_helper+0xe8><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
300103fc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30010400: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
30010404: eaffee60 b 3000bd8c <_Thread_Clear_state> <== NOT EXECUTED
30010408: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
3001040c: e28dd004 add sp, sp, #4
30010410: e8bd8070 pop {r4, r5, r6, pc}
30010414: e129f00c msr CPSR_fc, ip
30010418: eafffffb b 3001040c <_Thread_queue_Extract_priority_helper+0xb4>
3001041c: e3a03003 mov r3, #3 <== NOT EXECUTED 30010420: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 30010424: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
30010428: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3001042c: e58d1000 str r1, [sp] <== NOT EXECUTED 30010430: ebfff33b bl 3000d124 <_Watchdog_Remove> <== NOT EXECUTED 30010434: e59d1000 ldr r1, [sp] <== NOT EXECUTED 30010438: eaffffed b 300103f4 <_Thread_queue_Extract_priority_helper+0x9c><== NOT EXECUTED
3000eaf4 <_Thread_queue_First_priority>:
*/
Thread_Control *_Thread_queue_First_priority (
Thread_queue_Control *the_thread_queue
)
{
3000eaf4: e3a03000 mov r3, #0 <== NOT EXECUTED
uint32_t index;
for( index=0 ;
3000eaf8: e1a02003 mov r2, r3 <== 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 );
3000eafc: e082c082 add ip, r2, r2, lsl #1 <== NOT EXECUTED
return (Thread_Control *) _Chain_First(
&the_thread_queue->Queues.Priority[ index ]
);
}
return NULL;
}
3000eb00: e7901003 ldr r1, [r0, r3] <== NOT EXECUTED 3000eb04: e080c10c add ip, r0, ip, lsl #2 <== NOT EXECUTED 3000eb08: e28cc004 add ip, ip, #4 <== 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 ] ) )
3000eb0c: e151000c cmp r1, ip <== NOT EXECUTED
{
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000eb10: e2822001 add r2, r2, #1 <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
3000eb14: 1a000004 bne 3000eb2c <_Thread_queue_First_priority+0x38> <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3000eb18: e3520004 cmp r2, #4 <== NOT EXECUTED
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000eb1c: e283300c add r3, r3, #12 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3000eb20: 1afffff5 bne 3000eafc <_Thread_queue_First_priority+0x8> <== 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;
3000eb24: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000eb28: e12fff1e bx lr <== NOT EXECUTED
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
return (Thread_Control *) _Chain_First(
3000eb2c: e1a00001 mov r0, r1 <== NOT EXECUTED 3000eb30: e12fff1e bx lr <== NOT EXECUTED
30010444 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
30010444: e1a01000 mov r1, r0 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
30010448: 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 &&
3001044c: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 30010450: e3530000 cmp r3, #0 <== NOT EXECUTED 30010454: 0a000003 beq 30010468 <_Thread_queue_Process_timeout+0x24> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
30010458: e59f202c ldr r2, [pc, #44] ; 3001048c <_Thread_queue_Process_timeout+0x48><== NOT EXECUTED 3001045c: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 30010460: e1510002 cmp r1, r2 <== NOT EXECUTED 30010464: 0a000002 beq 30010474 <_Thread_queue_Process_timeout+0x30> <== NOT EXECUTED
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
30010468: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3001046c: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
30010470: eaffffb2 b 30010340 <_Thread_queue_Extract> <== NOT EXECUTED
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
30010474: e3530003 cmp r3, #3 <== NOT EXECUTED
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
30010478: 1590303c ldrne r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3001047c: 15813034 strne r3, [r1, #52] ; 0x34 <== NOT EXECUTED
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
30010480: 13a03002 movne r3, #2 <== NOT EXECUTED 30010484: 15803030 strne r3, [r0, #48] ; 0x30 <== NOT EXECUTED 30010488: e12fff1e bx lr <== NOT EXECUTED
3000c8d4 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000c8d4: e92d4070 push {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 )
3000c8d8: e2504000 subs r4, r0, #0 <== NOT EXECUTED
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000c8dc: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000c8e0: 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 )
3000c8e4: 0a000002 beq 3000c8f4 <_Thread_queue_Requeue+0x20> <== 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 ) {
3000c8e8: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000c8ec: e3530001 cmp r3, #1 <== NOT EXECUTED 3000c8f0: 0a000001 beq 3000c8fc <_Thread_queue_Requeue+0x28> <== NOT EXECUTED
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
}
}
3000c8f4: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c8f8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c8fc: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000c900: e3862080 orr r2, r6, #128 ; 0x80 <== NOT EXECUTED 3000c904: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3000c908: e59f2034 ldr r2, [pc, #52] ; 3000c944 <_Thread_queue_Requeue+0x70><== NOT EXECUTED 3000c90c: e591c010 ldr ip, [r1, #16] <== NOT EXECUTED 3000c910: e00c2002 and r2, ip, r2 <== 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 ) ) {
3000c914: e3520000 cmp r2, #0 <== NOT EXECUTED 3000c918: 1a000001 bne 3000c924 <_Thread_queue_Requeue+0x50> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c91c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000c920: eafffff3 b 3000c8f4 <_Thread_queue_Requeue+0x20> <== NOT EXECUTED
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
3000c924: e1a02003 mov r2, r3 <== 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;
3000c928: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED 3000c92c: eb000e89 bl 30010358 <_Thread_queue_Extract_priority_helper><== NOT EXECUTED
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
3000c930: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c934: e1a01005 mov r1, r5 <== NOT EXECUTED 3000c938: e1a0200d mov r2, sp <== NOT EXECUTED 3000c93c: ebffff46 bl 3000c65c <_Thread_queue_Enqueue_priority> <== NOT EXECUTED 3000c940: eafffff5 b 3000c91c <_Thread_queue_Requeue+0x48> <== NOT EXECUTED
3000c948 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000c948: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000c94c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000c950: e1a0100d mov r1, sp <== NOT EXECUTED 3000c954: ebfffdf2 bl 3000c124 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000c958: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000c95c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c960: 1a000004 bne 3000c978 <_Thread_queue_Timeout+0x30> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
3000c964: eb000eb6 bl 30010444 <_Thread_queue_Process_timeout> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000c968: e59f3010 ldr r3, [pc, #16] ; 3000c980 <_Thread_queue_Timeout+0x38><== NOT EXECUTED 3000c96c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c970: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000c974: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000c978: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c97c: e8bd8000 pop {pc} <== NOT EXECUTED
3001a5b4 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
3001a5b4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3001a5b8: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001a5bc: e28d101c add r1, sp, #28 <== NOT EXECUTED 3001a5c0: e2812004 add r2, r1, #4 <== NOT EXECUTED 3001a5c4: e28d7010 add r7, sp, #16 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001a5c8: e58d1024 str r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3001a5cc: e2801008 add r1, r0, #8 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3001a5d0: e3a03000 mov r3, #0 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001a5d4: e287a004 add sl, r7, #4 <== NOT EXECUTED 3001a5d8: e58d1008 str r1, [sp, #8] <== NOT EXECUTED 3001a5dc: e59f91c0 ldr r9, [pc, #448] ; 3001a7a4 <_Timer_server_Body+0x1f0><== NOT EXECUTED 3001a5e0: e2801040 add r1, r0, #64 ; 0x40 <== NOT EXECUTED 3001a5e4: e59fb1bc ldr fp, [pc, #444] ; 3001a7a8 <_Timer_server_Body+0x1f4><== NOT EXECUTED 3001a5e8: e1a04000 mov r4, r0 <== NOT EXECUTED 3001a5ec: e58d201c str r2, [sp, #28] <== NOT EXECUTED
head->previous = NULL;
3001a5f0: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001a5f4: e58da010 str sl, [sp, #16] <== NOT EXECUTED
head->previous = NULL;
3001a5f8: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
tail->previous = head;
3001a5fc: e58d7018 str r7, [sp, #24] <== NOT EXECUTED 3001a600: e2806030 add r6, r0, #48 ; 0x30 <== NOT EXECUTED 3001a604: e2808068 add r8, r0, #104 ; 0x68 <== NOT EXECUTED 3001a608: e58d100c str r1, [sp, #12] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
3001a60c: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
Chain_Control *tmp; /* * 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;
3001a610: e28d201c add r2, sp, #28 <== NOT EXECUTED 3001a614: e58da000 str sl, [sp] <== NOT EXECUTED 3001a618: e59da004 ldr sl, [sp, #4] <== NOT EXECUTED 3001a61c: e5842078 str r2, [r4, #120] ; 0x78 <== NOT EXECUTED
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
3001a620: e5993000 ldr r3, [r9] <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
3001a624: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
3001a628: e1a02007 mov r2, r7 <== NOT EXECUTED 3001a62c: e1a00006 mov r0, r6 <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
3001a630: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
3001a634: e0611003 rsb r1, r1, r3 <== NOT EXECUTED 3001a638: eb0011da bl 3001eda8 <_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();
3001a63c: e59b5000 ldr r5, [fp] <== NOT EXECUTED
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
3001a640: 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 ) {
3001a644: e1550002 cmp r5, r2 <== NOT EXECUTED 3001a648: 8a00003c bhi 3001a740 <_Timer_server_Body+0x18c> <== NOT EXECUTED
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
3001a64c: 3a000032 bcc 3001a71c <_Timer_server_Body+0x168> <== NOT EXECUTED
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
3001a650: 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 );
3001a654: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED 3001a658: eb0002d1 bl 3001b1a4 <_Chain_Get> <== NOT EXECUTED
if ( timer == NULL ) {
3001a65c: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3001a660: 0a00000b beq 3001a694 <_Timer_server_Body+0xe0> <== NOT EXECUTED
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001a664: e5913038 ldr r3, [r1, #56] ; 0x38 <== NOT EXECUTED 3001a668: e3530001 cmp r3, #1 <== NOT EXECUTED 3001a66c: 0a00002f beq 3001a730 <_Timer_server_Body+0x17c> <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
3001a670: e3530003 cmp r3, #3 <== NOT EXECUTED 3001a674: 1afffff6 bne 3001a654 <_Timer_server_Body+0xa0> <== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
3001a678: e2811010 add r1, r1, #16 <== NOT EXECUTED 3001a67c: e1a00008 mov r0, r8 <== NOT EXECUTED 3001a680: eb0011f3 bl 3001ee54 <_Watchdog_Insert> <== NOT EXECUTED
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
3001a684: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED 3001a688: eb0002c5 bl 3001b1a4 <_Chain_Get> <== NOT EXECUTED
if ( timer == NULL ) {
3001a68c: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3001a690: 1afffff3 bne 3001a664 <_Timer_server_Body+0xb0> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a694: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001a698: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3001a69c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
tmp = ts->insert_chain;
3001a6a0: e5942078 ldr r2, [r4, #120] ; 0x78 <== NOT EXECUTED
if ( _Chain_Is_empty( insert_chain ) ) {
3001a6a4: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 3001a6a8: e152000a cmp r2, sl <== NOT EXECUTED
ts->insert_chain = NULL;
3001a6ac: 05841078 streq r1, [r4, #120] ; 0x78 <== NOT EXECUTED
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
tmp = ts->insert_chain;
if ( _Chain_Is_empty( insert_chain ) ) {
3001a6b0: 13a01001 movne r1, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a6b4: e129f003 msr CPSR_fc, r3 <== 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;
while ( do_loop ) {
3001a6b8: e3510000 cmp r1, #0 <== NOT EXECUTED 3001a6bc: 1affffd7 bne 3001a620 <_Timer_server_Body+0x6c> <== NOT EXECUTED 3001a6c0: e59da000 ldr sl, [sp] <== 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 ) ) {
3001a6c4: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3001a6c8: e153000a cmp r3, sl <== NOT EXECUTED 3001a6cc: 1a00000a bne 3001a6fc <_Timer_server_Body+0x148> <== NOT EXECUTED 3001a6d0: ea00001f b 3001a754 <_Timer_server_Body+0x1a0> <== 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;
3001a6d4: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
3001a6d8: e5827004 str r7, [r2, #4] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
3001a6dc: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
3001a6e0: e3a02000 mov r2, #0 <== NOT EXECUTED 3001a6e4: e5832008 str r2, [r3, #8] <== NOT EXECUTED 3001a6e8: e129f001 msr CPSR_fc, r1 <== 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 );
3001a6ec: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 3001a6f0: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 3001a6f4: e1a0e00f mov lr, pc <== NOT EXECUTED 3001a6f8: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a6fc: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001a700: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 3001a704: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001a708: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
3001a70c: e153000a cmp r3, sl <== NOT EXECUTED 3001a710: 1affffef bne 3001a6d4 <_Timer_server_Body+0x120> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a714: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 3001a718: eaffffbc b 3001a610 <_Timer_server_Body+0x5c> <== 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 );
3001a71c: e1a00008 mov r0, r8 <== NOT EXECUTED 3001a720: e3a01001 mov r1, #1 <== NOT EXECUTED 3001a724: e0652002 rsb r2, r5, r2 <== NOT EXECUTED 3001a728: eb00116d bl 3001ece4 <_Watchdog_Adjust> <== NOT EXECUTED 3001a72c: eaffffc7 b 3001a650 <_Timer_server_Body+0x9c> <== NOT EXECUTED
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
3001a730: e1a00006 mov r0, r6 <== NOT EXECUTED 3001a734: e2811010 add r1, r1, #16 <== NOT EXECUTED 3001a738: eb0011c5 bl 3001ee54 <_Watchdog_Insert> <== NOT EXECUTED 3001a73c: eaffffc4 b 3001a654 <_Timer_server_Body+0xa0> <== 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 );
3001a740: e0621005 rsb r1, r2, r5 <== NOT EXECUTED 3001a744: e1a00008 mov r0, r8 <== NOT EXECUTED 3001a748: e1a02007 mov r2, r7 <== NOT EXECUTED 3001a74c: eb001195 bl 3001eda8 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 3001a750: eaffffbe b 3001a650 <_Timer_server_Body+0x9c> <== NOT EXECUTED
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
3001a754: e5c4107c strb r1, [r4, #124] ; 0x7c <== NOT EXECUTED 3001a758: e59f104c ldr r1, [pc, #76] ; 3001a7ac <_Timer_server_Body+0x1f8><== NOT EXECUTED 3001a75c: e5913000 ldr r3, [r1] <== NOT EXECUTED 3001a760: e2833001 add r3, r3, #1 <== NOT EXECUTED 3001a764: e5813000 str r3, [r1] <== NOT EXECUTED
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
3001a768: e3a01008 mov r1, #8 <== NOT EXECUTED 3001a76c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3001a770: eb000fa7 bl 3001e614 <_Thread_Set_state> <== NOT EXECUTED
_Timer_server_Reset_interval_system_watchdog( ts );
3001a774: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a778: ebffff61 bl 3001a504 <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED
_Timer_server_Reset_tod_system_watchdog( ts );
3001a77c: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a780: ebffff75 bl 3001a55c <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED
_Thread_Enable_dispatch();
3001a784: eb000d4b bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
ts->active = true;
3001a788: e3a02001 mov r2, #1 <== NOT EXECUTED 3001a78c: e5c4207c strb r2, [r4, #124] ; 0x7c <== NOT EXECUTED
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
3001a790: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 3001a794: eb00121d bl 3001f010 <_Watchdog_Remove> <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
3001a798: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED 3001a79c: eb00121b bl 3001f010 <_Watchdog_Remove> <== NOT EXECUTED 3001a7a0: eaffff9a b 3001a610 <_Timer_server_Body+0x5c> <== NOT EXECUTED
3001a504 <_Timer_server_Reset_interval_system_watchdog>:
}
static void _Timer_server_Reset_interval_system_watchdog(
Timer_server_Control *ts
)
{
3001a504: 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 );
3001a508: e2805008 add r5, r0, #8 <== NOT EXECUTED
}
static void _Timer_server_Reset_interval_system_watchdog(
Timer_server_Control *ts
)
{
3001a50c: 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 );
3001a510: e1a00005 mov r0, r5 <== NOT EXECUTED 3001a514: eb0012bd bl 3001f010 <_Watchdog_Remove> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a518: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001a51c: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 3001a520: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001a524: 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 );
3001a528: 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 ) ) {
3001a52c: e1530002 cmp r3, r2 <== NOT EXECUTED 3001a530: 0a000006 beq 3001a550 <_Timer_server_Reset_interval_system_watchdog+0x4c><== NOT EXECUTED
Watchdog_Interval delta_interval =
3001a534: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a538: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3001a53c: e59f0014 ldr r0, [pc, #20] ; 3001a558 <_Timer_server_Reset_interval_system_watchdog+0x54><== NOT EXECUTED 3001a540: e1a01005 mov r1, r5 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001a544: e5843014 str r3, [r4, #20] <== NOT EXECUTED
delta_interval
);
} else {
_ISR_Enable( level );
}
}
3001a548: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3001a54c: ea001240 b 3001ee54 <_Watchdog_Insert> <== NOT EXECUTED
3001a550: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
3001a554: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3001a55c <_Timer_server_Reset_tod_system_watchdog>:
}
static void _Timer_server_Reset_tod_system_watchdog(
Timer_server_Control *ts
)
{
3001a55c: 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 );
3001a560: e2805040 add r5, r0, #64 ; 0x40 <== NOT EXECUTED
}
static void _Timer_server_Reset_tod_system_watchdog(
Timer_server_Control *ts
)
{
3001a564: 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 );
3001a568: e1a00005 mov r0, r5 <== NOT EXECUTED 3001a56c: eb0012a7 bl 3001f010 <_Watchdog_Remove> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a570: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001a574: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 3001a578: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001a57c: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED 3001a580: 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 ) ) {
3001a584: e1530002 cmp r3, r2 <== NOT EXECUTED 3001a588: 0a000006 beq 3001a5a8 <_Timer_server_Reset_tod_system_watchdog+0x4c><== NOT EXECUTED
Watchdog_Interval delta_interval =
3001a58c: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a590: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001a594: e59f0014 ldr r0, [pc, #20] ; 3001a5b0 <_Timer_server_Reset_tod_system_watchdog+0x54><== NOT EXECUTED 3001a598: e1a01005 mov r1, r5 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001a59c: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
delta_interval
);
} else {
_ISR_Enable( level );
}
}
3001a5a0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001a5a4: ea00122a b 3001ee54 <_Watchdog_Insert> <== NOT EXECUTED
3001a5a8: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
3001a5ac: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3001a7b0 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( ts->insert_chain == NULL ) {
3001a7b0: e5902078 ldr r2, [r0, #120] ; 0x78 <== NOT EXECUTED
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
3001a7b4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
3001a7b8: e3520000 cmp r2, #0 <== NOT EXECUTED
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
3001a7bc: e1a04000 mov r4, r0 <== NOT EXECUTED 3001a7c0: e1a03001 mov r3, r1 <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
3001a7c4: 0a000002 beq 3001a7d4 <_Timer_server_Schedule_operation_method+0x24><== 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 );
3001a7c8: e5900078 ldr r0, [r0, #120] ; 0x78 <== NOT EXECUTED
} }
3001a7cc: e8bd4030 pop {r4, r5, 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 );
3001a7d0: ea000260 b 3001b158 <_Chain_Append> <== NOT EXECUTED 3001a7d4: e59f1104 ldr r1, [pc, #260] ; 3001a8e0 <_Timer_server_Schedule_operation_method+0x130><== NOT EXECUTED 3001a7d8: e5910000 ldr r0, [r1] <== NOT EXECUTED 3001a7dc: e2800001 add r0, r0, #1 <== NOT EXECUTED 3001a7e0: e5810000 str r0, [r1] <== NOT EXECUTED
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001a7e4: e5931038 ldr r1, [r3, #56] ; 0x38 <== NOT EXECUTED 3001a7e8: e3510001 cmp r1, #1 <== NOT EXECUTED 3001a7ec: 0a000021 beq 3001a878 <_Timer_server_Schedule_operation_method+0xc8><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
if ( !ts->active ) {
_Timer_server_Reset_interval_system_watchdog( ts );
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
3001a7f0: e3510003 cmp r1, #3 <== NOT EXECUTED 3001a7f4: 0a000001 beq 3001a800 <_Timer_server_Schedule_operation_method+0x50><== 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 );
}
}
3001a7f8: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
3001a7fc: ea000d2d b 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a800: e10fe000 mrs lr, CPSR <== NOT EXECUTED 3001a804: e38e1080 orr r1, lr, #128 ; 0x80 <== NOT EXECUTED 3001a808: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001a80c: e5941068 ldr r1, [r4, #104] ; 0x68 <== 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 );
3001a810: e284006c add r0, r4, #108 ; 0x6c <== NOT EXECUTED
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
3001a814: e1510000 cmp r1, r0 <== 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();
3001a818: e59f00c4 ldr r0, [pc, #196] ; 3001a8e4 <_Timer_server_Schedule_operation_method+0x134><== NOT EXECUTED
last_snapshot = ts->TOD_watchdogs.last_snapshot;
3001a81c: e594c074 ldr ip, [r4, #116] ; 0x74 <== 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();
3001a820: e5900000 ldr r0, [r0] <== NOT EXECUTED
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
3001a824: 0a000008 beq 3001a84c <_Timer_server_Schedule_operation_method+0x9c><== NOT EXECUTED
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
3001a828: e5915010 ldr r5, [r1, #16] <== NOT EXECUTED
if ( snapshot > last_snapshot ) {
3001a82c: e150000c cmp r0, ip <== NOT EXECUTED
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
3001a830: 9085200c addls r2, r5, ip <== NOT EXECUTED
delta_interval += delta;
3001a834: 90602002 rsbls r2, r0, r2 <== 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 ) {
3001a838: 9a000002 bls 3001a848 <_Timer_server_Schedule_operation_method+0x98><== NOT EXECUTED
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
3001a83c: e06cc000 rsb ip, ip, r0 <== NOT EXECUTED
if (delta_interval > delta) {
3001a840: e155000c cmp r5, ip <== NOT EXECUTED
delta_interval -= delta;
3001a844: 806c2005 rsbhi r2, ip, r5 <== NOT EXECUTED
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
3001a848: e5812010 str r2, [r1, #16] <== NOT EXECUTED
}
ts->TOD_watchdogs.last_snapshot = snapshot;
3001a84c: e5840074 str r0, [r4, #116] ; 0x74 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a850: e129f00e msr CPSR_fc, lr <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
3001a854: e2831010 add r1, r3, #16 <== NOT EXECUTED 3001a858: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED 3001a85c: eb00117c bl 3001ee54 <_Watchdog_Insert> <== NOT EXECUTED
if ( !ts->active ) {
3001a860: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3001a864: e3530000 cmp r3, #0 <== NOT EXECUTED 3001a868: 1affffe2 bne 3001a7f8 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
_Timer_server_Reset_tod_system_watchdog( ts );
3001a86c: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a870: ebffff39 bl 3001a55c <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED 3001a874: eaffffdf b 3001a7f8 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a878: e10f5000 mrs r5, CPSR <== NOT EXECUTED 3001a87c: e3851080 orr r1, r5, #128 ; 0x80 <== NOT EXECUTED 3001a880: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001a884: e5941030 ldr r1, [r4, #48] ; 0x30 <== NOT EXECUTED 3001a888: e2840034 add r0, r4, #52 ; 0x34 <== NOT EXECUTED
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
last_snapshot = ts->Interval_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
3001a88c: e1510000 cmp r1, r0 <== 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;
3001a890: e59f0050 ldr r0, [pc, #80] ; 3001a8e8 <_Timer_server_Schedule_operation_method+0x138><== NOT EXECUTED 3001a894: e5900000 ldr r0, [r0] <== NOT EXECUTED
last_snapshot = ts->Interval_watchdogs.last_snapshot;
3001a898: e594c03c ldr ip, [r4, #60] ; 0x3c <== NOT EXECUTED
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
3001a89c: 0a000004 beq 3001a8b4 <_Timer_server_Schedule_operation_method+0x104><== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
3001a8a0: e591e010 ldr lr, [r1, #16] <== NOT EXECUTED
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
3001a8a4: e06cc000 rsb ip, ip, r0 <== NOT EXECUTED
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
3001a8a8: e15c000e cmp ip, lr <== NOT EXECUTED
delta_interval -= delta;
3001a8ac: 306c200e rsbcc r2, ip, lr <== NOT EXECUTED
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
3001a8b0: e5812010 str r2, [r1, #16] <== NOT EXECUTED
}
ts->Interval_watchdogs.last_snapshot = snapshot;
3001a8b4: e584003c str r0, [r4, #60] ; 0x3c <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a8b8: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
3001a8bc: e2831010 add r1, r3, #16 <== NOT EXECUTED 3001a8c0: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 3001a8c4: eb001162 bl 3001ee54 <_Watchdog_Insert> <== NOT EXECUTED
if ( !ts->active ) {
3001a8c8: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3001a8cc: e3530000 cmp r3, #0 <== NOT EXECUTED 3001a8d0: 1affffc8 bne 3001a7f8 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
_Timer_server_Reset_interval_system_watchdog( ts );
3001a8d4: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a8d8: ebffff09 bl 3001a504 <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED 3001a8dc: eaffffc5 b 3001a7f8 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
3000cbfc <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
3000cbfc: e1a03000 mov r3, r0
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
3000cc00: e5902004 ldr r2, [r0, #4]
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
3000cc04: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
3000cc08: e8910011 ldm r1, {r0, r4}
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000cc0c: e59fc040 ldr ip, [pc, #64] ; 3000cc54 <_Timespec_Add_to+0x58>
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000cc10: e5931000 ldr r1, [r3]
time->tv_nsec += add->tv_nsec;
3000cc14: e0844002 add r4, r4, r2
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000cc18: e0811000 add r1, r1, r0
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000cc1c: e154000c cmp r4, ip 3000cc20: e1a02004 mov r2, r4
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000cc24: e8830012 stm r3, {r1, r4}
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000cc28: 9a000007 bls 3000cc4c <_Timespec_Add_to+0x50>
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000cc2c: e2822331 add r2, r2, #-1006632960 ; 0xc4000000 <== NOT EXECUTED 3000cc30: e2822865 add r2, r2, #6619136 ; 0x650000 <== NOT EXECUTED 3000cc34: e2822c36 add r2, r2, #13824 ; 0x3600 <== 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 ) {
3000cc38: e152000c cmp r2, ip <== NOT EXECUTED
*
* This routines adds two timespecs. The second argument is added
* to the first.
*/
uint32_t _Timespec_Add_to(
3000cc3c: e2811001 add r1, r1, #1 <== NOT EXECUTED
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
time->tv_sec++;
seconds++;
3000cc40: e2800001 add r0, r0, #1 <== 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 ) {
3000cc44: 8afffff8 bhi 3000cc2c <_Timespec_Add_to+0x30> <== NOT EXECUTED
3000cc48: e8830006 stm r3, {r1, r2} <== NOT EXECUTED
time->tv_sec++;
seconds++;
}
return seconds;
}
3000cc4c: e8bd0010 pop {r4}
3000cc50: e12fff1e bx lr
3000e8cc <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000e8cc: e92d48f0 push {r4, r5, r6, r7, fp, lr}
* 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;
3000e8d0: e5916004 ldr r6, [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;
3000e8d4: e591c000 ldr ip, [r1] 3000e8d8: e59f1074 ldr r1, [pc, #116] ; 3000e954 <_Timespec_Divide+0x88>
right += rhs->tv_nsec;
3000e8dc: e1a07fc6 asr r7, r6, #31 3000e8e0: e0e76c91 smlal r6, r7, r1, ip
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000e8e4: e1a04003 mov r4, r3
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 ) {
3000e8e8: e196c007 orrs ip, r6, r7
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000e8ec: e8900808 ldm r0, {r3, fp}
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000e8f0: e1a05002 mov r5, r2
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
*ival_percentage = 0;
3000e8f4: 0582c000 streq ip, [r2]
*fval_percentage = 0;
3000e8f8: 0584c000 streq ip, [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 ) {
3000e8fc: 08bd88f0 popeq {r4, r5, r6, r7, fp, 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;
3000e900: e1a0cfcb asr ip, fp, #31 <== NOT EXECUTED 3000e904: e0ecb391 smlal fp, ip, r1, r3 <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
3000e908: e59fe048 ldr lr, [pc, #72] ; 3000e958 <_Timespec_Divide+0x8c><== NOT EXECUTED 3000e90c: e1a02006 mov r2, r6 <== NOT EXECUTED 3000e910: e0810e9b umull r0, r1, fp, lr <== NOT EXECUTED 3000e914: e1a03007 mov r3, r7 <== NOT EXECUTED 3000e918: e0211c9e mla r1, lr, ip, r1 <== NOT EXECUTED 3000e91c: eb0040b7 bl 3001ec00 <__udivdi3> <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000e920: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000e924: 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;
3000e928: e1a06000 mov r6, r0 <== NOT EXECUTED 3000e92c: e1a07001 mov r7, r1 <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000e930: eb0040b2 bl 3001ec00 <__udivdi3> <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000e934: e1a01007 mov r1, r7 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
3000e938: e5850000 str r0, [r5] <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000e93c: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
3000e940: e3a03000 mov r3, #0 <== NOT EXECUTED
3000e944: e1a00006 mov r0, r6 <== NOT EXECUTED
3000e948: eb0041be bl 3001f048 <__umoddi3> <== NOT EXECUTED
3000e94c: e5840000 str r0, [r4] <== NOT EXECUTED
3000e950: e8bd88f0 pop {r4, r5, r6, r7, fp, pc} <== NOT EXECUTED
3000e8ec <_Timespec_Divide_by_integer>:
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
t = time->tv_sec;
3000e8ec: e590c000 ldr ip, [r0] <== NOT EXECUTED
t *= TOD_NANOSECONDS_PER_SECOND;
3000e8f0: e59f3068 ldr r3, [pc, #104] ; 3000e960 <_Timespec_Divide_by_integer+0x74><== NOT EXECUTED
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3000e8f4: e92d41f0 push {r4, r5, r6, r7, r8, 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;
3000e8f8: e086539c umull r5, r6, ip, r3 <== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
t = time->tv_sec;
3000e8fc: e1a0700c mov r7, ip <== NOT EXECUTED 3000e900: e1a08fc7 asr r8, r7, #31 <== NOT EXECUTED
t *= TOD_NANOSECONDS_PER_SECOND;
3000e904: e0266893 mla r6, r3, r8, r6 <== NOT EXECUTED
t += time->tv_nsec;
3000e908: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3000e90c: e1a04002 mov r4, r2 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3000e910: e0957000 adds r7, r5, r0 <== NOT EXECUTED 3000e914: e0a68fc0 adc r8, r6, r0, asr #31 <== NOT EXECUTED 3000e918: e1a02001 mov r2, r1 <== NOT EXECUTED 3000e91c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000e920: e1a00007 mov r0, r7 <== NOT EXECUTED 3000e924: e1a01008 mov r1, r8 <== NOT EXECUTED 3000e928: eb003ef1 bl 3001e4f4 <__udivdi3> <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000e92c: e59f202c ldr r2, [pc, #44] ; 3000e960 <_Timespec_Divide_by_integer+0x74><== NOT EXECUTED 3000e930: e3a03000 mov r3, #0 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3000e934: e1a05000 mov r5, r0 <== NOT EXECUTED 3000e938: e1a06001 mov r6, r1 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000e93c: eb003eec bl 3001e4f4 <__udivdi3> <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
3000e940: e59f2018 ldr r2, [pc, #24] ; 3000e960 <_Timespec_Divide_by_integer+0x74><== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000e944: e5840000 str r0, [r4] <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
3000e948: e3a03000 mov r3, #0 <== NOT EXECUTED 3000e94c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000e950: e1a00005 mov r0, r5 <== NOT EXECUTED 3000e954: eb003ff8 bl 3001e93c <__umoddi3> <== NOT EXECUTED 3000e958: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
3000e95c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3001ef18 <_Timespec_From_ticks>:
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
3001ef18: e59f3034 ldr r3, [pc, #52] ; 3001ef54 <_Timespec_From_ticks+0x3c><== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
3001ef1c: e59f2034 ldr r2, [pc, #52] ; 3001ef58 <_Timespec_From_ticks+0x40><== NOT EXECUTED
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
3001ef20: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 3001ef24: e0000093 mul r0, r3, r0 <== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
3001ef28: e0823290 umull r3, r2, r0, r2 <== NOT EXECUTED 3001ef2c: e1a02922 lsr r2, r2, #18 <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
3001ef30: e0623282 rsb r3, r2, r2, lsl #5 <== NOT EXECUTED 3001ef34: e0633303 rsb r3, r3, r3, lsl #6 <== NOT EXECUTED 3001ef38: e0823183 add r3, r2, r3, lsl #3 <== NOT EXECUTED 3001ef3c: e0403303 sub r3, r0, r3, lsl #6 <== NOT EXECUTED 3001ef40: e0630283 rsb r0, r3, r3, lsl #5 <== NOT EXECUTED 3001ef44: e0833100 add r3, r3, r0, lsl #2 <== NOT EXECUTED 3001ef48: e1a03183 lsl r3, r3, #3 <== NOT EXECUTED
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
3001ef4c: e881000c stm r1, {r2, r3} <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
TOD_NANOSECONDS_PER_MICROSECOND;
}
3001ef50: e12fff1e bx lr <== NOT EXECUTED
3001ef5c <_Timespec_Is_valid>:
bool _Timespec_Is_valid(
const struct timespec *time
)
{
if ( !time )
3001ef5c: e3500000 cmp r0, #0 <== NOT EXECUTED 3001ef60: 012fff1e bxeq lr <== NOT EXECUTED
return false;
if ( time->tv_sec < 0 )
3001ef64: e5903000 ldr r3, [r0] <== NOT EXECUTED 3001ef68: e3530000 cmp r3, #0 <== NOT EXECUTED
return false;
3001ef6c: b3a00000 movlt r0, #0 <== NOT EXECUTED
)
{
if ( !time )
return false;
if ( time->tv_sec < 0 )
3001ef70: b12fff1e bxlt lr <== NOT EXECUTED
return false;
if ( time->tv_nsec < 0 )
3001ef74: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 3001ef78: e3530000 cmp r3, #0 <== NOT EXECUTED 3001ef7c: ba000004 blt 3001ef94 <_Timespec_Is_valid+0x38> <== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
3001ef80: e59f0014 ldr r0, [pc, #20] ; 3001ef9c <_Timespec_Is_valid+0x40><== NOT EXECUTED 3001ef84: e1530000 cmp r3, r0 <== NOT EXECUTED 3001ef88: 83a00000 movhi r0, #0 <== NOT EXECUTED 3001ef8c: 93a00001 movls r0, #1 <== NOT EXECUTED 3001ef90: e12fff1e bx lr <== NOT EXECUTED
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
3001ef94: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
3001ef98: e12fff1e bx lr <== NOT EXECUTED
300104e4 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
300104e4: e5902000 ldr r2, [r0] 300104e8: e5913000 ldr r3, [r1] 300104ec: e1520003 cmp r2, r3
return true;
300104f0: b3a00001 movlt r0, #1
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
300104f4: b12fff1e bxlt lr
return true;
if ( lhs->tv_sec > rhs->tv_sec )
300104f8: ca000005 bgt 30010514 <_Timespec_Less_than+0x30>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Less_than(
300104fc: e5900004 ldr r0, [r0, #4] 30010500: e5913004 ldr r3, [r1, #4] 30010504: e1500003 cmp r0, r3 30010508: a3a00000 movge r0, #0 3001050c: b3a00001 movlt r0, #1 30010510: e12fff1e bx lr
{
if ( lhs->tv_sec < rhs->tv_sec )
return true;
if ( lhs->tv_sec > rhs->tv_sec )
return false;
30010514: e3a00000 mov r0, #0 <== NOT EXECUTED
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
return true;
return false;
}
30010518: e12fff1e bx lr <== NOT EXECUTED
3000cc58 <_Timespec_Subtract>:
const struct timespec *end,
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
3000cc58: e591c004 ldr ip, [r1, #4] 3000cc5c: e5903004 ldr r3, [r0, #4]
void _Timespec_Subtract(
const struct timespec *start,
const struct timespec *end,
struct timespec *result
)
{
3000cc60: e92d0030 push {r4, r5}
if (end->tv_nsec < start->tv_nsec) {
3000cc64: e15c0003 cmp ip, r3
3000cc68: ba000006 blt 3000cc88 <_Timespec_Subtract+0x30>
result->tv_sec = end->tv_sec - start->tv_sec - 1;
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
} else {
result->tv_sec = end->tv_sec - start->tv_sec;
3000cc6c: e5914000 ldr r4, [r1] 3000cc70: e5901000 ldr r1, [r0]
result->tv_nsec = end->tv_nsec - start->tv_nsec;
3000cc74: e063300c rsb r3, r3, ip
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
} else {
result->tv_sec = end->tv_sec - start->tv_sec;
3000cc78: e0611004 rsb r1, r1, r4
3000cc7c: e882000a stm r2, {r1, r3}
result->tv_nsec = end->tv_nsec - start->tv_nsec;
}
}
3000cc80: e8bd0030 pop {r4, r5}
3000cc84: e12fff1e bx lr
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000cc88: e5915000 ldr r5, [r1] <== NOT EXECUTED
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000cc8c: e59f1018 ldr r1, [pc, #24] ; 3000ccac <_Timespec_Subtract+0x54><== NOT EXECUTED
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000cc90: e5904000 ldr r4, [r0] <== NOT EXECUTED
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000cc94: e08c1001 add r1, ip, r1 <== NOT EXECUTED
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000cc98: e2450001 sub r0, r5, #1 <== NOT EXECUTED 3000cc9c: e0640000 rsb r0, r4, r0 <== NOT EXECUTED
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000cca0: e0633001 rsb r3, r3, r1 <== NOT EXECUTED
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000cca4: e8820009 stm r2, {r0, r3} <== NOT EXECUTED
3000cca8: eafffff4 b 3000cc80 <_Timespec_Subtract+0x28> <== NOT EXECUTED
300104c0 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
300104c0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
300104c4: e5904000 ldr r4, [r0] <== NOT EXECUTED
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
300104c8: e1a05000 mov r5, r0 <== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
300104cc: e3540000 cmp r4, #0 <== NOT EXECUTED
300104d0: 1a000002 bne 300104e0 <_Timespec_To_ticks+0x20> <== NOT EXECUTED
300104d4: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED
300104d8: e3500000 cmp r0, #0 <== NOT EXECUTED
300104dc: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
300104e0: eb00065e bl 30011e60 <TOD_TICKS_PER_SECOND_method> <== NOT EXECUTED
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
300104e4: e59f3024 ldr r3, [pc, #36] ; 30010510 <_Timespec_To_ticks+0x50><== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
300104e8: e0040490 mul r4, r0, r4 <== NOT EXECUTED
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
300104ec: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 300104f0: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 300104f4: e0632283 rsb r2, r3, r3, lsl #5 <== NOT EXECUTED 300104f8: e0833102 add r3, r3, r2, lsl #2 <== NOT EXECUTED 300104fc: e1a01183 lsl r1, r3, #3 <== NOT EXECUTED 30010500: eb00149e bl 30015780 <__aeabi_uidiv> <== NOT EXECUTED
if (ticks)
30010504: e0940000 adds r0, r4, r0 <== NOT EXECUTED
return ticks;
return 1;
30010508: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
3001050c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000cddc <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000cddc: 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 );
}
}
3000cde0: e59f5040 ldr r5, [pc, #64] ; 3000ce28 <_User_extensions_Fatal+0x4c>
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000cde4: e1a08000 mov r8, r0
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
3000cde8: e5954008 ldr r4, [r5, #8]
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000cdec: e1a07002 mov r7, r2
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000cdf0: e1540005 cmp r4, r5
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000cdf4: e20160ff and r6, r1, #255 ; 0xff
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000cdf8: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
!_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 )
3000cdfc: e5943030 ldr r3, [r4, #48] ; 0x30
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
3000ce00: e1a00008 mov r0, r8
!_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 )
3000ce04: e3530000 cmp r3, #0
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
3000ce08: e1a01006 mov r1, r6 3000ce0c: e1a02007 mov r2, r7 3000ce10: 11a0e00f movne lr, pc 3000ce14: 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 ) {
3000ce18: e5944004 ldr r4, [r4, #4]
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000ce1c: e1540005 cmp r4, r5
3000ce20: 1afffff5 bne 3000cdfc <_User_extensions_Fatal+0x20>
3000ce24: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000e5cc <_User_extensions_Remove_set>:
#include <rtems/score/userext.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
3000e5cc: e92d4010 push {r4, lr}
3000e5d0: e1a04000 mov r4, r0
_Chain_Extract( &the_extension->Node );
3000e5d4: ebfff5c5 bl 3000bcf0 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
3000e5d8: e5943024 ldr r3, [r4, #36] ; 0x24
3000e5dc: e3530000 cmp r3, #0
3000e5e0: 08bd8010 popeq {r4, pc}
_Chain_Extract( &the_extension->Switch.Node );
3000e5e4: e2840008 add r0, r4, #8 <== NOT EXECUTED
}
3000e5e8: 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 );
3000e5ec: eafff5bf b 3000bcf0 <_Chain_Extract> <== NOT EXECUTED
3000ce2c <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
3000ce2c: e92d40f0 push {r4, r5, r6, r7, lr}
return false;
}
}
return true;
}
3000ce30: e59f5050 ldr r5, [pc, #80] ; 3000ce88 <_User_extensions_Thread_create+0x5c>
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
3000ce34: e1a06000 mov r6, r0
return false;
}
}
return true;
}
3000ce38: e4954004 ldr r4, [r5], #4
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
3000ce3c: e1540005 cmp r4, r5
3000ce40: 0a00000e beq 3000ce80 <_User_extensions_Thread_create+0x54>
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
status = (*the_extension->Callouts.thread_create)(
3000ce44: e59f7040 ldr r7, [pc, #64] ; 3000ce8c <_User_extensions_Thread_create+0x60>
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
3000ce48: e5943014 ldr r3, [r4, #20]
status = (*the_extension->Callouts.thread_create)(
3000ce4c: e1a01006 mov r1, r6
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
3000ce50: e3530000 cmp r3, #0
3000ce54: 0a000004 beq 3000ce6c <_User_extensions_Thread_create+0x40>
status = (*the_extension->Callouts.thread_create)(
3000ce58: e5970004 ldr r0, [r7, #4] 3000ce5c: e1a0e00f mov lr, pc 3000ce60: e12fff13 bx r3
_Thread_Executing,
the_thread
);
if ( !status )
3000ce64: e3500000 cmp r0, #0
3000ce68: 08bd80f0 popeq {r4, r5, r6, r7, pc}
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
3000ce6c: e5944000 ldr r4, [r4]
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
3000ce70: e1540005 cmp r4, r5
3000ce74: 1afffff3 bne 3000ce48 <_User_extensions_Thread_create+0x1c>
if ( !status )
return false;
}
}
return true;
3000ce78: e3a00001 mov r0, #1
3000ce7c: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000ce80: e3a00001 mov r0, #1 <== NOT EXECUTED
}
3000ce84: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000eca8 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
3000eca8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000ecac: e1a04000 mov r4, r0
3000ecb0: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ecb4: e10f0000 mrs r0, CPSR 3000ecb8: e3803080 orr r3, r0, #128 ; 0x80 3000ecbc: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
3000ecc0: e1a07004 mov r7, r4 3000ecc4: e4973004 ldr r3, [r7], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
3000ecc8: e1530007 cmp r3, r7
3000eccc: 0a00001a beq 3000ed3c <_Watchdog_Adjust+0x94>
switch ( direction ) {
3000ecd0: e3510000 cmp r1, #0 <== NOT EXECUTED 3000ecd4: 1a00001a bne 3000ed44 <_Watchdog_Adjust+0x9c> <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000ecd8: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ecdc: 0a000016 beq 3000ed3c <_Watchdog_Adjust+0x94> <== NOT EXECUTED
if ( units < _Watchdog_First( header )->delta_interval ) {
3000ece0: e5936010 ldr r6, [r3, #16] <== NOT EXECUTED 3000ece4: e1520006 cmp r2, r6 <== NOT EXECUTED 3000ece8: 21a01000 movcs r1, r0 <== NOT EXECUTED
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000ecec: 23a08001 movcs r8, #1 <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
3000ecf0: 2a000005 bcs 3000ed0c <_Watchdog_Adjust+0x64> <== NOT EXECUTED 3000ecf4: ea000019 b 3000ed60 <_Watchdog_Adjust+0xb8> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000ecf8: e0555006 subs r5, r5, r6 <== NOT EXECUTED 3000ecfc: 0a00000e beq 3000ed3c <_Watchdog_Adjust+0x94> <== NOT EXECUTED
if ( units < _Watchdog_First( header )->delta_interval ) {
3000ed00: e5936010 ldr r6, [r3, #16] <== NOT EXECUTED 3000ed04: e1560005 cmp r6, r5 <== NOT EXECUTED 3000ed08: 8a000014 bhi 3000ed60 <_Watchdog_Adjust+0xb8> <== NOT EXECUTED
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000ed0c: e5838010 str r8, [r3, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ed10: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Tickle( header );
3000ed14: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ed18: eb0000ad bl 3000efd4 <_Watchdog_Tickle> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ed1c: e10f0000 mrs r0, CPSR <== NOT EXECUTED 3000ed20: e3803080 orr r3, r0, #128 ; 0x80 <== NOT EXECUTED 3000ed24: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
}
}
_ISR_Enable( level );
}
3000ed28: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000ed2c: e1a01000 mov r1, r0 <== NOT EXECUTED
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000ed30: e1570002 cmp r7, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000ed34: e1a03002 mov r3, r2 <== NOT EXECUTED 3000ed38: 1affffee bne 3000ecf8 <_Watchdog_Adjust+0x50> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ed3c: e129f000 msr CPSR_fc, r0
}
}
_ISR_Enable( level );
}
3000ed40: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000ed44: e3510001 cmp r1, #1 <== NOT EXECUTED 3000ed48: 1afffffb bne 3000ed3c <_Watchdog_Adjust+0x94> <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
3000ed4c: e5932010 ldr r2, [r3, #16] <== NOT EXECUTED 3000ed50: e0825005 add r5, r2, r5 <== NOT EXECUTED 3000ed54: e5835010 str r5, [r3, #16] <== NOT EXECUTED 3000ed58: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
}
}
_ISR_Enable( level );
}
3000ed5c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
3000ed60: e0655006 rsb r5, r5, r6 <== NOT EXECUTED 3000ed64: e5835010 str r5, [r3, #16] <== NOT EXECUTED
break;
3000ed68: eafffff3 b 3000ed3c <_Watchdog_Adjust+0x94> <== NOT EXECUTED
3001eda8 <_Watchdog_Adjust_to_chain>:
{
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
if ( units <= 0 ) {
3001eda8: e3510000 cmp r1, #0 <== NOT EXECUTED
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
3001edac: e92d05f0 push {r4, r5, r6, r7, r8, sl} <== NOT EXECUTED
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
if ( units <= 0 ) {
3001edb0: 0a000022 beq 3001ee40 <_Watchdog_Adjust_to_chain+0x98> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001edb4: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3001edb8: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3001edbc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
return;
}
_ISR_Disable( level );
3001edc0: e1a06000 mov r6, r0 <== NOT EXECUTED 3001edc4: e4963004 ldr r3, [r6], #4 <== 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;
3001edc8: e3a0a000 mov sl, #0 <== NOT EXECUTED 3001edcc: e2828004 add r8, r2, #4 <== NOT EXECUTED
while ( 1 ) {
if ( units <= 0 ) {
break;
}
if ( _Chain_Is_empty( header ) ) {
3001edd0: e1530006 cmp r3, r6 <== NOT EXECUTED 3001edd4: 0a000018 beq 3001ee3c <_Watchdog_Adjust_to_chain+0x94> <== 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 ) {
3001edd8: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001eddc: e15c0001 cmp ip, r1 <== NOT EXECUTED 3001ede0: 8a000018 bhi 3001ee48 <_Watchdog_Adjust_to_chain+0xa0> <== 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;
3001ede4: e06c1001 rsb r1, ip, r1 <== NOT EXECUTED
first->delta_interval = 0;
3001ede8: e583a010 str sl, [r3, #16] <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
3001edec: e5935000 ldr r5, [r3] <== NOT EXECUTED
previous = the_node->previous;
3001edf0: e5934004 ldr r4, [r3, #4] <== NOT EXECUTED
next->previous = previous;
3001edf4: e5854004 str r4, [r5, #4] <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3001edf8: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
previous->next = next;
3001edfc: e5845000 str r5, [r4] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3001ee00: e5838000 str r8, [r3] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node;
3001ee04: 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;
3001ee08: e5823008 str r3, [r2, #8] <== NOT EXECUTED
old_last->next = the_node; the_node->previous = old_last;
3001ee0c: e583c004 str ip, [r3, #4] <== NOT EXECUTED
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3001ee10: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001ee14: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED 3001ee18: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001ee1c: 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 ) )
3001ee20: e1560003 cmp r6, r3 <== NOT EXECUTED 3001ee24: 0a000002 beq 3001ee34 <_Watchdog_Adjust_to_chain+0x8c> <== NOT EXECUTED
break;
first = _Watchdog_First( header );
if ( first->delta_interval != 0 )
3001ee28: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001ee2c: e35c0000 cmp ip, #0 <== NOT EXECUTED 3001ee30: 0affffed beq 3001edec <_Watchdog_Adjust_to_chain+0x44> <== NOT EXECUTED
}
_ISR_Disable( level );
while ( 1 ) {
if ( units <= 0 ) {
3001ee34: e3510000 cmp r1, #0 <== NOT EXECUTED 3001ee38: 1affffe4 bne 3001edd0 <_Watchdog_Adjust_to_chain+0x28> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001ee3c: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001ee40: e8bd05f0 pop {r4, r5, r6, r7, r8, sl} <== NOT EXECUTED
3001ee44: e12fff1e bx lr <== 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 ) {
first->delta_interval -= units;
3001ee48: e061100c rsb r1, r1, ip <== NOT EXECUTED 3001ee4c: e5831010 str r1, [r3, #16] <== NOT EXECUTED
break;
3001ee50: eafffff9 b 3001ee3c <_Watchdog_Adjust_to_chain+0x94> <== NOT EXECUTED
3000cf68 <_Watchdog_Insert>:
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
3000cf68: e59f3140 ldr r3, [pc, #320] ; 3000d0b0 <_Watchdog_Insert+0x148>
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
3000cf6c: e92d01f0 push {r4, r5, r6, r7, r8}
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
3000cf70: e5933000 ldr r3, [r3]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000cf74: e10f6000 mrs r6, CPSR 3000cf78: e3862080 orr r2, r6, #128 ; 0x80 3000cf7c: e129f002 msr CPSR_fc, r2
/*
* 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 ) {
3000cf80: e5912008 ldr r2, [r1, #8] 3000cf84: e3520000 cmp r2, #0
3000cf88: 1a000041 bne 3000d094 <_Watchdog_Insert+0x12c>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
3000cf8c: e59f8120 ldr r8, [pc, #288] ; 3000d0b4 <_Watchdog_Insert+0x14c>
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
3000cf90: e3a0c001 mov ip, #1
_Watchdog_Sync_count++;
3000cf94: e5982000 ldr r2, [r8] 3000cf98: e59f7118 ldr r7, [pc, #280] ; 3000d0b8 <_Watchdog_Insert+0x150> 3000cf9c: e2822001 add r2, r2, #1
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
3000cfa0: e581c008 str ip, [r1, #8]
_Watchdog_Sync_count++;
3000cfa4: e5882000 str r2, [r8]
restart:
delta_interval = the_watchdog->initial;
3000cfa8: e591200c ldr r2, [r1, #12]
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000cfac: e590c000 ldr ip, [r0]
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000cfb0: e3520000 cmp r2, #0
3000cfb4: 0a000023 beq 3000d048 <_Watchdog_Insert+0xe0>
3000cfb8: e59c4000 ldr r4, [ip] 3000cfbc: e3540000 cmp r4, #0
3000cfc0: 0a000020 beq 3000d048 <_Watchdog_Insert+0xe0>
break;
if ( delta_interval < after->delta_interval ) {
3000cfc4: e59c4010 ldr r4, [ip, #16] 3000cfc8: e1520004 cmp r2, r4
3000cfcc: 3a000032 bcc 3000d09c <_Watchdog_Insert+0x134>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000cfd0: e10f5000 mrs r5, CPSR 3000cfd4: e129f006 msr CPSR_fc, r6 3000cfd8: e129f005 msr CPSR_fc, r5
delta_interval -= after->delta_interval;
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
3000cfdc: e5915008 ldr r5, [r1, #8] 3000cfe0: e3550001 cmp r5, #1
3000cfe4: 1a000023 bne 3000d078 <_Watchdog_Insert+0x110>
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000cfe8: e5975000 ldr r5, [r7] 3000cfec: e1530005 cmp r3, r5
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
3000cff0: 20642002 rsbcs r2, r4, r2
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000cff4: 2a000010 bcs 3000d03c <_Watchdog_Insert+0xd4>
3000cff8: ea00002a b 3000d0a8 <_Watchdog_Insert+0x140> <== NOT EXECUTED
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000cffc: e59c4000 ldr r4, [ip] <== NOT EXECUTED 3000d000: e3540000 cmp r4, #0 <== NOT EXECUTED 3000d004: 0a00000f beq 3000d048 <_Watchdog_Insert+0xe0> <== NOT EXECUTED
break;
if ( delta_interval < after->delta_interval ) {
3000d008: e59c4010 ldr r4, [ip, #16] <== NOT EXECUTED 3000d00c: e1540002 cmp r4, r2 <== NOT EXECUTED 3000d010: 8a000021 bhi 3000d09c <_Watchdog_Insert+0x134> <== NOT EXECUTED 3000d014: e10f5000 mrs r5, CPSR <== NOT EXECUTED 3000d018: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000d01c: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
delta_interval -= after->delta_interval;
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
3000d020: e5915008 ldr r5, [r1, #8] <== NOT EXECUTED
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
3000d024: e0642002 rsb r2, r4, r2 <== NOT EXECUTED
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
3000d028: e3550001 cmp r5, #1 <== NOT EXECUTED 3000d02c: 1a000011 bne 3000d078 <_Watchdog_Insert+0x110> <== NOT EXECUTED
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000d030: e5974000 ldr r4, [r7] <== NOT EXECUTED 3000d034: e1530004 cmp r3, r4 <== NOT EXECUTED 3000d038: 3a00001a bcc 3000d0a8 <_Watchdog_Insert+0x140> <== NOT EXECUTED
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000d03c: e3520000 cmp r2, #0
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
3000d040: e59cc000 ldr ip, [ip]
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000d044: 1affffec bne 3000cffc <_Watchdog_Insert+0x94>
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
3000d048: e59c0004 ldr r0, [ip, #4]
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
3000d04c: e59f4068 ldr r4, [pc, #104] ; 3000d0bc <_Watchdog_Insert+0x154>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000d050: e590c000 ldr ip, [r0] 3000d054: e5944000 ldr r4, [r4]
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
3000d058: e3a05002 mov r5, #2 3000d05c: e5815008 str r5, [r1, #8]
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
3000d060: e5812010 str r2, [r1, #16]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000d064: e5810004 str r0, [r1, #4]
before_node = after_node->next; after_node->next = the_node;
3000d068: e5801000 str r1, [r0]
the_node->next = before_node; before_node->previous = the_node;
3000d06c: e58c1004 str r1, [ip, #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;
3000d070: e581c000 str ip, [r1]
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
3000d074: e5814014 str r4, [r1, #20]
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
3000d078: e5873000 str r3, [r7]
_Watchdog_Sync_count--;
3000d07c: e5983000 ldr r3, [r8] 3000d080: e2433001 sub r3, r3, #1 3000d084: e5883000 str r3, [r8]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d088: e129f006 msr CPSR_fc, r6
_ISR_Enable( level ); }
3000d08c: e8bd01f0 pop {r4, r5, r6, r7, r8}
3000d090: e12fff1e bx lr
3000d094: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000d098: eafffffb b 3000d08c <_Watchdog_Insert+0x124> <== NOT EXECUTED
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
break;
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
3000d09c: e0624004 rsb r4, r2, r4 <== NOT EXECUTED 3000d0a0: e58c4010 str r4, [ip, #16] <== NOT EXECUTED
break;
3000d0a4: eaffffe7 b 3000d048 <_Watchdog_Insert+0xe0> <== NOT EXECUTED
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
3000d0a8: e5873000 str r3, [r7] <== NOT EXECUTED
goto restart;
3000d0ac: eaffffbd b 3000cfa8 <_Watchdog_Insert+0x40> <== NOT EXECUTED
3000e780 <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
3000e780: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
printk(
3000e784: e250c000 subs ip, r0, #0 <== NOT EXECUTED 3000e788: e591000c ldr r0, [r1, #12] <== NOT EXECUTED
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
3000e78c: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
printk(
3000e790: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
3000e794: e88d0003 stm sp, {r0, r1} <== NOT EXECUTED
3000e798: e591e01c ldr lr, [r1, #28] <== NOT EXECUTED
3000e79c: 059fc02c ldreq ip, [pc, #44] ; 3000e7d0 <_Watchdog_Report+0x50><== NOT EXECUTED
3000e7a0: e58de008 str lr, [sp, #8] <== NOT EXECUTED
3000e7a4: e591e020 ldr lr, [r1, #32] <== NOT EXECUTED
3000e7a8: 01a0200c moveq r2, ip <== NOT EXECUTED
3000e7ac: e58de00c str lr, [sp, #12] <== NOT EXECUTED
3000e7b0: e5911024 ldr r1, [r1, #36] ; 0x24 <== NOT EXECUTED
3000e7b4: 159f2018 ldrne r2, [pc, #24] ; 3000e7d4 <_Watchdog_Report+0x54><== NOT EXECUTED
3000e7b8: e58d1010 str r1, [sp, #16] <== NOT EXECUTED
3000e7bc: e59f0014 ldr r0, [pc, #20] ; 3000e7d8 <_Watchdog_Report+0x58><== NOT EXECUTED
3000e7c0: e1a0100c mov r1, ip <== NOT EXECUTED
3000e7c4: ebffe62b bl 30008078 <printk> <== NOT EXECUTED
watch,
watch->routine,
watch->id,
watch->user_data
);
}
3000e7c8: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000e7cc: e8bd8000 pop {pc} <== NOT EXECUTED
3000e708 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
3000e708: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000e70c: e1a05000 mov r5, r0 <== NOT EXECUTED
3000e710: e1a04001 mov r4, r1 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000e714: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000e718: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000e71c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
3000e720: e59f004c ldr r0, [pc, #76] ; 3000e774 <_Watchdog_Report_chain+0x6c><== NOT EXECUTED 3000e724: e1a02004 mov r2, r4 <== NOT EXECUTED 3000e728: e1a01005 mov r1, r5 <== NOT EXECUTED 3000e72c: ebffe651 bl 30008078 <printk> <== NOT EXECUTED
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
3000e730: e4947004 ldr r7, [r4], #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 ) ) {
3000e734: e1570004 cmp r7, r4 <== NOT EXECUTED 3000e738: 0a00000a beq 3000e768 <_Watchdog_Report_chain+0x60> <== NOT EXECUTED
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
3000e73c: e1a01007 mov r1, r7 <== NOT EXECUTED 3000e740: e3a00000 mov r0, #0 <== NOT EXECUTED 3000e744: eb00000d bl 3000e780 <_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 )
3000e748: 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 ) ;
3000e74c: e1570004 cmp r7, r4 <== NOT EXECUTED 3000e750: 1afffff9 bne 3000e73c <_Watchdog_Report_chain+0x34> <== NOT EXECUTED
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
3000e754: e59f001c ldr r0, [pc, #28] ; 3000e778 <_Watchdog_Report_chain+0x70><== NOT EXECUTED 3000e758: e1a01005 mov r1, r5 <== NOT EXECUTED 3000e75c: ebffe645 bl 30008078 <printk> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000e760: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
3000e764: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
3000e768: e59f000c ldr r0, [pc, #12] ; 3000e77c <_Watchdog_Report_chain+0x74><== NOT EXECUTED 3000e76c: ebffe641 bl 30008078 <printk> <== NOT EXECUTED 3000e770: eafffffa b 3000e760 <_Watchdog_Report_chain+0x58> <== NOT EXECUTED
3000d1d0 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
3000d1d0: e92d40f0 push {r4, r5, r6, r7, lr}
3000d1d4: e1a06000 mov r6, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000d1d8: e10f7000 mrs r7, CPSR 3000d1dc: e3873080 orr r3, r7, #128 ; 0x80 3000d1e0: e129f003 msr CPSR_fc, r3
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000d1e4: e1a05000 mov r5, r0 3000d1e8: e4953004 ldr r3, [r5], #4
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000d1ec: e1530005 cmp r3, r5
3000d1f0: 0a000007 beq 3000d214 <_Watchdog_Tickle+0x44>
* 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) {
3000d1f4: e5931010 ldr r1, [r3, #16]
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000d1f8: e1a04003 mov r4, r3 3000d1fc: e3510000 cmp r1, #0
3000d200: 0a000015 beq 3000d25c <_Watchdog_Tickle+0x8c>
the_watchdog->delta_interval--;
3000d204: e2411001 sub r1, r1, #1
if ( the_watchdog->delta_interval != 0 )
3000d208: e3510000 cmp r1, #0
* 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) {
the_watchdog->delta_interval--;
3000d20c: e5831010 str r1, [r3, #16]
if ( the_watchdog->delta_interval != 0 )
3000d210: 0a000011 beq 3000d25c <_Watchdog_Tickle+0x8c>
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
3000d214: e1a02007 mov r2, r7
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d218: e129f002 msr CPSR_fc, r2
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000d21c: e8bd80f0 pop {r4, r5, r6, r7, pc}
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
3000d220: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED 3000d224: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000d228: e1a0e00f mov lr, pc <== NOT EXECUTED 3000d22c: e594f01c ldr pc, [r4, #28] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000d230: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000d234: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000d238: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000d23c: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000d240: e1a07002 mov r7, r2 <== NOT EXECUTED
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
3000d244: e1530005 cmp r3, r5 <== NOT EXECUTED 3000d248: e1a04003 mov r4, r3 <== NOT EXECUTED 3000d24c: 0afffff1 beq 3000d218 <_Watchdog_Tickle+0x48> <== NOT EXECUTED
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
3000d250: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 3000d254: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d258: 1affffee bne 3000d218 <_Watchdog_Tickle+0x48> <== NOT EXECUTED
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
3000d25c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d260: ebffffaf bl 3000d124 <_Watchdog_Remove> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d264: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
switch( watchdog_state ) {
3000d268: e3500002 cmp r0, #2 <== NOT EXECUTED 3000d26c: 1affffef bne 3000d230 <_Watchdog_Tickle+0x60> <== NOT EXECUTED 3000d270: eaffffea b 3000d220 <_Watchdog_Tickle+0x50> <== NOT EXECUTED
3000d2fc <_Workspace_Allocate_or_fatal_error>:
3000d2fc: e3a02000 mov r2, #0
* _Workspace_Allocate_or_fatal_error
*/
void *_Workspace_Allocate_or_fatal_error(
size_t size
)
{
3000d300: e1a01000 mov r1, r0
3000d304: e52de004 push {lr} ; (str lr, [sp, #-4]!)
3000d308: e59f0018 ldr r0, [pc, #24] ; 3000d328 <_Workspace_Allocate_or_fatal_error+0x2c>
3000d30c: e1a03002 mov r3, r2
3000d310: eb000ab2 bl 3000fde0 <_Heap_Allocate_aligned_with_boundary>
__builtin_return_address( 1 ),
memory
);
#endif
if ( memory == NULL )
3000d314: e3500000 cmp r0, #0
3000d318: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
_Internal_error_Occurred(
3000d31c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000d320: e3a02003 mov r2, #3 <== NOT EXECUTED 3000d324: ebfff6d1 bl 3000ae70 <_Internal_error_Occurred> <== NOT EXECUTED
3000d274 <_Workspace_Handler_initialization>:
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
3000d274: e59f3050 ldr r3, [pc, #80] ; 3000d2cc <_Workspace_Handler_initialization+0x58>
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
3000d278: e92d4030 push {r4, r5, lr}
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
uintptr_t size = Configuration.work_space_size;
if ( Configuration.do_zero_of_workspace )
3000d27c: e5d32028 ldrb r2, [r3, #40] ; 0x28
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
3000d280: e5935000 ldr r5, [r3]
uintptr_t size = Configuration.work_space_size;
if ( Configuration.do_zero_of_workspace )
3000d284: e3520000 cmp r2, #0
*/
void _Workspace_Handler_initialization(void)
{
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
uintptr_t size = Configuration.work_space_size;
3000d288: e5934004 ldr r4, [r3, #4]
if ( Configuration.do_zero_of_workspace )
3000d28c: 1a000009 bne 3000d2b8 <_Workspace_Handler_initialization+0x44>
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
3000d290: e59f0038 ldr r0, [pc, #56] ; 3000d2d0 <_Workspace_Handler_initialization+0x5c> 3000d294: e1a01005 mov r1, r5 3000d298: e1a02004 mov r2, r4 3000d29c: e3a03008 mov r3, #8 3000d2a0: ebfff657 bl 3000ac04 <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
3000d2a4: e3500000 cmp r0, #0
3000d2a8: 18bd8030 popne {r4, r5, pc}
_Internal_error_Occurred(
3000d2ac: e3a01001 mov r1, #1 <== NOT EXECUTED 3000d2b0: e3a02002 mov r2, #2 <== NOT EXECUTED 3000d2b4: ebfff6ed bl 3000ae70 <_Internal_error_Occurred> <== NOT EXECUTED
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
uintptr_t size = Configuration.work_space_size;
if ( Configuration.do_zero_of_workspace )
memset( starting_address, 0, size );
3000d2b8: e1a00005 mov r0, r5 3000d2bc: e3a01000 mov r1, #0 3000d2c0: e1a02004 mov r2, r4 3000d2c4: eb0015cf bl 30012a08 <memset> 3000d2c8: eafffff0 b 3000d290 <_Workspace_Handler_initialization+0x1c>
300097d8 <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300097d8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300097dc: e252e000 subs lr, r2, #0 <== NOT EXECUTED
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300097e0: e1a0c001 mov ip, r1 <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300097e4: 059f102c ldreq r1, [pc, #44] ; 30009818 <__assert_func+0x40><== NOT EXECUTED 300097e8: 159f102c ldrne r1, [pc, #44] ; 3000981c <__assert_func+0x44><== NOT EXECUTED
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300097ec: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300097f0: 01a0e001 moveq lr, r1 <== NOT EXECUTED
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300097f4: e1a02000 mov r2, r0 <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300097f8: e58d1000 str r1, [sp] <== NOT EXECUTED 300097fc: e59f001c ldr r0, [pc, #28] ; 30009820 <__assert_func+0x48> <== NOT EXECUTED 30009800: e1a01003 mov r1, r3 <== NOT EXECUTED 30009804: e1a0300c mov r3, ip <== NOT EXECUTED 30009808: e58de004 str lr, [sp, #4] <== NOT EXECUTED 3000980c: eb000451 bl 3000a958 <printk> <== NOT EXECUTED
file,
line,
(func) ? ", function: " : "",
(func) ? func : ""
);
rtems_fatal_error_occurred(0);
30009810: e3a00000 mov r0, #0 <== NOT EXECUTED 30009814: eb00113e bl 3000dd14 <rtems_fatal_error_occurred> <== NOT EXECUTED
3001607c <__env_lock>:
3001607c: e12fff1e bx lr <== NOT EXECUTED
30016080 <__env_unlock>:
30016080: e12fff1e bx lr <== NOT EXECUTED
30006ba0 <__getpid>:
#include <unistd.h>
pid_t __getpid(void)
{
return getpid();
30006ba0: eaffffff b 30006ba4 <getpid> <== NOT EXECUTED
30007ff0 <_chown_helper>:
const char *path,
uid_t owner,
gid_t group,
int follow_link
)
{
30007ff0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30007ff4: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
30007ff8: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30007ffc: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
30008000: e1a08003 mov r8, r3 <== NOT EXECUTED
30008004: e1a05822 lsr r5, r2, #16 <== NOT EXECUTED
30008008: e1a07000 mov r7, r0 <== NOT EXECUTED
3000800c: 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 ) )
30008010: eb00382d bl 300160cc <strlen> <== NOT EXECUTED 30008014: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30008018: e1a01000 mov r1, r0 <== NOT EXECUTED 3000801c: e3a02000 mov r2, #0 <== NOT EXECUTED 30008020: e1a00007 mov r0, r7 <== NOT EXECUTED 30008024: e1a03004 mov r3, r4 <== NOT EXECUTED 30008028: e58d8000 str r8, [sp] <== NOT EXECUTED 3000802c: eb000030 bl 300080f4 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 30008030: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30008034: 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 ) )
30008038: 1a000008 bne 30008060 <_chown_helper+0x70> <== NOT EXECUTED
return -1;
result = (*loc.ops->chown_h)( &loc, owner, group );
3000803c: e1a02005 mov r2, r5 <== NOT EXECUTED 30008040: e1a00004 mov r0, r4 <== NOT EXECUTED 30008044: e1a01006 mov r1, r6 <== NOT EXECUTED 30008048: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000804c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008050: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED 30008054: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30008058: e1a00004 mov r0, r4 <== NOT EXECUTED 3000805c: eb00005e bl 300081dc <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
30008060: e1a00005 mov r0, r5 <== NOT EXECUTED
30008064: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30008068: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3001908c <_execve>:
int _execve(
const char *path __attribute__((unused)),
char *const argv[] __attribute__((unused)),
char *const envp[] __attribute__((unused))
)
{
3001908c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30019090: ebffe650 bl 300129d8 <__errno> <== NOT EXECUTED 30019094: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30019098: e5803000 str r3, [r0] <== NOT EXECUTED
}
3001909c: e3e00000 mvn r0, #0 <== NOT EXECUTED
300190a0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007010 <_fcntl_r>:
int fd,
int cmd,
int arg
)
{
return fcntl( fd, cmd, arg );
30007010: e1a00001 mov r0, r1 <== NOT EXECUTED 30007014: e1a01002 mov r1, r2 <== NOT EXECUTED 30007018: e1a02003 mov r2, r3 <== NOT EXECUTED 3000701c: eaffff81 b 30006e28 <fcntl> <== NOT EXECUTED
300269e0 <_getpid_r>:
pid_t _getpid_r(
struct _reent *ptr __attribute__((unused))
)
{
return getpid();
}
300269e0: e3a00001 mov r0, #1 <== NOT EXECUTED 300269e4: e12fff1e bx lr <== NOT EXECUTED
300065b0 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
300065b0: eaffffe1 b 3000653c <gettimeofday> <== NOT EXECUTED
300065a4 <_gettimeofday_r>:
struct _reent *ignored_reentrancy_stuff __attribute__((unused)),
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
300065a4: e1a00001 mov r0, r1 <== NOT EXECUTED 300065a8: e1a01002 mov r1, r2 <== NOT EXECUTED 300065ac: eaffffe2 b 3000653c <gettimeofday> <== NOT EXECUTED
30026bf8 <_kill_r>:
struct _reent *ptr,
pid_t pid,
int sig
)
{
return killinfo( pid, sig, NULL );
30026bf8: e1a00001 mov r0, r1 <== NOT EXECUTED 30026bfc: e1a01002 mov r1, r2 <== NOT EXECUTED 30026c00: e3a02000 mov r2, #0 <== NOT EXECUTED 30026c04: ea00002c b 30026cbc <killinfo> <== NOT EXECUTED
30009c7c <_link_r>:
struct _reent *ptr __attribute__((unused)),
const char *existing,
const char *new
)
{
return link( existing, new );
30009c7c: e1a00001 mov r0, r1 <== NOT EXECUTED 30009c80: e1a01002 mov r1, r2 <== NOT EXECUTED 30009c84: eaffffbe b 30009b84 <link> <== NOT EXECUTED
30017850 <_lseek_r>:
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
30017850: e1a00001 mov r0, r1 <== NOT EXECUTED 30017854: e1a01002 mov r1, r2 <== NOT EXECUTED 30017858: e1a02003 mov r2, r3 <== NOT EXECUTED 3001785c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30017860: eaffffb7 b 30017744 <lseek> <== NOT EXECUTED
300088b4 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
300088b4: e1a00001 mov r0, r1 <== NOT EXECUTED 300088b8: e1a01002 mov r1, r2 <== NOT EXECUTED 300088bc: eaffffd9 b 30008828 <lstat> <== NOT EXECUTED
300179a4 <_read_r>:
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
300179a4: e1a00001 mov r0, r1 <== NOT EXECUTED 300179a8: e1a01002 mov r1, r2 <== NOT EXECUTED 300179ac: e1a02003 mov r2, r3 <== NOT EXECUTED 300179b0: eaffffce b 300178f0 <read> <== NOT EXECUTED
300179b4 <_realloc_r>:
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
return realloc( ptr, size );
300179b4: e1a00001 mov r0, r1 <== NOT EXECUTED 300179b8: e1a01002 mov r1, r2 <== NOT EXECUTED 300179bc: ea000011 b 30017a08 <realloc> <== NOT EXECUTED
3000ab1c <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
3000ab1c: 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 );
3000ab20: e1a00001 mov r0, r1 <== NOT EXECUTED
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
3000ab24: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED 3000ab28: e1a05001 mov r5, r1 <== NOT EXECUTED 3000ab2c: 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 );
3000ab30: ebfffa29 bl 300093dc <rtems_filesystem_dirname> <== NOT EXECUTED
if ( old_parent_pathlen == 0 )
3000ab34: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000ab38: 1a000059 bne 3000aca4 <_rename_r+0x188> <== NOT EXECUTED
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
3000ab3c: e28d4018 add r4, sp, #24 <== NOT EXECUTED 3000ab40: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ab44: e28d1044 add r1, sp, #68 ; 0x44 <== NOT EXECUTED 3000ab48: e1a02004 mov r2, r4 <== NOT EXECUTED 3000ab4c: eb0000e8 bl 3000aef4 <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;
3000ab50: e1a08007 mov r8, r7 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
3000ab54: e28dc02c add ip, sp, #44 ; 0x2c <== NOT EXECUTED
3000ab58: e1a0e004 mov lr, r4 <== NOT EXECUTED
3000ab5c: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
3000ab60: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000ab64: e59e3000 ldr r3, [lr] <== NOT EXECUTED
name = old + old_parent_pathlen;
3000ab68: e0855007 add r5, r5, r7 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
3000ab6c: e58c3000 str r3, [ip] <== NOT EXECUTED
name = old + old_parent_pathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000ab70: e1a00005 mov r0, r5 <== 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;
3000ab74: e58d5040 str r5, [sp, #64] ; 0x40 <== NOT EXECUTED
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000ab78: eb00399d bl 300191f4 <strlen> <== NOT EXECUTED 3000ab7c: e1a01000 mov r1, r0 <== NOT EXECUTED 3000ab80: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ab84: ebfffa23 bl 30009418 <rtems_filesystem_prefix_separators> <== NOT EXECUTED 3000ab88: e0855000 add r5, r5, r0 <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
3000ab8c: e1a00005 mov r0, r5 <== 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 ) );
3000ab90: e58d5040 str r5, [sp, #64] ; 0x40 <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
3000ab94: eb003996 bl 300191f4 <strlen> <== NOT EXECUTED 3000ab98: e28d702c add r7, sp, #44 ; 0x2c <== NOT EXECUTED 3000ab9c: e1a01000 mov r1, r0 <== NOT EXECUTED 3000aba0: e3a02000 mov r2, #0 <== NOT EXECUTED 3000aba4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000aba8: e1a03007 mov r3, r7 <== NOT EXECUTED 3000abac: e58d2000 str r2, [sp] <== NOT EXECUTED 3000abb0: ebfff9d7 bl 30009314 <rtems_filesystem_evaluate_relative_path><== NOT EXECUTED
0, &old_loc, false );
if ( result != 0 ) {
3000abb4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000abb8: 1a000031 bne 3000ac84 <_rename_r+0x168> <== NOT EXECUTED
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
3000abbc: e28d5004 add r5, sp, #4 <== NOT EXECUTED 3000abc0: e1a00006 mov r0, r6 <== NOT EXECUTED 3000abc4: e1a02005 mov r2, r5 <== NOT EXECUTED 3000abc8: e28d1044 add r1, sp, #68 ; 0x44 <== NOT EXECUTED 3000abcc: eb0000c8 bl 3000aef4 <rtems_filesystem_get_start_loc> <== NOT EXECUTED
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
3000abd0: e59d0044 ldr r0, [sp, #68] ; 0x44 <== NOT EXECUTED 3000abd4: e1a01005 mov r1, r5 <== NOT EXECUTED 3000abd8: e0860000 add r0, r6, r0 <== NOT EXECUTED 3000abdc: e28d2040 add r2, sp, #64 ; 0x40 <== NOT EXECUTED 3000abe0: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000abe4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000abe8: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
if ( result != 0 ) {
3000abec: e3500000 cmp r0, #0 <== NOT EXECUTED 3000abf0: 1a000037 bne 3000acd4 <_rename_r+0x1b8> <== 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 ) {
3000abf4: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 3000abf8: e59d2028 ldr r2, [sp, #40] ; 0x28 <== NOT EXECUTED 3000abfc: e1520003 cmp r2, r3 <== NOT EXECUTED 3000ac00: 1a000013 bne 3000ac54 <_rename_r+0x138> <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
3000ac04: e1a01007 mov r1, r7 <== NOT EXECUTED 3000ac08: e1a02005 mov r2, r5 <== NOT EXECUTED 3000ac0c: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED 3000ac10: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED 3000ac14: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac18: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ac1c: e59cf040 ldr pc, [ip, #64] ; 0x40 <== NOT EXECUTED 3000ac20: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &new_parent_loc );
3000ac24: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ac28: ebfffa8d bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_old_parentloc )
3000ac2c: e3580000 cmp r8, #0 <== NOT EXECUTED 3000ac30: 1a000004 bne 3000ac48 <_rename_r+0x12c> <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
3000ac34: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ac38: ebfffa89 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
3000ac3c: e1a00006 mov r0, r6 <== NOT EXECUTED
3000ac40: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
3000ac44: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
rtems_filesystem_freenode( &new_parent_loc );
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
3000ac48: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac4c: ebfffa84 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED 3000ac50: eafffff7 b 3000ac34 <_rename_r+0x118> <== 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 ) {
rtems_filesystem_freenode( &new_parent_loc );
3000ac54: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ac58: ebfffa81 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_old_parentloc )
3000ac5c: e3580000 cmp r8, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
3000ac60: 11a00004 movne r0, r4 <== NOT EXECUTED 3000ac64: 1bfffa7e blne 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &old_loc );
3000ac68: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ac6c: ebfffa7c bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EXDEV );
3000ac70: eb002c5c bl 30015de8 <__errno> <== NOT EXECUTED 3000ac74: e3a03012 mov r3, #18 <== NOT EXECUTED 3000ac78: e5803000 str r3, [r0] <== NOT EXECUTED 3000ac7c: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000ac80: eaffffed b 3000ac3c <_rename_r+0x120> <== 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 )
3000ac84: e3580000 cmp r8, #0 <== NOT EXECUTED 3000ac88: 1a000001 bne 3000ac94 <_rename_r+0x178> <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
return -1;
3000ac8c: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000ac90: eaffffe9 b 3000ac3c <_rename_r+0x120> <== 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 );
3000ac94: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac98: ebfffa71 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
return -1;
3000ac9c: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000aca0: eaffffe5 b 3000ac3c <_rename_r+0x120> <== 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,
3000aca4: e3a03000 mov r3, #0 <== NOT EXECUTED 3000aca8: e28d4018 add r4, sp, #24 <== NOT EXECUTED 3000acac: e58d3000 str r3, [sp] <== NOT EXECUTED 3000acb0: e3a02002 mov r2, #2 <== NOT EXECUTED 3000acb4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000acb8: e1a01007 mov r1, r7 <== NOT EXECUTED 3000acbc: e1a03004 mov r3, r4 <== NOT EXECUTED 3000acc0: ebfff9af bl 30009384 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
3000acc4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000acc8: 1affffef bne 3000ac8c <_rename_r+0x170> <== NOT EXECUTED
return -1;
free_old_parentloc = true;
3000accc: e3a08001 mov r8, #1 <== NOT EXECUTED 3000acd0: eaffff9f b 3000ab54 <_rename_r+0x38> <== NOT EXECUTED
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
if ( result != 0 ) {
rtems_filesystem_freenode( &new_parent_loc );
3000acd4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000acd8: ebfffa61 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_old_parentloc )
3000acdc: e3580000 cmp r8, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
3000ace0: 11a00004 movne r0, r4 <== NOT EXECUTED 3000ace4: 1bfffa5e blne 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &old_loc );
3000ace8: e1a00007 mov r0, r7 <== NOT EXECUTED 3000acec: ebfffa5c bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
return -1;
3000acf0: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000acf4: eaffffd0 b 3000ac3c <_rename_r+0x120> <== NOT EXECUTED
300074ac <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
300074ac: e1a00001 mov r0, r1 <== NOT EXECUTED 300074b0: e1a01002 mov r1, r2 <== NOT EXECUTED 300074b4: eaffffd8 b 3000741c <stat> <== NOT EXECUTED
300093f8 <_times>:
#endif
clock_t _times(
struct tms *ptms
)
{
300093f8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_interval ticks;
if ( !ptms )
300093fc: e2504000 subs r4, r0, #0 <== NOT EXECUTED
#endif
clock_t _times(
struct tms *ptms
)
{
30009400: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
rtems_interval ticks;
if ( !ptms )
30009404: 0a000025 beq 300094a0 <_times+0xa8> <== NOT EXECUTED
/*
* This call does not depend on TOD being initialized and can't fail.
*/
ticks = rtems_clock_get_ticks_since_boot();
30009408: eb000114 bl 30009860 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
3000940c: e59f30a0 ldr r3, [pc, #160] ; 300094b4 <_times+0xbc> <== NOT EXECUTED 30009410: e59f20a0 ldr r2, [pc, #160] ; 300094b8 <_times+0xc0> <== NOT EXECUTED 30009414: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
/*
* This call does not depend on TOD being initialized and can't fail.
*/
ticks = rtems_clock_get_ticks_since_boot();
30009418: e1a05000 mov r5, r0 <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
3000941c: e0631283 rsb r1, r3, r3, lsl #5 <== NOT EXECUTED 30009420: e0831101 add r1, r3, r1, lsl #2 <== NOT EXECUTED 30009424: e1a01181 lsl r1, r1, #3 <== NOT EXECUTED 30009428: e1a004a1 lsr r0, r1, #9 <== NOT EXECUTED 3000942c: e082c290 umull ip, r2, r0, r2 <== NOT EXECUTED 30009430: e1a023a2 lsr r2, r2, #7 <== NOT EXECUTED 30009434: e062c282 rsb ip, r2, r2, lsl #5 <== NOT EXECUTED 30009438: e59fe07c ldr lr, [pc, #124] ; 300094bc <_times+0xc4> <== NOT EXECUTED 3000943c: e06cc30c rsb ip, ip, ip, lsl #6 <== NOT EXECUTED 30009440: e08e0e93 umull r0, lr, r3, lr <== NOT EXECUTED 30009444: e082c18c add ip, r2, ip, lsl #3 <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
30009448: e59f3070 ldr r3, [pc, #112] ; 300094c0 <_times+0xc8> <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
3000944c: e08cc10c add ip, ip, ip, lsl #2 <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
30009450: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
30009454: e08cc10c add ip, ip, ip, lsl #2 <== NOT EXECUTED 30009458: e08cc10c add ip, ip, ip, lsl #2 <== NOT EXECUTED 3000945c: e041c48c sub ip, r1, ip, lsl #9 <== NOT EXECUTED 30009460: e1a0e92e lsr lr, lr, #18 <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
30009464: e2800084 add r0, r0, #132 ; 0x84 <== NOT EXECUTED 30009468: e28d200c add r2, sp, #12 <== NOT EXECUTED 3000946c: e28d3008 add r3, sp, #8 <== NOT EXECUTED 30009470: e1a0100d mov r1, sp <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
30009474: e58de000 str lr, [sp] <== NOT EXECUTED 30009478: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
3000947c: eb000e9f bl 3000cf00 <_Timespec_Divide> <== NOT EXECUTED
&_Thread_Executing->cpu_time_used,
&per_tick,
&ticks,
&fractional_ticks
);
ptms->tms_utime = ticks;
30009480: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
}
#else
ptms->tms_utime = _Thread_Executing->cpu_time_used;
#endif
ptms->tms_stime = ticks;
ptms->tms_cutime = 0;
30009484: e3a03000 mov r3, #0 <== NOT EXECUTED
&_Thread_Executing->cpu_time_used,
&per_tick,
&ticks,
&fractional_ticks
);
ptms->tms_utime = ticks;
30009488: e8840024 stm r4, {r2, r5} <== NOT EXECUTED
}
#else
ptms->tms_utime = _Thread_Executing->cpu_time_used;
#endif
ptms->tms_stime = ticks;
ptms->tms_cutime = 0;
3000948c: e5843008 str r3, [r4, #8] <== NOT EXECUTED
ptms->tms_cstime = 0;
30009490: e584300c str r3, [r4, #12] <== NOT EXECUTED
return ticks;
30009494: e1a00005 mov r0, r5 <== NOT EXECUTED
}
30009498: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000949c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
)
{
rtems_interval ticks;
if ( !ptms )
rtems_set_errno_and_return_minus_one( EFAULT );
300094a0: eb0023c1 bl 300123ac <__errno> <== NOT EXECUTED 300094a4: e3a0300e mov r3, #14 <== NOT EXECUTED 300094a8: e5803000 str r3, [r0] <== NOT EXECUTED 300094ac: e3e00000 mvn r0, #0 <== NOT EXECUTED 300094b0: eafffff8 b 30009498 <_times+0xa0> <== NOT EXECUTED
300094c8 <_times_r>:
clock_t _times_r(
struct _reent *ptr __attribute__((unused)),
struct tms *ptms
)
{
return _times( ptms );
300094c8: e1a00001 mov r0, r1 <== NOT EXECUTED 300094cc: eaffffc9 b 300093f8 <_times> <== NOT EXECUTED
3000a658 <_unlink_r>:
int _unlink_r(
struct _reent *ptr __attribute__((unused)),
const char *path
)
{
return unlink( path );
3000a658: e1a00001 mov r0, r1 <== NOT EXECUTED 3000a65c: eaffffa7 b 3000a500 <unlink> <== NOT EXECUTED
30008694 <access>:
int access(
const char *path,
int amode
)
{
30008694: e92d4010 push {r4, lr} <== NOT EXECUTED
30008698: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
3000869c: e1a04001 mov r4, r1 <== NOT EXECUTED
struct stat statbuf;
if ( stat(path, &statbuf) )
300086a0: e1a0100d mov r1, sp <== NOT EXECUTED 300086a4: eb000607 bl 30009ec8 <stat> <== NOT EXECUTED 300086a8: e3500000 cmp r0, #0 <== NOT EXECUTED 300086ac: 1a00000a bne 300086dc <access+0x48> <== NOT EXECUTED
return -1;
if ( amode & R_OK ) {
300086b0: e3140004 tst r4, #4 <== NOT EXECUTED 300086b4: 1a00000a bne 300086e4 <access+0x50> <== NOT EXECUTED
if (!( statbuf.st_mode & S_IREAD ))
return -1;
}
if ( amode & W_OK ) {
300086b8: e3140002 tst r4, #2 <== NOT EXECUTED 300086bc: 1a000003 bne 300086d0 <access+0x3c> <== NOT EXECUTED
if ( !( statbuf.st_mode & S_IWRITE ) )
return -1;
}
if ( amode & X_OK ) {
300086c0: e2140001 ands r0, r4, #1 <== NOT EXECUTED 300086c4: 1a00000b bne 300086f8 <access+0x64> <== NOT EXECUTED
if ( !( statbuf.st_mode & S_IEXEC ) )
return -1;
}
return 0;
}
300086c8: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
300086cc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if (!( statbuf.st_mode & S_IREAD ))
return -1;
}
if ( amode & W_OK ) {
if ( !( statbuf.st_mode & S_IWRITE ) )
300086d0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 300086d4: e3130080 tst r3, #128 ; 0x80 <== NOT EXECUTED 300086d8: 1afffff8 bne 300086c0 <access+0x2c> <== NOT EXECUTED
return -1;
300086dc: e3e00000 mvn r0, #0 <== NOT EXECUTED 300086e0: eafffff8 b 300086c8 <access+0x34> <== NOT EXECUTED
if ( stat(path, &statbuf) )
return -1;
if ( amode & R_OK ) {
if (!( statbuf.st_mode & S_IREAD ))
300086e4: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 300086e8: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300086ec: 1afffff1 bne 300086b8 <access+0x24> <== NOT EXECUTED
return -1;
}
if ( amode & W_OK ) {
if ( !( statbuf.st_mode & S_IWRITE ) )
return -1;
300086f0: e3e00000 mvn r0, #0 <== NOT EXECUTED 300086f4: eafffff3 b 300086c8 <access+0x34> <== NOT EXECUTED
}
if ( amode & X_OK ) {
if ( !( statbuf.st_mode & S_IEXEC ) )
300086f8: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 300086fc: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED
return -1;
}
return 0;
30008700: 03e00000 mvneq r0, #0 <== NOT EXECUTED 30008704: 13a00000 movne r0, #0 <== NOT EXECUTED 30008708: eaffffee b 300086c8 <access+0x34> <== NOT EXECUTED
30009cfc <adjtime>:
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
30009cfc: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
long adjustment;
/*
* Simple validations
*/
if ( !delta )
30009d00: e2504000 subs r4, r0, #0 <== NOT EXECUTED
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
30009d04: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30009d08: e1a05001 mov r5, r1 <== NOT EXECUTED
long adjustment;
/*
* Simple validations
*/
if ( !delta )
30009d0c: 0a000042 beq 30009e1c <adjtime+0x120> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
30009d10: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 30009d14: e59f3114 ldr r3, [pc, #276] ; 30009e30 <adjtime+0x134> <== NOT EXECUTED 30009d18: e1520003 cmp r2, r3 <== NOT EXECUTED 30009d1c: 8a00003e bhi 30009e1c <adjtime+0x120> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
30009d20: e3510000 cmp r1, #0 <== NOT EXECUTED
olddelta->tv_sec = 0;
30009d24: 13a03000 movne r3, #0 <== NOT EXECUTED 30009d28: 15813000 strne r3, [r1] <== NOT EXECUTED
olddelta->tv_usec = 0;
30009d2c: 15813004 strne r3, [r1, #4] <== NOT EXECUTED
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
30009d30: e5943000 ldr r3, [r4] <== NOT EXECUTED
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
olddelta->tv_sec = 0;
olddelta->tv_usec = 0;
30009d34: 15942004 ldrne r2, [r4, #4] <== NOT EXECUTED
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
30009d38: e0631283 rsb r1, r3, r3, lsl #5 <== NOT EXECUTED 30009d3c: e0611301 rsb r1, r1, r1, lsl #6 <== NOT EXECUTED 30009d40: e0833181 add r3, r3, r1, lsl #3 <== NOT EXECUTED
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
30009d44: e59f10e8 ldr r1, [pc, #232] ; 30009e34 <adjtime+0x138> <== NOT EXECUTED
olddelta->tv_usec = 0;
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
adjustment += delta->tv_usec;
30009d48: e0822303 add r2, r2, r3, lsl #6 <== NOT EXECUTED
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
30009d4c: e591000c ldr r0, [r1, #12] <== NOT EXECUTED 30009d50: e1520000 cmp r2, r0 <== NOT EXECUTED
return 0;
30009d54: 33a00000 movcc r0, #0 <== NOT EXECUTED
/* convert delta to microseconds */
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() )
30009d58: 2a000001 bcs 30009d64 <adjtime+0x68> <== NOT EXECUTED
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
}
30009d5c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30009d60: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009d64: e59f30cc ldr r3, [pc, #204] ; 30009e38 <adjtime+0x13c> <== NOT EXECUTED 30009d68: e5932000 ldr r2, [r3] <== NOT EXECUTED 30009d6c: e2822001 add r2, r2, #1 <== NOT EXECUTED 30009d70: e5832000 str r2, [r3] <== NOT EXECUTED
* This prevents context switches while we are adjusting the TOD
*/
_Thread_Disable_dispatch();
_TOD_Get( &ts );
30009d74: e1a0000d mov r0, sp <== NOT EXECUTED 30009d78: eb0005f1 bl 3000b544 <_TOD_Get> <== NOT EXECUTED
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
30009d7c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30009d80: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 30009d84: e0631283 rsb r1, r3, r3, lsl #5 <== NOT EXECUTED 30009d88: e0833101 add r3, r3, r1, lsl #2 <== NOT EXECUTED 30009d8c: e0803183 add r3, r0, r3, lsl #3 <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
30009d90: e5942000 ldr r2, [r4] <== NOT EXECUTED 30009d94: e59d0000 ldr r0, [sp] <== NOT EXECUTED
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
30009d98: e59f109c ldr r1, [pc, #156] ; 30009e3c <adjtime+0x140> <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Get( &ts );
ts.tv_sec += delta->tv_sec;
30009d9c: e0802002 add r2, r0, r2 <== NOT EXECUTED
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
30009da0: e1530001 cmp r3, r1 <== NOT EXECUTED
* This prevents context switches while we are adjusting the TOD
*/
_Thread_Disable_dispatch();
_TOD_Get( &ts );
30009da4: e1a0600d mov r6, sp <== NOT EXECUTED
ts.tv_sec += delta->tv_sec;
30009da8: e88d000c stm sp, {r2, r3} <== NOT EXECUTED
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
30009dac: 9a000006 bls 30009dcc <adjtime+0xd0> <== NOT EXECUTED
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
30009db0: e2833331 add r3, r3, #-1006632960 ; 0xc4000000 <== NOT EXECUTED 30009db4: e2833865 add r3, r3, #6619136 ; 0x650000 <== NOT EXECUTED 30009db8: e2833c36 add r3, r3, #13824 ; 0x3600 <== 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 ) {
30009dbc: e1530001 cmp r3, r1 <== NOT EXECUTED
* At one point there was a static variable named adjustment
* used by this implementation. I don't see any reason for it
* to be here based upon the GNU/Linux documentation.
*/
int adjtime(
30009dc0: e2822001 add r2, r2, #1 <== 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 ) {
30009dc4: 8afffff9 bhi 30009db0 <adjtime+0xb4> <== NOT EXECUTED
30009dc8: e88d000c stm sp, {r2, r3} <== 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) ) {
30009dcc: e59f106c ldr r1, [pc, #108] ; 30009e40 <adjtime+0x144> <== NOT EXECUTED 30009dd0: e1530001 cmp r3, r1 <== NOT EXECUTED 30009dd4: 8a000007 bhi 30009df8 <adjtime+0xfc> <== NOT EXECUTED 30009dd8: e59d2000 ldr r2, [sp] <== NOT EXECUTED
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
30009ddc: e28335ee add r3, r3, #998244352 ; 0x3b800000 <== NOT EXECUTED 30009de0: e283396b add r3, r3, #1753088 ; 0x1ac000 <== NOT EXECUTED 30009de4: 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) ) {
30009de8: e1530001 cmp r3, r1 <== NOT EXECUTED
* At one point there was a static variable named adjustment
* used by this implementation. I don't see any reason for it
* to be here based upon the GNU/Linux documentation.
*/
int adjtime(
30009dec: 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) ) {
30009df0: 9afffff9 bls 30009ddc <adjtime+0xe0> <== NOT EXECUTED
30009df4: e88d000c stm sp, {r2, r3} <== NOT EXECUTED
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec--;
}
_TOD_Set( &ts );
30009df8: e1a0000d mov r0, sp <== NOT EXECUTED 30009dfc: eb0005f8 bl 3000b5e4 <_TOD_Set> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009e00: eb000bbb bl 3000ccf4 <_Thread_Enable_dispatch> <== NOT EXECUTED
/* set the user's output */
if ( olddelta )
30009e04: e3550000 cmp r5, #0 <== NOT EXECUTED
*olddelta = *delta;
return 0;
30009e08: 01a00005 moveq r0, r5 <== NOT EXECUTED
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
30009e0c: 18940018 ldmne r4, {r3, r4} <== NOT EXECUTED
return 0;
30009e10: 13a00000 movne r0, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
30009e14: 18850018 stmne r5, {r3, r4} <== NOT EXECUTED
30009e18: eaffffcf b 30009d5c <adjtime+0x60> <== NOT EXECUTED
*/
if ( !delta )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
30009e1c: eb0023ea bl 30012dcc <__errno> <== NOT EXECUTED 30009e20: e3a03016 mov r3, #22 <== NOT EXECUTED 30009e24: e5803000 str r3, [r0] <== NOT EXECUTED 30009e28: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009e2c: eaffffca b 30009d5c <adjtime+0x60> <== NOT EXECUTED
3000a630 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
3000a630: 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);
3000a634: e59f41b8 ldr r4, [pc, #440] ; 3000a7f4 <aio_cancel+0x1c4> <== NOT EXECUTED
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
3000a638: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
3000a63c: e1a00004 mov r0, r4 <== NOT EXECUTED
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
3000a640: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
3000a644: eb000459 bl 3000b7b0 <pthread_mutex_lock> <== NOT EXECUTED
if (fcntl (fildes, F_GETFD) < 0) {
3000a648: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a64c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000a650: eb001bdb bl 300115c4 <fcntl> <== NOT EXECUTED 3000a654: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a658: ba00005e blt 3000a7d8 <aio_cancel+0x1a8> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
3000a65c: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a660: 0a000032 beq 3000a730 <aio_cancel+0x100> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
3000a664: e5957000 ldr r7, [r5] <== NOT EXECUTED 3000a668: e1570006 cmp r7, r6 <== NOT EXECUTED 3000a66c: 1a000028 bne 3000a714 <aio_cancel+0xe4> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
3000a670: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000a674: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a678: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a67c: eb0000be bl 3000a97c <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000a680: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000a684: 0a00000c beq 3000a6bc <aio_cancel+0x8c> <== NOT EXECUTED
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
3000a688: e286801c add r8, r6, #28 <== NOT EXECUTED 3000a68c: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a690: eb000446 bl 3000b7b0 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
3000a694: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a698: e2860008 add r0, r6, #8 <== NOT EXECUTED 3000a69c: eb0001cd bl 3000add8 <rtems_aio_remove_req> <== NOT EXECUTED 3000a6a0: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000a6a4: e1a00008 mov r0, r8 <== NOT EXECUTED 3000a6a8: eb000461 bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a6ac: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a6b0: eb00045f bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
3000a6b4: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a6b8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
3000a6bc: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 3000a6c0: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED 3000a6c4: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a6c8: 0a00000d beq 3000a704 <aio_cancel+0xd4> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
3000a6cc: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 3000a6d0: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a6d4: e1a02006 mov r2, r6 <== NOT EXECUTED 3000a6d8: eb0000a7 bl 3000a97c <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000a6dc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a6e0: 0a00000b beq 3000a714 <aio_cancel+0xe4> <== 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);
3000a6e4: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a6e8: e2800008 add r0, r0, #8 <== NOT EXECUTED 3000a6ec: eb0001b9 bl 3000add8 <rtems_aio_remove_req> <== NOT EXECUTED 3000a6f0: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a6f4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a6f8: eb00044d bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
return AIO_ALLDONE;
}
3000a6fc: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a700: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a704: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a708: eb000449 bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
3000a70c: e3a05002 mov r5, #2 <== NOT EXECUTED 3000a710: eaffffe7 b 3000a6b4 <aio_cancel+0x84> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a714: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a718: eb000445 bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EINVAL);
3000a71c: eb002976 bl 30014cfc <__errno> <== NOT EXECUTED 3000a720: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a724: e5803000 str r3, [r0] <== NOT EXECUTED 3000a728: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000a72c: eaffffe0 b 3000a6b4 <aio_cancel+0x84> <== NOT EXECUTED
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
3000a730: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000a734: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a738: e1a02005 mov r2, r5 <== NOT EXECUTED 3000a73c: eb00008e bl 3000a97c <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000a740: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000a744: 0a00000b beq 3000a778 <aio_cancel+0x148> <== NOT EXECUTED
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
3000a748: e287601c add r6, r7, #28 <== NOT EXECUTED 3000a74c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a750: eb000416 bl 3000b7b0 <pthread_mutex_lock> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000a754: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a758: eb000a7c bl 3000d150 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
3000a75c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a760: eb000188 bl 3000ad88 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000a764: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a768: eb000431 bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a76c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a770: eb00042f bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
3000a774: eaffffce b 3000a6b4 <aio_cancel+0x84> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
3000a778: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 3000a77c: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED 3000a780: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a784: 0affffde beq 3000a704 <aio_cancel+0xd4> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
3000a788: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 3000a78c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a790: e1a02007 mov r2, r7 <== NOT EXECUTED 3000a794: eb000078 bl 3000a97c <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain == NULL) {
3000a798: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000a79c: 0affffd8 beq 3000a704 <aio_cancel+0xd4> <== 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);
3000a7a0: e285601c add r6, r5, #28 <== NOT EXECUTED 3000a7a4: eb000a69 bl 3000d150 <_Chain_Extract> <== NOT EXECUTED
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
3000a7a8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a7ac: eb000175 bl 3000ad88 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
3000a7b0: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a7b4: eb00035a bl 3000b524 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
3000a7b8: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a7bc: eb000282 bl 3000b1cc <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
3000a7c0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a7c4: ebfff27f bl 300071c8 <free> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000a7c8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a7cc: eb000418 bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
3000a7d0: e1a05007 mov r5, r7 <== NOT EXECUTED 3000a7d4: eaffffb6 b 3000a6b4 <aio_cancel+0x84> <== NOT EXECUTED
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
if (fcntl (fildes, F_GETFD) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
3000a7d8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a7dc: eb000414 bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EBADF);
3000a7e0: eb002945 bl 30014cfc <__errno> <== NOT EXECUTED 3000a7e4: e3a03009 mov r3, #9 <== NOT EXECUTED 3000a7e8: e5803000 str r3, [r0] <== NOT EXECUTED 3000a7ec: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000a7f0: eaffffaf b 3000a6b4 <aio_cancel+0x84> <== NOT EXECUTED
3000a7f8 <aio_error>:
int
aio_error (const struct aiocb *aiocbp)
{
return aiocbp->error_code;
}
3000a7f8: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED 3000a7fc: e12fff1e bx lr <== NOT EXECUTED
3000a800 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
3000a800: e3500a02 cmp r0, #8192 ; 0x2000 <== NOT EXECUTED
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
3000a804: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000a808: 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);
3000a80c: 13a05016 movne r5, #22 <== NOT EXECUTED
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
3000a810: 1a000011 bne 3000a85c <aio_fsync+0x5c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000a814: e5910000 ldr r0, [r1] <== NOT EXECUTED 3000a818: e3a01003 mov r1, #3 <== NOT EXECUTED 3000a81c: eb001b68 bl 300115c4 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000a820: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000a824: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3000a828: e3500001 cmp r0, #1 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000a82c: 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)))
3000a830: 8a000009 bhi 3000a85c <aio_fsync+0x5c> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
3000a834: e3a00018 mov r0, #24 <== NOT EXECUTED 3000a838: ebfff401 bl 30007844 <malloc> <== NOT EXECUTED
if (req == NULL)
3000a83c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000a840: 0a000004 beq 3000a858 <aio_fsync+0x58> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000a844: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_SYNC;
3000a848: e3a03003 mov r3, #3 <== NOT EXECUTED 3000a84c: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000a850: 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);
3000a854: ea000179 b 3000ae40 <rtems_aio_enqueue> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000a858: e3a0500b mov r5, #11 <== NOT EXECUTED 3000a85c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000a860: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000a864: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000a868: eb002923 bl 30014cfc <__errno> <== NOT EXECUTED 3000a86c: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
3000a870: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a874: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b024 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
3000b024: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000b028: e3a01003 mov r1, #3 <== NOT EXECUTED
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
3000b02c: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000b030: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000b034: eb001962 bl 300115c4 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000b038: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000b03c: e3500002 cmp r0, #2 <== NOT EXECUTED 3000b040: 13500000 cmpne r0, #0 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000b044: 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)))
3000b048: 1a00000f bne 3000b08c <aio_read+0x68> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
3000b04c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000b050: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b054: 1a000013 bne 3000b0a8 <aio_read+0x84> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
3000b058: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000b05c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b060: ba000010 blt 3000b0a8 <aio_read+0x84> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
3000b064: e3a00018 mov r0, #24 <== NOT EXECUTED 3000b068: ebfff1f5 bl 30007844 <malloc> <== NOT EXECUTED
if (req == NULL)
3000b06c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000b070: 0a000004 beq 3000b088 <aio_read+0x64> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000b074: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_READ;
3000b078: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b07c: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000b080: 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);
3000b084: eaffff6d b 3000ae40 <rtems_aio_enqueue> <== NOT EXECUTED
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000b088: e3a0500b mov r5, #11 <== NOT EXECUTED 3000b08c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000b090: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000b094: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000b098: eb002717 bl 30014cfc <__errno> <== NOT EXECUTED 3000b09c: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
3000b0a0: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b0a4: e8bd8030 pop {r4, r5, pc} <== 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);
3000b0a8: e3a05016 mov r5, #22 <== NOT EXECUTED 3000b0ac: eafffff6 b 3000b08c <aio_read+0x68> <== NOT EXECUTED
3000b0b0 <aio_return>:
ssize_t
aio_return (const struct aiocb *aiocbp)
{
return aiocbp->return_value;
}
3000b0b0: e5900034 ldr r0, [r0, #52] ; 0x34 <== NOT EXECUTED 3000b0b4: e12fff1e bx lr <== NOT EXECUTED
30009918 <aio_suspend>:
int aio_suspend(
const struct aiocb * const list[] __attribute__((unused)),
int nent __attribute__((unused)),
const struct timespec *timeout __attribute__((unused))
)
{
30009918: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000991c: eb00242d bl 300129d8 <__errno> <== NOT EXECUTED 30009920: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009924: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009928: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000992c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b0b8 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
3000b0b8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000b0bc: e3a01003 mov r1, #3 <== NOT EXECUTED
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
3000b0c0: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
3000b0c4: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000b0c8: eb00193d bl 300115c4 <fcntl> <== NOT EXECUTED
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
3000b0cc: e2000003 and r0, r0, #3 <== NOT EXECUTED 3000b0d0: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3000b0d4: e3500001 cmp r0, #1 <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
3000b0d8: 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)))
3000b0dc: 8a00000f bhi 3000b120 <aio_write+0x68> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
3000b0e0: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000b0e4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b0e8: 1a000013 bne 3000b13c <aio_write+0x84> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
3000b0ec: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000b0f0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b0f4: ba000010 blt 3000b13c <aio_write+0x84> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
3000b0f8: e3a00018 mov r0, #24 <== NOT EXECUTED 3000b0fc: ebfff1d0 bl 30007844 <malloc> <== NOT EXECUTED
if (req == NULL)
3000b100: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000b104: 0a000004 beq 3000b11c <aio_write+0x64> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
3000b108: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_WRITE;
3000b10c: e3a03002 mov r3, #2 <== NOT EXECUTED 3000b110: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
3000b114: 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);
3000b118: eaffff48 b 3000ae40 <rtems_aio_enqueue> <== NOT EXECUTED
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
3000b11c: e3a0500b mov r5, #11 <== NOT EXECUTED 3000b120: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000b124: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 3000b128: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000b12c: eb0026f2 bl 30014cfc <__errno> <== NOT EXECUTED 3000b130: e5805000 str r5, [r0] <== NOT EXECUTED
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
3000b134: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000b138: e8bd8030 pop {r4, r5, pc} <== 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);
3000b13c: e3a05016 mov r5, #22 <== NOT EXECUTED 3000b140: eafffff6 b 3000b120 <aio_write+0x68> <== NOT EXECUTED
3000bb84 <alarm>:
}
unsigned int alarm(
unsigned int seconds
)
{
3000bb84: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000bb88: e59f4080 ldr r4, [pc, #128] ; 3000bc10 <alarm+0x8c> <== NOT EXECUTED
}
unsigned int alarm(
unsigned int seconds
)
{
3000bb8c: e1a05000 mov r5, r0 <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
3000bb90: e594601c ldr r6, [r4, #28] <== NOT EXECUTED 3000bb94: e3560000 cmp r6, #0 <== NOT EXECUTED 3000bb98: 0a00000c beq 3000bbd0 <alarm+0x4c> <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
3000bb9c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bba0: eb0013de bl 30010b20 <_Watchdog_Remove> <== NOT EXECUTED
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
3000bba4: e2400002 sub r0, r0, #2 <== NOT EXECUTED 3000bba8: e3500001 cmp r0, #1 <== NOT EXECUTED
unsigned int alarm(
unsigned int seconds
)
{
unsigned int remaining = 0;
3000bbac: 83a06000 movhi r6, #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) ) {
3000bbb0: 9a00000c bls 3000bbe8 <alarm+0x64> <== NOT EXECUTED
remaining = the_timer->initial -
((the_timer->stop_time - the_timer->start_time) / TOD_TICKS_PER_SECOND);
}
}
if ( seconds )
3000bbb4: e3550000 cmp r5, #0 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000bbb8: 159f0054 ldrne r0, [pc, #84] ; 3000bc14 <alarm+0x90> <== NOT EXECUTED 3000bbbc: 159f104c ldrne r1, [pc, #76] ; 3000bc10 <alarm+0x8c> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000bbc0: 1584500c strne r5, [r4, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000bbc4: 1b001366 blne 30010964 <_Watchdog_Insert> <== NOT EXECUTED
_Watchdog_Insert_seconds( the_timer, seconds );
return remaining;
}
3000bbc8: e1a00006 mov r0, r6 <== NOT EXECUTED
3000bbcc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000bbd0: e59f3040 ldr r3, [pc, #64] ; 3000bc18 <alarm+0x94> <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000bbd4: e5846008 str r6, [r4, #8] <== NOT EXECUTED
the_watchdog->routine = routine;
3000bbd8: e584301c str r3, [r4, #28] <== NOT EXECUTED
the_watchdog->id = id;
3000bbdc: e5846020 str r6, [r4, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000bbe0: e5846024 str r6, [r4, #36] ; 0x24 <== NOT EXECUTED 3000bbe4: eafffff2 b 3000bbb4 <alarm+0x30> <== 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);
3000bbe8: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000bbec: e5947018 ldr r7, [r4, #24] <== 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 -
3000bbf0: e594600c ldr r6, [r4, #12] <== NOT EXECUTED
((the_timer->stop_time - the_timer->start_time) / TOD_TICKS_PER_SECOND);
3000bbf4: e0637007 rsb r7, r3, r7 <== NOT EXECUTED 3000bbf8: eb0009ce bl 3000e338 <TOD_TICKS_PER_SECOND_method> <== NOT EXECUTED 3000bbfc: e1a01000 mov r1, r0 <== NOT EXECUTED 3000bc00: e1a00007 mov r0, r7 <== NOT EXECUTED 3000bc04: eb003a1b bl 3001a478 <__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 -
3000bc08: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3000bc0c: eaffffe8 b 3000bbb4 <alarm+0x30> <== NOT EXECUTED
30007c34 <cfgetispeed>:
speed_t cfgetispeed(
const struct termios *tp
)
{
return (tp->c_cflag / (CIBAUD / CBAUD)) & CBAUD;
30007c34: e1d030ba ldrh r3, [r0, #10] <== NOT EXECUTED
}
30007c38: e59f0004 ldr r0, [pc, #4] ; 30007c44 <cfgetispeed+0x10> <== NOT EXECUTED 30007c3c: e0030000 and r0, r3, r0 <== NOT EXECUTED 30007c40: e12fff1e bx lr <== NOT EXECUTED
30007c48 <cfgetospeed>:
speed_t cfgetospeed(
const struct termios *tp
)
{
return tp->c_cflag & CBAUD;
30007c48: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
}
30007c4c: e59f0004 ldr r0, [pc, #4] ; 30007c58 <cfgetospeed+0x10> <== NOT EXECUTED 30007c50: e0030000 and r0, r3, r0 <== NOT EXECUTED 30007c54: e12fff1e bx lr <== NOT EXECUTED
30007c5c <cfsetispeed>:
int cfsetispeed(
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
30007c5c: e3c13a01 bic r3, r1, #4096 ; 0x1000 <== NOT EXECUTED 30007c60: e3d3300f bics r3, r3, #15 <== NOT EXECUTED
int cfsetispeed(
struct termios *tp,
speed_t speed
)
{
30007c64: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007c68: e1a02000 mov r2, r0 <== NOT EXECUTED
if ( speed & ~CBAUD )
30007c6c: 1a000006 bne 30007c8c <cfsetispeed+0x30> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
tp->c_cflag = (tp->c_cflag & ~CIBAUD) | (speed * (CIBAUD / CBAUD));
30007c70: e590c008 ldr ip, [r0, #8] <== NOT EXECUTED
return 0;
30007c74: e1a00003 mov r0, r3 <== NOT EXECUTED
)
{
if ( speed & ~CBAUD )
rtems_set_errno_and_return_minus_one( EINVAL );
tp->c_cflag = (tp->c_cflag & ~CIBAUD) | (speed * (CIBAUD / CBAUD));
30007c78: e3cc3201 bic r3, ip, #268435456 ; 0x10000000 <== NOT EXECUTED 30007c7c: e3c3380f bic r3, r3, #983040 ; 0xf0000 <== NOT EXECUTED 30007c80: e1831801 orr r1, r3, r1, lsl #16 <== NOT EXECUTED 30007c84: e5821008 str r1, [r2, #8] <== NOT EXECUTED
return 0; }
30007c88: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
rtems_set_errno_and_return_minus_one( EINVAL );
30007c8c: eb003148 bl 300141b4 <__errno> <== NOT EXECUTED
30007c90: e3a03016 mov r3, #22 <== NOT EXECUTED
30007c94: e5803000 str r3, [r0] <== NOT EXECUTED
30007c98: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007c9c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007ca0 <cfsetospeed>:
int cfsetospeed(
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
30007ca0: e3c13a01 bic r3, r1, #4096 ; 0x1000 <== NOT EXECUTED 30007ca4: e3d3300f bics r3, r3, #15 <== NOT EXECUTED
int cfsetospeed(
struct termios *tp,
speed_t speed
)
{
30007ca8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007cac: e1a02000 mov r2, r0 <== NOT EXECUTED
if ( speed & ~CBAUD )
30007cb0: 1a000006 bne 30007cd0 <cfsetospeed+0x30> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
30007cb4: e590c008 ldr ip, [r0, #8] <== NOT EXECUTED
return 0;
30007cb8: e1a00003 mov r0, r3 <== NOT EXECUTED
)
{
if ( speed & ~CBAUD )
rtems_set_errno_and_return_minus_one( EINVAL );
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
30007cbc: e3cc3a01 bic r3, ip, #4096 ; 0x1000 <== NOT EXECUTED 30007cc0: e3c3300f bic r3, r3, #15 <== NOT EXECUTED 30007cc4: e1811003 orr r1, r1, r3 <== NOT EXECUTED 30007cc8: e5821008 str r1, [r2, #8] <== NOT EXECUTED
return 0; }
30007ccc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
rtems_set_errno_and_return_minus_one( EINVAL );
30007cd0: eb003137 bl 300141b4 <__errno> <== NOT EXECUTED
30007cd4: e3a03016 mov r3, #22 <== NOT EXECUTED
30007cd8: e5803000 str r3, [r0] <== NOT EXECUTED
30007cdc: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007ce0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007f84 <chmod>:
int chmod(
const char *path,
mode_t mode
)
{
30007f84: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30007f88: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30007f8c: e1a05001 mov r5, r1 <== NOT EXECUTED
30007f90: 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 );
30007f94: eb00384c bl 300160cc <strlen> <== NOT EXECUTED 30007f98: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30007f9c: e3a03001 mov r3, #1 <== NOT EXECUTED 30007fa0: e1a01000 mov r1, r0 <== NOT EXECUTED 30007fa4: e58d3000 str r3, [sp] <== NOT EXECUTED 30007fa8: e3a02000 mov r2, #0 <== NOT EXECUTED 30007fac: e1a00006 mov r0, r6 <== NOT EXECUTED 30007fb0: e1a03004 mov r3, r4 <== NOT EXECUTED 30007fb4: eb00004e bl 300080f4 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
if ( status != 0 )
30007fb8: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30007fbc: 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 )
30007fc0: 1a000007 bne 30007fe4 <chmod+0x60> <== NOT EXECUTED
return -1;
result = (*loc.handlers->fchmod_h)( &loc, mode );
30007fc4: e1a01005 mov r1, r5 <== NOT EXECUTED 30007fc8: e1a00004 mov r0, r4 <== NOT EXECUTED 30007fcc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30007fd0: e1a0e00f mov lr, pc <== NOT EXECUTED 30007fd4: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED 30007fd8: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30007fdc: e1a00004 mov r0, r4 <== NOT EXECUTED 30007fe0: eb00007d bl 300081dc <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
30007fe4: e1a00005 mov r0, r5 <== NOT EXECUTED
30007fe8: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30007fec: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000806c <chown>:
int chown(
const char *path,
uid_t owner,
gid_t group
)
{
3000806c: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 30008070: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
return _chown_helper( path, owner, group, true );
30008074: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 30008078: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED 3000807c: e3a03001 mov r3, #1 <== NOT EXECUTED 30008080: eaffffda b 30007ff0 <_chown_helper> <== NOT EXECUTED
30009930 <clock_getcpuclockid>:
int clock_getcpuclockid(
pid_t pid,
clockid_t *clock_id
)
{
30009930: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009934: eb002427 bl 300129d8 <__errno> <== NOT EXECUTED 30009938: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000993c: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009940: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009944: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009948 <clock_getenable_attr>:
int clock_getenable_attr(
clockid_t clock_id,
int *attr
)
{
30009948: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000994c: eb002421 bl 300129d8 <__errno> <== NOT EXECUTED 30009950: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009954: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009958: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000995c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a240 <clock_getres>:
int clock_getres(
clockid_t clock_id,
struct timespec *res
)
{
if ( !res )
3000a240: e3510000 cmp r1, #0 <== NOT EXECUTED
int clock_getres(
clockid_t clock_id,
struct timespec *res
)
{
3000a244: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !res )
3000a248: 0a000012 beq 3000a298 <clock_getres+0x58> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
switch ( clock_id ) {
3000a24c: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3000a250: e3500002 cmp r0, #2 <== NOT EXECUTED 3000a254: 9a000004 bls 3000a26c <clock_getres+0x2c> <== NOT EXECUTED
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
}
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000a258: eb002404 bl 30013270 <__errno> <== NOT EXECUTED 3000a25c: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a260: e5803000 str r3, [r0] <== NOT EXECUTED 3000a264: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
3000a268: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case CLOCK_REALTIME:
case CLOCK_PROCESS_CPUTIME:
case CLOCK_THREAD_CPUTIME:
if ( res ) {
res->tv_sec = rtems_configuration_get_microseconds_per_tick() /
3000a26c: e59f3038 ldr r3, [pc, #56] ; 3000a2ac <clock_getres+0x6c> <== NOT EXECUTED 3000a270: e59f2038 ldr r2, [pc, #56] ; 3000a2b0 <clock_getres+0x70> <== NOT EXECUTED 3000a274: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return 0;
3000a278: e3a00000 mov r0, #0 <== NOT EXECUTED
case CLOCK_REALTIME:
case CLOCK_PROCESS_CPUTIME:
case CLOCK_THREAD_CPUTIME:
if ( res ) {
res->tv_sec = rtems_configuration_get_microseconds_per_tick() /
3000a27c: e082c293 umull ip, r2, r3, r2 <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND;
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
3000a280: e063c283 rsb ip, r3, r3, lsl #5 <== NOT EXECUTED 3000a284: e083310c add r3, r3, ip, lsl #2 <== NOT EXECUTED
case CLOCK_REALTIME:
case CLOCK_PROCESS_CPUTIME:
case CLOCK_THREAD_CPUTIME:
if ( res ) {
res->tv_sec = rtems_configuration_get_microseconds_per_tick() /
3000a288: e1a02922 lsr r2, r2, #18 <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND;
res->tv_nsec = rtems_configuration_get_nanoseconds_per_tick();
3000a28c: e1a03183 lsl r3, r3, #3 <== NOT EXECUTED
case CLOCK_REALTIME:
case CLOCK_PROCESS_CPUTIME:
case CLOCK_THREAD_CPUTIME:
if ( res ) {
res->tv_sec = rtems_configuration_get_microseconds_per_tick() /
3000a290: e881000c stm r1, {r2, r3} <== NOT EXECUTED
3000a294: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
clockid_t clock_id,
struct timespec *res
)
{
if ( !res )
rtems_set_errno_and_return_minus_one( EINVAL );
3000a298: eb0023f4 bl 30013270 <__errno> <== NOT EXECUTED
3000a29c: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a2a0: e5803000 str r3, [r0] <== NOT EXECUTED
3000a2a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a2a8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009b4c <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
if ( !tp )
30009b4c: e3510000 cmp r1, #0 <== NOT EXECUTED
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
30009b50: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !tp )
30009b54: 0a000019 beq 30009bc0 <clock_gettime+0x74> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
30009b58: e3500001 cmp r0, #1 <== NOT EXECUTED 30009b5c: 0a000013 beq 30009bb0 <clock_gettime+0x64> <== NOT EXECUTED
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
30009b60: e3500004 cmp r0, #4 <== NOT EXECUTED 30009b64: 0a00000d beq 30009ba0 <clock_gettime+0x54> <== NOT EXECUTED
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
30009b68: e3500002 cmp r0, #2 <== NOT EXECUTED 30009b6c: 0a00000b beq 30009ba0 <clock_gettime+0x54> <== NOT EXECUTED
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
30009b70: e3500003 cmp r0, #3 <== NOT EXECUTED 30009b74: 0a000004 beq 30009b8c <clock_gettime+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
30009b78: eb0025fb bl 3001336c <__errno> <== NOT EXECUTED 30009b7c: e3a03016 mov r3, #22 <== NOT EXECUTED 30009b80: e5803000 str r3, [r0] <== NOT EXECUTED 30009b84: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0;
}
30009b88: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
30009b8c: eb0025f6 bl 3001336c <__errno> <== NOT EXECUTED
30009b90: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED
30009b94: e5803000 str r3, [r0] <== NOT EXECUTED
30009b98: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009b9c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
_TOD_Get_uptime_as_timespec( tp );
30009ba0: e1a00001 mov r0, r1 <== NOT EXECUTED 30009ba4: eb0007a9 bl 3000ba50 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED
return 0;
30009ba8: e3a00000 mov r0, #0 <== NOT EXECUTED
30009bac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
30009bb0: e1a00001 mov r0, r1 <== NOT EXECUTED 30009bb4: eb00078b bl 3000b9e8 <_TOD_Get> <== NOT EXECUTED
return 0;
30009bb8: e3a00000 mov r0, #0 <== NOT EXECUTED
30009bbc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
clockid_t clock_id,
struct timespec *tp
)
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
30009bc0: eb0025e9 bl 3001336c <__errno> <== NOT EXECUTED
30009bc4: e3a03016 mov r3, #22 <== NOT EXECUTED
30009bc8: e5803000 str r3, [r0] <== NOT EXECUTED
30009bcc: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009bd0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009960 <clock_setenable_attr>:
int clock_setenable_attr(
clockid_t clock_id,
int attr
)
{
30009960: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009964: eb00241b bl 300129d8 <__errno> <== NOT EXECUTED 30009968: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000996c: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009970: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009974: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009bd4 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
if ( !tp )
30009bd4: e3510000 cmp r1, #0 <== NOT EXECUTED
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
30009bd8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !tp )
30009bdc: 0a00001c beq 30009c54 <clock_settime+0x80> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
30009be0: e3500001 cmp r0, #1 <== NOT EXECUTED 30009be4: 0a000008 beq 30009c0c <clock_settime+0x38> <== NOT EXECUTED
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
30009be8: e3500002 cmp r0, #2 <== NOT EXECUTED 30009bec: 0a000013 beq 30009c40 <clock_settime+0x6c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
30009bf0: e3500003 cmp r0, #3 <== NOT EXECUTED 30009bf4: 0a000011 beq 30009c40 <clock_settime+0x6c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
30009bf8: eb0025db bl 3001336c <__errno> <== NOT EXECUTED 30009bfc: e3a03016 mov r3, #22 <== NOT EXECUTED 30009c00: e5803000 str r3, [r0] <== NOT EXECUTED 30009c04: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0;
}
30009c08: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
30009c0c: e5912000 ldr r2, [r1] <== NOT EXECUTED 30009c10: e59f3050 ldr r3, [pc, #80] ; 30009c68 <clock_settime+0x94> <== NOT EXECUTED 30009c14: e1520003 cmp r2, r3 <== NOT EXECUTED 30009c18: 9a00000d bls 30009c54 <clock_settime+0x80> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009c1c: e59f3048 ldr r3, [pc, #72] ; 30009c6c <clock_settime+0x98> <== NOT EXECUTED 30009c20: e5932000 ldr r2, [r3] <== NOT EXECUTED 30009c24: e2822001 add r2, r2, #1 <== NOT EXECUTED 30009c28: e5832000 str r2, [r3] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
30009c2c: e1a00001 mov r0, r1 <== NOT EXECUTED 30009c30: eb00079d bl 3000baac <_TOD_Set> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009c34: eb000d60 bl 3000d1bc <_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;
30009c38: e3a00000 mov r0, #0 <== NOT EXECUTED
30009c3c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
30009c40: eb0025c9 bl 3001336c <__errno> <== NOT EXECUTED
30009c44: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED
30009c48: e5803000 str r3, [r0] <== NOT EXECUTED
30009c4c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009c50: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
rtems_set_errno_and_return_minus_one( EINVAL );
30009c54: eb0025c4 bl 3001336c <__errno> <== NOT EXECUTED
30009c58: e3a03016 mov r3, #22 <== NOT EXECUTED
30009c5c: e5803000 str r3, [r0] <== NOT EXECUTED
30009c60: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009c64: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30005e14 <devFS_Show>:
{
int i;
rtems_filesystem_location_info_t *temp_loc;
rtems_device_name_t *device_name_table;
temp_loc = &rtems_filesystem_root;
30005e14: e59f3078 ldr r3, [pc, #120] ; 30005e94 <devFS_Show+0x80> <== NOT EXECUTED
#include <rtems/seterr.h>
#include "devfs.h"
int devFS_Show(void)
{
30005e18: 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;
30005e1c: e5933000 ldr r3, [r3] <== NOT EXECUTED
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
30005e20: e5935018 ldr r5, [r3, #24] <== NOT EXECUTED
if (!device_name_table)
30005e24: e3550000 cmp r5, #0 <== NOT EXECUTED 30005e28: 0a000014 beq 30005e80 <devFS_Show+0x6c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++){
30005e2c: e59f6064 ldr r6, [pc, #100] ; 30005e98 <devFS_Show+0x84> <== NOT EXECUTED
30005e30: e5960000 ldr r0, [r6] <== NOT EXECUTED
30005e34: e3500000 cmp r0, #0 <== NOT EXECUTED
30005e38: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
30005e3c: e3a03000 mov r3, #0 <== NOT EXECUTED
30005e40: e1a04003 mov r4, r3 <== NOT EXECUTED
if (device_name_table[i].device_name){
30005e44: e0833103 add r3, r3, r3, lsl #2 <== NOT EXECUTED 30005e48: e7951103 ldr r1, [r5, r3, lsl #2] <== NOT EXECUTED
printk("/%s %d %d\n", device_name_table[i].device_name,
30005e4c: e59f0048 ldr r0, [pc, #72] ; 30005e9c <devFS_Show+0x88> <== NOT EXECUTED
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++){
if (device_name_table[i].device_name){
30005e50: e3510000 cmp r1, #0 <== NOT EXECUTED 30005e54: e0853103 add r3, r5, r3, lsl #2 <== NOT EXECUTED
printk("/%s %d %d\n", device_name_table[i].device_name,
30005e58: 15932008 ldrne r2, [r3, #8] <== NOT EXECUTED 30005e5c: 1593300c ldrne r3, [r3, #12] <== NOT EXECUTED 30005e60: 1b0004b8 blne 30007148 <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++){
30005e64: e5963000 ldr r3, [r6] <== NOT EXECUTED 30005e68: e2844001 add r4, r4, #1 <== NOT EXECUTED 30005e6c: e1540003 cmp r4, r3 <== NOT EXECUTED 30005e70: e1a03004 mov r3, r4 <== NOT EXECUTED 30005e74: 3afffff2 bcc 30005e44 <devFS_Show+0x30> <== 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;
30005e78: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30005e7c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
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)
rtems_set_errno_and_return_minus_one( EFAULT );
30005e80: eb00285a bl 3000fff0 <__errno> <== NOT EXECUTED
30005e84: e3a0300e mov r3, #14 <== NOT EXECUTED
30005e88: e5803000 str r3, [r0] <== NOT EXECUTED
30005e8c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005e90: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000d708 <devFS_evaluate_path>:
{
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
3000d708: e3d22007 bics r2, r2, #7
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3000d70c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000d710: e1a09000 mov r9, r0
3000d714: e1a04001 mov r4, r1
3000d718: e1a0b003 mov fp, r3
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
3000d71c: 1a000028 bne 3000d7c4 <devFS_evaluate_path+0xbc>
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
3000d720: e5937000 ldr r7, [r3]
if (!device_name_table)
3000d724: e3570000 cmp r7, #0
3000d728: 0a00002a beq 3000d7d8 <devFS_evaluate_path+0xd0>
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
3000d72c: e59f30b8 ldr r3, [pc, #184] ; 3000d7ec <devFS_evaluate_path+0xe4> 3000d730: e5938000 ldr r8, [r3] 3000d734: e3580000 cmp r8, #0 3000d738: 11a0a002 movne sl, r2 3000d73c: 11a0500a movne r5, sl
3000d740: 0a000010 beq 3000d788 <devFS_evaluate_path+0x80>
if (!device_name_table[i].device_name)
3000d744: e08aa10a add sl, sl, sl, lsl #2 3000d748: e797610a ldr r6, [r7, sl, lsl #2]
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
3000d74c: e1a00009 mov r0, r9
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++) {
if (!device_name_table[i].device_name)
3000d750: e2561000 subs r1, r6, #0
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
3000d754: e1a02004 mov r2, r4
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++) {
if (!device_name_table[i].device_name)
3000d758: e087a10a add sl, r7, sl, lsl #2
3000d75c: 0a000005 beq 3000d778 <devFS_evaluate_path+0x70>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
3000d760: eb000da9 bl 30010e0c <strncmp> 3000d764: e3500000 cmp r0, #0
3000d768: 1a000002 bne 3000d778 <devFS_evaluate_path+0x70>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
3000d76c: e7d60004 ldrb r0, [r6, r4] 3000d770: e3500000 cmp r0, #0
3000d774: 0a000008 beq 3000d79c <devFS_evaluate_path+0x94>
/* 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++) {
3000d778: e2855001 add r5, r5, #1 3000d77c: e1580005 cmp r8, r5 3000d780: e1a0a005 mov sl, r5
3000d784: 8affffee bhi 3000d744 <devFS_evaluate_path+0x3c>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
3000d788: eb000a18 bl 3000fff0 <__errno> 3000d78c: e3a03002 mov r3, #2 3000d790: e5803000 str r3, [r0] 3000d794: e3e00000 mvn r0, #0
}
3000d798: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000d79c: e59f304c ldr r3, [pc, #76] ; 3000d7f0 <devFS_evaluate_path+0xe8>
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
3000d7a0: e59f204c ldr r2, [pc, #76] ; 3000d7f4 <devFS_evaluate_path+0xec>
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000d7a4: e5933000 ldr r3, [r3]
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
3000d7a8: e58b2008 str r2, [fp, #8]
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000d7ac: e5933028 ldr r3, [r3, #40] ; 0x28
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
3000d7b0: e59f2040 ldr r2, [pc, #64] ; 3000d7f8 <devFS_evaluate_path+0xf0>
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
3000d7b4: e58ba000 str sl, [fp]
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
3000d7b8: e58b200c str r2, [fp, #12]
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000d7bc: e58b3010 str r3, [fp, #16]
return 0;
3000d7c0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
3000d7c4: eb000a09 bl 3000fff0 <__errno> <== NOT EXECUTED
3000d7c8: e3a03001 mov r3, #1 <== NOT EXECUTED
3000d7cc: e5803000 str r3, [r0] <== NOT EXECUTED
3000d7d0: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d7d4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/* 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 );
3000d7d8: eb000a04 bl 3000fff0 <__errno> <== NOT EXECUTED
3000d7dc: e3a0300e mov r3, #14 <== NOT EXECUTED
3000d7e0: e5803000 str r3, [r0] <== NOT EXECUTED
3000d7e4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d7e8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30005c38 <devFS_initialize>:
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
30005c38: e92d4070 push {r4, r5, r6, lr}
rtems_device_name_t *device_name_table;
/* allocate device only filesystem name table */
device_name_table = (rtems_device_name_t *)_Workspace_Allocate(
30005c3c: e59f605c ldr r6, [pc, #92] ; 30005ca0 <devFS_initialize+0x68>
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
30005c40: 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(
30005c44: e5960000 ldr r0, [r6] 30005c48: e0800100 add r0, r0, r0, lsl #2 30005c4c: e1a00100 lsl r0, r0, #2 30005c50: eb001d2a bl 3000d100 <_Workspace_Allocate>
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* no memory for device filesystem */
if (!device_name_table)
30005c54: e2505000 subs r5, r0, #0
30005c58: 0a00000b beq 30005c8c <devFS_initialize+0x54>
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(
30005c5c: e5962000 ldr r2, [r6] 30005c60: e3a01000 mov r1, #0 30005c64: e0822102 add r2, r2, r2, lsl #2 30005c68: e1a02102 lsl r2, r2, #2 30005c6c: eb002b44 bl 30010984 <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;
30005c70: e59f302c ldr r3, [pc, #44] ; 30005ca4 <devFS_initialize+0x6c>
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;
30005c74: e584501c str r5, [r4, #28]
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* set file handlers */
temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers;
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
30005c78: e2832038 add r2, r3, #56 ; 0x38
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;
30005c7c: e5843024 str r3, [r4, #36] ; 0x24
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
30005c80: e5842028 str r2, [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;
30005c84: e3a00000 mov r0, #0
}
30005c88: e8bd8070 pop {r4, r5, r6, pc}
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* no memory for device filesystem */
if (!device_name_table)
rtems_set_errno_and_return_minus_one( ENOMEM );
30005c8c: eb0028d7 bl 3000fff0 <__errno> <== NOT EXECUTED
30005c90: e3a0300c mov r3, #12 <== NOT EXECUTED
30005c94: e5803000 str r3, [r0] <== NOT EXECUTED
30005c98: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005c9c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30005ea0 <devFS_ioctl>:
int devFS_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30005ea0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_libio_ioctl_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
30005ea4: e590c018 ldr ip, [r0, #24]
int devFS_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30005ea8: e24dd010 sub sp, sp, #16 30005eac: e1a03000 mov r3, r0
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.command = command;
30005eb0: e98d0006 stmib sp, {r1, r2}
args.buffer = buffer;
status = rtems_io_control(
30005eb4: e59c0008 ldr r0, [ip, #8] 30005eb8: e59c100c ldr r1, [ip, #12] 30005ebc: e1a0200d mov r2, sp
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
30005ec0: e58d3000 str r3, [sp]
args.command = command;
args.buffer = buffer;
status = rtems_io_control(
30005ec4: eb00104a bl 30009ff4 <rtems_io_control>
np->major,
np->minor,
(void *) &args
);
if ( status )
30005ec8: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return args.ioctl_return;
30005ecc: 059d000c ldreq r0, [sp, #12]
np->major,
np->minor,
(void *) &args
);
if ( status )
30005ed0: 1a000001 bne 30005edc <devFS_ioctl+0x3c>
return rtems_deviceio_errno(status);
return args.ioctl_return;
}
30005ed4: e28dd010 add sp, sp, #16
30005ed8: e8bd8000 pop {pc}
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
30005edc: eb001e49 bl 3000d808 <rtems_deviceio_errno> <== NOT EXECUTED 30005ee0: eafffffb b 30005ed4 <devFS_ioctl+0x34> <== NOT EXECUTED
30005ca8 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
30005ca8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30005cac: 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') &&
30005cb0: e5d00000 ldrb r0, [r0]
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
30005cb4: 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') &&
30005cb8: e3500064 cmp r0, #100 ; 0x64
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
30005cbc: e1a06002 mov r6, r2 30005cc0: e1a0b003 mov fp, 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') &&
30005cc4: 0a000036 beq 30005da4 <devFS_mknod+0xfc>
(path[2] == 'v') && (path[3] == '\0'))
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
30005cc8: e2053a0f and r3, r5, #61440 ; 0xf000 30005ccc: e3530a02 cmp r3, #8192 ; 0x2000 30005cd0: 13530a06 cmpne r3, #24576 ; 0x6000 30005cd4: 03a03000 moveq r3, #0 30005cd8: 13a03001 movne r3, #1
30005cdc: 1a00003a bne 30005dcc <devFS_mknod+0x124>
rtems_set_errno_and_return_minus_one( EINVAL );
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;
30005ce0: e59d2024 ldr r2, [sp, #36] ; 0x24 30005ce4: e5928000 ldr r8, [r2]
if (!device_name_table)
30005ce8: e3580000 cmp r8, #0
30005cec: 0a000040 beq 30005df4 <devFS_mknod+0x14c>
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
30005cf0: e59f2110 ldr r2, [pc, #272] ; 30005e08 <devFS_mknod+0x160> 30005cf4: e592a000 ldr sl, [r2] 30005cf8: e35a0000 cmp sl, #0 30005cfc: 13e09000 mvnne r9, #0 30005d00: 11a07003 movne r7, r3
30005d04: 1a000007 bne 30005d28 <devFS_mknod+0x80>
30005d08: ea000034 b 30005de0 <devFS_mknod+0x138> <== NOT EXECUTED
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
30005d0c: eb002b9a bl 30010b7c <strcmp> 30005d10: e3500000 cmp r0, #0
30005d14: 0a00001d beq 30005d90 <devFS_mknod+0xe8>
/* 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++){
30005d18: e2877001 add r7, r7, #1 30005d1c: e157000a cmp r7, sl 30005d20: e1a03007 mov r3, r7
30005d24: 2a000009 bcs 30005d50 <devFS_mknod+0xa8>
if (device_name_table[i].device_name == NULL)
30005d28: e0833103 add r3, r3, r3, lsl #2 30005d2c: e7983103 ldr r3, [r8, r3, lsl #2]
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
30005d30: e1a00004 mov r0, r4
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++){
if (device_name_table[i].device_name == NULL)
30005d34: e2531000 subs r1, r3, #0
30005d38: 1afffff3 bne 30005d0c <devFS_mknod+0x64>
30005d3c: e1a09007 mov r9, r7
/* 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++){
30005d40: e2877001 add r7, r7, #1 30005d44: e157000a cmp r7, sl 30005d48: e1a03007 mov r3, r7
30005d4c: 3afffff5 bcc 30005d28 <devFS_mknod+0x80>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
30005d50: e3790001 cmn r9, #1
30005d54: 0a000021 beq 30005de0 <devFS_mknod+0x138>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30005d58: e10f7000 mrs r7, CPSR 30005d5c: e3873080 orr r3, r7, #128 ; 0x80 30005d60: e129f003 msr CPSR_fc, r3
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
30005d64: e0899109 add r9, r9, r9, lsl #2 30005d68: e1a09109 lsl r9, r9, #2 30005d6c: e7884009 str r4, [r8, r9]
device_name_table[slot].device_name_length = strlen(path);
30005d70: e1a00004 mov r0, r4 30005d74: eb002c0c bl 30010dac <strlen>
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
30005d78: e0888009 add r8, r8, r9
device_name_table[slot].device_name_length = strlen(path); device_name_table[slot].major = major;
30005d7c: e9880841 stmib r8, {r0, r6, fp}
device_name_table[slot].minor = minor; device_name_table[slot].mode = mode;
30005d80: e5885010 str r5, [r8, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30005d84: e129f007 msr CPSR_fc, r7
_ISR_Enable(level);
return 0;
30005d88: e3a00000 mov r0, #0
}
30005d8c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
30005d90: eb002896 bl 3000fff0 <__errno> <== NOT EXECUTED
30005d94: e3a03011 mov r3, #17 <== NOT EXECUTED
30005d98: e5803000 str r3, [r0] <== NOT EXECUTED
30005d9c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005da0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* 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') &&
30005da4: e5d43001 ldrb r3, [r4, #1] 30005da8: e3530065 cmp r3, #101 ; 0x65
30005dac: 1affffc5 bne 30005cc8 <devFS_mknod+0x20>
30005db0: e5d43002 ldrb r3, [r4, #2] 30005db4: e3530076 cmp r3, #118 ; 0x76
30005db8: 1affffc2 bne 30005cc8 <devFS_mknod+0x20>
(path[2] == 'v') && (path[3] == '\0'))
30005dbc: e5d40003 ldrb r0, [r4, #3] 30005dc0: e3500000 cmp r0, #0
30005dc4: 1affffbf bne 30005cc8 <devFS_mknod+0x20>
30005dc8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
rtems_set_errno_and_return_minus_one( EINVAL );
30005dcc: eb002887 bl 3000fff0 <__errno> <== NOT EXECUTED
30005dd0: e3a03016 mov r3, #22 <== NOT EXECUTED
30005dd4: e5803000 str r3, [r0] <== NOT EXECUTED
30005dd8: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005ddc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
30005de0: eb002882 bl 3000fff0 <__errno> <== NOT EXECUTED
30005de4: e3a0300c mov r3, #12 <== NOT EXECUTED
30005de8: e5803000 str r3, [r0] <== NOT EXECUTED
30005dec: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005df0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
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 );
30005df4: eb00287d bl 3000fff0 <__errno> <== NOT EXECUTED
30005df8: e3a0300e mov r3, #14 <== NOT EXECUTED
30005dfc: e5803000 str r3, [r0] <== NOT EXECUTED
30005e00: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005e04: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30005f1c <devFS_read>:
ssize_t devFS_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
30005f1c: e92d4800 push {fp, lr} <== 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;
30005f20: e590c018 ldr ip, [r0, #24] <== NOT EXECUTED
ssize_t devFS_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
30005f24: e24dd01c sub sp, sp, #28 <== NOT EXECUTED 30005f28: e1a03000 mov r3, r0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
30005f2c: e590e014 ldr lr, [r0, #20] <== NOT EXECUTED
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
30005f30: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
30005f34: e59c0008 ldr r0, [ip, #8] <== NOT EXECUTED 30005f38: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
30005f3c: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
30005f40: e283c00c add ip, r3, #12 <== NOT EXECUTED
30005f44: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
30005f48: e58d3000 str r3, [sp] <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
30005f4c: e1a0200d mov r2, sp <== NOT EXECUTED
args.iop = iop; args.offset = iop->offset; args.buffer = buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
30005f50: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
30005f54: e98d1800 stmib sp, {fp, ip} <== NOT EXECUTED
args.buffer = buffer; args.count = count; args.flags = iop->flags;
30005f58: e58de014 str lr, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
30005f5c: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
status = rtems_io_read(
30005f60: eb001086 bl 3000a180 <rtems_io_read> <== NOT EXECUTED
np->major,
np->minor,
(void *) &args
);
if ( status )
30005f64: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
30005f68: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
np->major,
np->minor,
(void *) &args
);
if ( status )
30005f6c: 1a000001 bne 30005f78 <devFS_read+0x5c> <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
30005f70: e28dd01c add sp, sp, #28 <== NOT EXECUTED
30005f74: e8bd8800 pop {fp, pc} <== NOT EXECUTED
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
30005f78: eb001e22 bl 3000d808 <rtems_deviceio_errno> <== NOT EXECUTED 30005f7c: eafffffb b 30005f70 <devFS_read+0x54> <== NOT EXECUTED
30005fa0 <devFS_write>:
ssize_t devFS_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
30005fa0: e92d4800 push {fp, lr}
rtems_libio_rw_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
30005fa4: e590c018 ldr ip, [r0, #24]
ssize_t devFS_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
30005fa8: e24dd01c sub sp, sp, #28 30005fac: e1a03000 mov r3, r0
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
30005fb0: e590e014 ldr lr, [r0, #20]
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
30005fb4: e58d100c str r1, [sp, #12]
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
30005fb8: e59c0008 ldr r0, [ip, #8] 30005fbc: e59c100c ldr r1, [ip, #12]
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
30005fc0: e58d2010 str r2, [sp, #16]
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
30005fc4: e283c00c add ip, r3, #12
30005fc8: e89c1800 ldm ip, {fp, ip}
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
30005fcc: e58d3000 str r3, [sp]
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
30005fd0: e1a0200d mov r2, sp
args.iop = iop; args.offset = iop->offset; args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
30005fd4: e3a03000 mov r3, #0
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
30005fd8: e98d1800 stmib sp, {fp, ip}
args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags;
30005fdc: e58de014 str lr, [sp, #20]
args.bytes_moved = 0;
30005fe0: e58d3018 str r3, [sp, #24]
status = rtems_io_write(
30005fe4: eb00107a bl 3000a1d4 <rtems_io_write>
np->major,
np->minor,
(void *) &args
);
if ( status )
30005fe8: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
30005fec: 059d0018 ldreq r0, [sp, #24]
np->major,
np->minor,
(void *) &args
);
if ( status )
30005ff0: 1a000001 bne 30005ffc <devFS_write+0x5c>
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
30005ff4: e28dd01c add sp, sp, #28
30005ff8: e8bd8800 pop {fp, pc}
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
30005ffc: eb001e01 bl 3000d808 <rtems_deviceio_errno> <== NOT EXECUTED 30006000: eafffffb b 30005ff4 <devFS_write+0x54> <== NOT EXECUTED
3001133c <device_ftruncate>:
rtems_libio_t *iop,
rtems_off64_t length
)
{
return 0;
}
3001133c: e3a00000 mov r0, #0 <== NOT EXECUTED 30011340: e12fff1e bx lr <== NOT EXECUTED
300112ec <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
300112ec: e52de004 push {lr} ; (str lr, [sp, #-4]!)
args.iop = iop;
args.command = command;
args.buffer = buffer;
the_jnode = iop->pathinfo.node_access;
300112f0: e590c018 ldr ip, [r0, #24]
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
300112f4: e24dd010 sub sp, sp, #16 300112f8: e1a03000 mov r3, r0
rtems_libio_ioctl_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
args.iop = iop;
args.command = command;
300112fc: e98d0006 stmib sp, {r1, r2}
args.buffer = buffer;
the_jnode = iop->pathinfo.node_access;
status = rtems_io_control(
30011300: e59c0050 ldr r0, [ip, #80] ; 0x50 30011304: e59c1054 ldr r1, [ip, #84] ; 0x54 30011308: e1a0200d mov r2, sp
{
rtems_libio_ioctl_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
args.iop = iop;
3001130c: e58d3000 str r3, [sp]
args.command = command;
args.buffer = buffer;
the_jnode = iop->pathinfo.node_access;
status = rtems_io_control(
30011310: eb00027e bl 30011d10 <rtems_io_control>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
30011314: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return args.ioctl_return;
30011318: 059d000c ldreq r0, [sp, #12]
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
3001131c: 1a000001 bne 30011328 <device_ioctl+0x3c>
return rtems_deviceio_errno(status);
return args.ioctl_return;
}
30011320: e28dd010 add sp, sp, #16
30011324: e8bd8000 pop {pc}
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
30011328: eb000322 bl 30011fb8 <rtems_deviceio_errno> <== NOT EXECUTED 3001132c: eafffffb b 30011320 <device_ioctl+0x34> <== NOT EXECUTED
30011330 <device_lseek>:
rtems_off64_t offset,
int whence
)
{
return offset;
}
30011330: e1a00001 mov r0, r1 <== NOT EXECUTED 30011334: e1a01002 mov r1, r2 <== NOT EXECUTED 30011338: e12fff1e bx lr <== NOT EXECUTED
30011224 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
30011224: e92d4800 push {fp, lr} <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
30011228: e590c018 ldr ip, [r0, #24] <== NOT EXECUTED
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
3001122c: e24dd01c sub sp, sp, #28 <== NOT EXECUTED 30011230: e1a03000 mov r3, r0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
30011234: e590e014 ldr lr, [r0, #20] <== NOT EXECUTED
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
30011238: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count;
3001123c: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
30011240: e59c0050 ldr r0, [ip, #80] ; 0x50 <== NOT EXECUTED 30011244: e59c1054 ldr r1, [ip, #84] ; 0x54 <== NOT EXECUTED
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
30011248: e58d3000 str r3, [sp] <== NOT EXECUTED
args.offset = iop->offset;
3001124c: e283c00c add ip, r3, #12 <== NOT EXECUTED
30011250: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
30011254: e1a0200d mov r2, sp <== NOT EXECUTED
args.iop = iop; args.offset = iop->offset; args.buffer = buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
30011258: e3a03000 mov r3, #0 <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
3001125c: e98d1800 stmib sp, {fp, ip} <== NOT EXECUTED
args.buffer = buffer; args.count = count; args.flags = iop->flags;
30011260: e58de014 str lr, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
30011264: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
status = rtems_io_read(
30011268: eb0002d2 bl 30011db8 <rtems_io_read> <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
3001126c: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
30011270: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
30011274: 1a000001 bne 30011280 <device_read+0x5c> <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
30011278: e28dd01c add sp, sp, #28 <== NOT EXECUTED
3001127c: e8bd8800 pop {fp, pc} <== NOT EXECUTED
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
30011280: eb00034c bl 30011fb8 <rtems_deviceio_errno> <== NOT EXECUTED 30011284: eafffffb b 30011278 <device_read+0x54> <== NOT EXECUTED
30011288 <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
30011288: e92d4800 push {fp, lr}
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
3001128c: e590c018 ldr ip, [r0, #24]
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
30011290: e24dd01c sub sp, sp, #28 30011294: e1a03000 mov r3, r0
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
30011298: e590e014 ldr lr, [r0, #20]
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
3001129c: e58d100c str r1, [sp, #12]
args.count = count;
300112a0: e58d2010 str r2, [sp, #16]
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
300112a4: e59c0050 ldr r0, [ip, #80] ; 0x50 300112a8: e59c1054 ldr r1, [ip, #84] ; 0x54
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
300112ac: e58d3000 str r3, [sp]
args.offset = iop->offset;
300112b0: e283c00c add ip, r3, #12
300112b4: e89c1800 ldm ip, {fp, ip}
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
300112b8: e1a0200d mov r2, sp
args.iop = iop; args.offset = iop->offset; args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
300112bc: e3a03000 mov r3, #0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
300112c0: e98d1800 stmib sp, {fp, ip}
args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags;
300112c4: e58de014 str lr, [sp, #20]
args.bytes_moved = 0;
300112c8: e58d3018 str r3, [sp, #24]
status = rtems_io_write(
300112cc: eb0002ce bl 30011e0c <rtems_io_write>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
300112d0: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
300112d4: 059d0018 ldreq r0, [sp, #24]
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
300112d8: 1a000001 bne 300112e4 <device_write+0x5c>
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
300112dc: e28dd01c add sp, sp, #28
300112e0: e8bd8800 pop {fp, pc}
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
300112e4: eb000333 bl 30011fb8 <rtems_deviceio_errno> <== NOT EXECUTED 300112e8: eafffffb b 300112dc <device_write+0x54> <== NOT EXECUTED
30007408 <drainOutput>:
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30007408: e59030b4 ldr r3, [r0, #180] ; 0xb4
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
3000740c: e92d4030 push {r4, r5, lr}
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30007410: e3530000 cmp r3, #0
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
30007414: e1a04000 mov r4, r0
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30007418: 08bd8030 popeq {r4, r5, pc}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000741c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30007420: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30007424: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
30007428: e5901084 ldr r1, [r0, #132] ; 0x84 <== NOT EXECUTED 3000742c: e5902080 ldr r2, [r0, #128] ; 0x80 <== NOT EXECUTED 30007430: e1510002 cmp r1, r2 <== NOT EXECUTED 30007434: 0a00000f beq 30007478 <drainOutput+0x70> <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
30007438: e3a05002 mov r5, #2 <== NOT EXECUTED 3000743c: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007440: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
30007444: e3a01000 mov r1, #0 <== NOT EXECUTED 30007448: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED 3000744c: e1a02001 mov r2, r1 <== NOT EXECUTED 30007450: eb0009bf bl 30009b54 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
30007454: e3500000 cmp r0, #0 <== NOT EXECUTED 30007458: 1a000008 bne 30007480 <drainOutput+0x78> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000745c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30007460: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30007464: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
30007468: e5941084 ldr r1, [r4, #132] ; 0x84 <== NOT EXECUTED 3000746c: e5942080 ldr r2, [r4, #128] ; 0x80 <== NOT EXECUTED 30007470: e1510002 cmp r1, r2 <== NOT EXECUTED 30007474: 1afffff0 bne 3000743c <drainOutput+0x34> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007478: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3000747c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
30007480: eb000b5b bl 3000a1f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
30006cc4 <dup>:
int dup(
int fildes
)
{
return fcntl( fildes, F_DUPFD, 0 );
30006cc4: e3a01000 mov r1, #0 <== NOT EXECUTED 30006cc8: e1a02001 mov r2, r1 <== NOT EXECUTED 30006ccc: ea000055 b 30006e28 <fcntl> <== NOT EXECUTED
30006c70 <dup2>:
int dup2(
int fildes,
int fildes2
)
{
30006c70: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30006c74: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
30006c78: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
30006c7c: e1a0100d mov r1, sp <== NOT EXECUTED
int dup2(
int fildes,
int fildes2
)
{
30006c80: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
30006c84: eb000178 bl 3000726c <fstat> <== NOT EXECUTED
if ( status == -1 )
30006c88: e3700001 cmn r0, #1 <== NOT EXECUTED
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
30006c8c: e1a0400d mov r4, sp <== NOT EXECUTED
if ( status == -1 )
30006c90: 1a000001 bne 30006c9c <dup2+0x2c> <== NOT EXECUTED
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
}
30006c94: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
30006c98: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
30006c9c: e1a00005 mov r0, r5 <== NOT EXECUTED 30006ca0: e1a0100d mov r1, sp <== NOT EXECUTED 30006ca4: eb000170 bl 3000726c <fstat> <== NOT EXECUTED
if ( status == -1 )
30006ca8: e3700001 cmn r0, #1 <== NOT EXECUTED 30006cac: 0afffff8 beq 30006c94 <dup2+0x24> <== NOT EXECUTED
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
30006cb0: e1a00006 mov r0, r6 <== NOT EXECUTED 30006cb4: e3a01000 mov r1, #0 <== NOT EXECUTED 30006cb8: e1a02005 mov r2, r5 <== NOT EXECUTED 30006cbc: eb000059 bl 30006e28 <fcntl> <== NOT EXECUTED 30006cc0: eafffff3 b 30006c94 <dup2+0x24> <== NOT EXECUTED
30008170 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
30008170: e92d4010 push {r4, lr} <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) &&
30008174: e591203c ldr r2, [r1, #60] ; 0x3c <== NOT EXECUTED
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
30008178: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) &&
3000817c: e3120c02 tst r2, #512 ; 0x200 <== NOT EXECUTED
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
30008180: e1a04001 mov r4, r1 <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) &&
30008184: 0a00000b beq 300081b8 <echo+0x48> <== NOT EXECUTED
iscntrl(c) && (c != '\t') && (c != '\n')) {
30008188: e59f3070 ldr r3, [pc, #112] ; 30008200 <echo+0x90> <== NOT EXECUTED 3000818c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008190: e0833000 add r3, r3, r0 <== NOT EXECUTED 30008194: 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) &&
30008198: e3130020 tst r3, #32 <== NOT EXECUTED 3000819c: 03a03000 moveq r3, #0 <== NOT EXECUTED 300081a0: 13a03001 movne r3, #1 <== NOT EXECUTED
iscntrl(c) && (c != '\t') && (c != '\n')) {
300081a4: e3500009 cmp r0, #9 <== NOT EXECUTED 300081a8: 03a03000 moveq r3, #0 <== NOT EXECUTED 300081ac: 12033001 andne r3, r3, #1 <== NOT EXECUTED 300081b0: e3530000 cmp r3, #0 <== NOT EXECUTED 300081b4: 1a000003 bne 300081c8 <echo+0x58> <== NOT EXECUTED
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
300081b8: e1a01004 mov r1, r4 <== NOT EXECUTED 300081bc: ebffff8f bl 30008000 <oproc> <== NOT EXECUTED
} }
300081c0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300081c4: e8bd8010 pop {r4, pc} <== 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')) {
300081c8: e350000a cmp r0, #10 <== NOT EXECUTED 300081cc: 0afffff9 beq 300081b8 <echo+0x48> <== NOT EXECUTED
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
300081d0: e2203040 eor r3, r0, #64 ; 0x40 <== NOT EXECUTED
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
300081d4: e3a0c05e mov ip, #94 ; 0x5e <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
300081d8: e1a0000d mov r0, sp <== NOT EXECUTED 300081dc: e3a01002 mov r1, #2 <== NOT EXECUTED 300081e0: e1a02004 mov r2, r4 <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
300081e4: e5cd3001 strb r3, [sp, #1] <== NOT EXECUTED
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
300081e8: e5cdc000 strb ip, [sp] <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
300081ec: ebffff3c bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
tty->column += 2;
300081f0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300081f4: e2833002 add r3, r3, #2 <== NOT EXECUTED 300081f8: 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')) {
300081fc: eaffffef b 300081c0 <echo+0x50> <== NOT EXECUTED
300075a0 <endgrent>:
void endgrent(void)
{
if (group_fp != NULL)
300075a0: e59f300c ldr r3, [pc, #12] ; 300075b4 <endgrent+0x14> <== NOT EXECUTED 300075a4: e59301c4 ldr r0, [r3, #452] ; 0x1c4 <== NOT EXECUTED 300075a8: e3500000 cmp r0, #0 <== NOT EXECUTED 300075ac: 012fff1e bxeq lr <== NOT EXECUTED
fclose(group_fp);
300075b0: ea002ef8 b 30013198 <fclose> <== NOT EXECUTED
30007434 <endpwent>:
void endpwent(void)
{
if (passwd_fp != NULL)
30007434: e59f300c ldr r3, [pc, #12] ; 30007448 <endpwent+0x14> <== NOT EXECUTED 30007438: e59300e8 ldr r0, [r3, #232] ; 0xe8 <== NOT EXECUTED 3000743c: e3500000 cmp r0, #0 <== NOT EXECUTED 30007440: 012fff1e bxeq lr <== NOT EXECUTED
fclose(passwd_fp);
30007444: ea002f53 b 30013198 <fclose> <== NOT EXECUTED
30008204 <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)
30008204: 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)
{
30008208: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
if (tty->ccount == 0)
3000820c: 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)
{
30008210: e1a04000 mov r4, r0 <== NOT EXECUTED 30008214: e1a06001 mov r6, r1 <== NOT EXECUTED
if (tty->ccount == 0)
30008218: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return;
if (lineFlag) {
3000821c: e3510000 cmp r1, #0 <== NOT EXECUTED 30008220: 0a000010 beq 30008268 <erase+0x64> <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
30008224: e590103c ldr r1, [r0, #60] ; 0x3c <== NOT EXECUTED 30008228: e2112008 ands r2, r1, #8 <== NOT EXECUTED
tty->ccount = 0;
3000822c: 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)) {
30008230: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
30008234: e2110010 ands r0, r1, #16 <== NOT EXECUTED 30008238: 1a00000c bne 30008270 <erase+0x6c> <== NOT EXECUTED
tty->ccount = 0;
3000823c: e5840020 str r0, [r4, #32] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
30008240: e1a01004 mov r1, r4 <== NOT EXECUTED 30008244: e5d40044 ldrb r0, [r4, #68] ; 0x44 <== NOT EXECUTED 30008248: ebffffc8 bl 30008170 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
3000824c: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
30008250: e3130020 tst r3, #32 <== NOT EXECUTED
30008254: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
30008258: e3a0000a mov r0, #10 <== NOT EXECUTED 3000825c: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
30008260: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
30008264: eaffffc1 b 30008170 <echo> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
30008268: e590103c ldr r1, [r0, #60] ; 0x3c <== NOT EXECUTED 3000826c: e2012008 and r2, r1, #8 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
30008270: e59f7198 ldr r7, [pc, #408] ; 30008410 <erase+0x20c> <== NOT EXECUTED 30008274: ea000008 b 3000829c <erase+0x98> <== NOT EXECUTED 30008278: e3110c02 tst r1, #512 ; 0x200 <== NOT EXECUTED 3000827c: 1a00004b bne 300083b0 <erase+0x1ac> <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
30008280: e3560000 cmp r6, #0 <== NOT EXECUTED
30008284: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
30008288: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000828c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008290: 0a000045 beq 300083ac <erase+0x1a8> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
30008294: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED 30008298: e2012008 and r2, r1, #8 <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
3000829c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 300082a0: e594001c ldr r0, [r4, #28] <== NOT EXECUTED 300082a4: e5843020 str r3, [r4, #32] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
300082a8: e3520000 cmp r2, #0 <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
300082ac: e7d05003 ldrb r5, [r0, r3] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
300082b0: 0afffff2 beq 30008280 <erase+0x7c> <== NOT EXECUTED
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
300082b4: e3560000 cmp r6, #0 <== NOT EXECUTED 300082b8: 1a000001 bne 300082c4 <erase+0xc0> <== NOT EXECUTED 300082bc: e3110010 tst r1, #16 <== NOT EXECUTED 300082c0: 0a000035 beq 3000839c <erase+0x198> <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
300082c4: e3550009 cmp r5, #9 <== NOT EXECUTED 300082c8: 0a00000f beq 3000830c <erase+0x108> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
300082cc: e5973000 ldr r3, [r7] <== NOT EXECUTED 300082d0: e2855001 add r5, r5, #1 <== NOT EXECUTED 300082d4: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED 300082d8: e3130020 tst r3, #32 <== NOT EXECUTED 300082dc: 1affffe5 bne 30008278 <erase+0x74> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
300082e0: e59f012c ldr r0, [pc, #300] ; 30008414 <erase+0x210> <== NOT EXECUTED 300082e4: e3a01003 mov r1, #3 <== NOT EXECUTED 300082e8: e1a02004 mov r2, r4 <== NOT EXECUTED 300082ec: ebfffefc bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
300082f0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300082f4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
300082f8: 12433001 subne r3, r3, #1 <== NOT EXECUTED 300082fc: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
}
}
if (!lineFlag)
30008300: e3560000 cmp r6, #0 <== NOT EXECUTED
30008304: 1affffdf bne 30008288 <erase+0x84> <== NOT EXECUTED
30008308: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
3000830c: e3530000 cmp r3, #0 <== 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;
30008310: e594502c ldr r5, [r4, #44] ; 0x2c <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
30008314: 0a000011 beq 30008360 <erase+0x15c> <== NOT EXECUTED
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
30008318: e5978000 ldr r8, [r7] <== 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;
3000831c: 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)
30008320: e201ac02 and sl, r1, #512 ; 0x200 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
30008324: e7d01002 ldrb r1, [r0, r2] <== NOT EXECUTED 30008328: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (c == '\t') {
3000832c: e3510009 cmp r1, #9 <== NOT EXECUTED
col = (col | 7) + 1;
30008330: 03855007 orreq r5, r5, #7 <== NOT EXECUTED
} else if (iscntrl (c)) {
30008334: e088c001 add ip, r8, r1 <== NOT EXECUTED
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
30008338: 02855001 addeq r5, r5, #1 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
3000833c: 0a000005 beq 30008358 <erase+0x154> <== NOT EXECUTED
col = (col | 7) + 1;
} else if (iscntrl (c)) {
30008340: e5dcc001 ldrb ip, [ip, #1] <== NOT EXECUTED 30008344: e31c0020 tst ip, #32 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
30008348: 02855001 addeq r5, r5, #1 <== NOT EXECUTED
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
3000834c: 0a000001 beq 30008358 <erase+0x154> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
30008350: e35a0000 cmp sl, #0 <== NOT EXECUTED
col += 2;
30008354: 12855002 addne r5, r5, #2 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
30008358: e1530002 cmp r3, r2 <== NOT EXECUTED 3000835c: 1afffff0 bne 30008324 <erase+0x120> <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
30008360: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30008364: e1550003 cmp r5, r3 <== NOT EXECUTED 30008368: aaffffc4 bge 30008280 <erase+0x7c> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
3000836c: e59f00a4 ldr r0, [pc, #164] ; 30008418 <erase+0x214> <== NOT EXECUTED 30008370: e3a01001 mov r1, #1 <== NOT EXECUTED 30008374: e1a02004 mov r2, r4 <== NOT EXECUTED 30008378: ebfffed9 bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
tty->column--;
3000837c: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30008380: e2433001 sub r3, r3, #1 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
30008384: e1530005 cmp r3, r5 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
30008388: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
3000838c: cafffff6 bgt 3000836c <erase+0x168> <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
30008390: e3560000 cmp r6, #0 <== NOT EXECUTED
30008394: 1affffbb bne 30008288 <erase+0x84> <== NOT EXECUTED
30008398: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
3000839c: e5d40043 ldrb r0, [r4, #67] ; 0x43 <== NOT EXECUTED 300083a0: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
300083a4: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
300083a8: eaffff70 b 30008170 <echo> <== NOT EXECUTED
300083ac: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
300083b0: e59f005c ldr r0, [pc, #92] ; 30008414 <erase+0x210> <== NOT EXECUTED 300083b4: e3a01003 mov r1, #3 <== NOT EXECUTED 300083b8: e1a02004 mov r2, r4 <== NOT EXECUTED 300083bc: ebfffec8 bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
300083c0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300083c4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
300083c8: 12433001 subne r3, r3, #1 <== NOT EXECUTED 300083cc: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
300083d0: e5973000 ldr r3, [r7] <== NOT EXECUTED 300083d4: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED 300083d8: e3130020 tst r3, #32 <== NOT EXECUTED 300083dc: 0affffbf beq 300082e0 <erase+0xdc> <== NOT EXECUTED 300083e0: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 300083e4: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED 300083e8: 0affffa4 beq 30008280 <erase+0x7c> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
300083ec: e59f0020 ldr r0, [pc, #32] ; 30008414 <erase+0x210> <== NOT EXECUTED 300083f0: e3a01003 mov r1, #3 <== NOT EXECUTED 300083f4: e1a02004 mov r2, r4 <== NOT EXECUTED 300083f8: ebfffeb9 bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
300083fc: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30008400: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
30008404: 12433001 subne r3, r3, #1 <== NOT EXECUTED 30008408: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED 3000840c: eaffffbb b 30008300 <erase+0xfc> <== NOT EXECUTED
30007360 <fchdir>:
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
30007360: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
30007364: e59f3138 ldr r3, [pc, #312] ; 300074a4 <fchdir+0x144> <== NOT EXECUTED
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
30007368: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
3000736c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007370: e1500003 cmp r0, r3 <== NOT EXECUTED 30007374: 2a000040 bcs 3000747c <fchdir+0x11c> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
30007378: e59f3128 ldr r3, [pc, #296] ; 300074a8 <fchdir+0x148> <== NOT EXECUTED 3000737c: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 30007380: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007384: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
30007388: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000738c: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007390: 0a000039 beq 3000747c <fchdir+0x11c> <== NOT EXECUTED
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30007394: e3130002 tst r3, #2 <== NOT EXECUTED 30007398: 0a00003c beq 30007490 <fchdir+0x130> <== NOT EXECUTED
/*
* Verify you can change directory into this node.
*/
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
3000739c: e2805018 add r5, r0, #24 <== NOT EXECUTED 300073a0: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 300073a4: e1a00005 mov r0, r5 <== NOT EXECUTED 300073a8: e1a0e00f mov lr, pc <== NOT EXECUTED 300073ac: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED 300073b0: e3500001 cmp r0, #1 <== NOT EXECUTED 300073b4: e1a07000 mov r7, r0 <== NOT EXECUTED 300073b8: 1a000022 bne 30007448 <fchdir+0xe8> <== NOT EXECUTED
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
300073bc: e59f60e8 ldr r6, [pc, #232] ; 300074ac <fchdir+0x14c> <== NOT EXECUTED
300073c0: e28d4004 add r4, sp, #4 <== NOT EXECUTED
300073c4: e596e000 ldr lr, [r6] <== NOT EXECUTED
300073c8: e1a09004 mov r9, r4 <== NOT EXECUTED
300073cc: e28ec004 add ip, lr, #4 <== NOT EXECUTED
300073d0: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
300073d4: e8a9000f stmia r9!, {r0, r1, r2, r3} <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
300073d8: e8b5000f ldm r5!, {r0, r1, r2, r3} <== NOT EXECUTED
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
300073dc: e59cb000 ldr fp, [ip] <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
300073e0: e595a000 ldr sl, [r5] <== NOT EXECUTED
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
300073e4: e28d8018 add r8, sp, #24 <== NOT EXECUTED 300073e8: e3a05000 mov r5, #0 <== NOT EXECUTED
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
rtems_filesystem_current = iop->pathinfo;
300073ec: e28ee004 add lr, lr, #4 <== NOT EXECUTED
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
300073f0: e589b000 str fp, [r9] <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
300073f4: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
300073f8: e58ca000 str sl, [ip] <== NOT EXECUTED
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
300073fc: e1a02005 mov r2, r5 <== NOT EXECUTED 30007400: e59f00a8 ldr r0, [pc, #168] ; 300074b0 <fchdir+0x150> <== NOT EXECUTED 30007404: e1a01007 mov r1, r7 <== NOT EXECUTED 30007408: e1a03008 mov r3, r8 <== NOT EXECUTED 3000740c: e58d5000 str r5, [sp] <== NOT EXECUTED 30007410: ebffff98 bl 30007278 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 30007414: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30007418: 1a00000f bne 3000745c <fchdir+0xfc> <== NOT EXECUTED
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
return -1;
}
/* release the old one */
rtems_filesystem_freenode( &saved );
3000741c: e1a00004 mov r0, r4 <== NOT EXECUTED 30007420: eb000065 bl 300075bc <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_current = loc;
30007424: e8b8000f ldm r8!, {r0, r1, r2, r3} <== NOT EXECUTED
30007428: e596c000 ldr ip, [r6] <== NOT EXECUTED
3000742c: e5984000 ldr r4, [r8] <== NOT EXECUTED
30007430: e28cc004 add ip, ip, #4 <== NOT EXECUTED
30007434: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
return 0;
30007438: e1a00005 mov r0, r5 <== NOT EXECUTED
return -1;
}
/* release the old one */
rtems_filesystem_freenode( &saved );
rtems_filesystem_current = loc;
3000743c: e58c4000 str r4, [ip] <== NOT EXECUTED
return 0;
}
30007440: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
30007444: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* Verify you can change directory into this node.
*/
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_set_errno_and_return_minus_one( ENOTDIR );
30007448: eb002fae bl 30013308 <__errno> <== NOT EXECUTED 3000744c: e3a03014 mov r3, #20 <== NOT EXECUTED 30007450: e5803000 str r3, [r0] <== NOT EXECUTED 30007454: e3e00000 mvn r0, #0 <== NOT EXECUTED 30007458: eafffff8 b 30007440 <fchdir+0xe0> <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
3000745c: e596c000 ldr ip, [r6] <== NOT EXECUTED
30007460: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
30007464: e28cc004 add ip, ip, #4 <== NOT EXECUTED
30007468: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000746c: e5993000 ldr r3, [r9] <== NOT EXECUTED
return -1;
30007470: e3e00000 mvn r0, #0 <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
30007474: e58c3000 str r3, [ip] <== NOT EXECUTED
return -1;
30007478: eafffff0 b 30007440 <fchdir+0xe0> <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
3000747c: eb002fa1 bl 30013308 <__errno> <== NOT EXECUTED 30007480: e3a03009 mov r3, #9 <== NOT EXECUTED 30007484: e5803000 str r3, [r0] <== NOT EXECUTED 30007488: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000748c: eaffffeb b 30007440 <fchdir+0xe0> <== NOT EXECUTED
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30007490: eb002f9c bl 30013308 <__errno> <== NOT EXECUTED 30007494: e3a03016 mov r3, #22 <== NOT EXECUTED 30007498: e5803000 str r3, [r0] <== NOT EXECUTED 3000749c: e3e00000 mvn r0, #0 <== NOT EXECUTED 300074a0: eaffffe6 b 30007440 <fchdir+0xe0> <== NOT EXECUTED
300074b4 <fchmod>:
mode_t mode
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300074b4: e59f306c ldr r3, [pc, #108] ; 30007528 <fchmod+0x74> <== NOT EXECUTED
int fchmod(
int fd,
mode_t mode
)
{
300074b8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300074bc: e5933000 ldr r3, [r3] <== NOT EXECUTED 300074c0: e1500003 cmp r0, r3 <== NOT EXECUTED 300074c4: 2a00000d bcs 30007500 <fchmod+0x4c> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
300074c8: e59f305c ldr r3, [pc, #92] ; 3000752c <fchmod+0x78> <== NOT EXECUTED 300074cc: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 300074d0: e5933000 ldr r3, [r3] <== NOT EXECUTED 300074d4: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
300074d8: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 300074dc: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300074e0: 0a000006 beq 30007500 <fchmod+0x4c> <== NOT EXECUTED
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
300074e4: e3130004 tst r3, #4 <== NOT EXECUTED 300074e8: 0a000009 beq 30007514 <fchmod+0x60> <== NOT EXECUTED
return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode );
300074ec: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 300074f0: e2800018 add r0, r0, #24 <== NOT EXECUTED 300074f4: e1a0e00f mov lr, pc <== NOT EXECUTED 300074f8: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED
}
300074fc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30007500: eb002f80 bl 30013308 <__errno> <== NOT EXECUTED
30007504: e3a03009 mov r3, #9 <== NOT EXECUTED
30007508: e5803000 str r3, [r0] <== NOT EXECUTED
3000750c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007510: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007514: eb002f7b bl 30013308 <__errno> <== NOT EXECUTED
30007518: e3a03016 mov r3, #22 <== NOT EXECUTED
3000751c: e5803000 str r3, [r0] <== NOT EXECUTED
30007520: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007524: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007530 <fchown>:
gid_t group
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007530: e59f307c ldr r3, [pc, #124] ; 300075b4 <fchown+0x84> <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
30007534: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007538: e5933000 ldr r3, [r3] <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
3000753c: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007540: e1500003 cmp r0, r3 <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
30007544: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007548: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED
3000754c: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007550: 2a00000d bcs 3000758c <fchown+0x5c> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
30007554: e59f305c ldr r3, [pc, #92] ; 300075b8 <fchown+0x88> <== NOT EXECUTED 30007558: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 3000755c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007560: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
30007564: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 30007568: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3000756c: 0a000006 beq 3000758c <fchown+0x5c> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007570: e3130004 tst r3, #4 <== NOT EXECUTED 30007574: 0a000009 beq 300075a0 <fchown+0x70> <== NOT EXECUTED
return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group );
30007578: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 3000757c: e2800018 add r0, r0, #24 <== NOT EXECUTED 30007580: e1a0e00f mov lr, pc <== NOT EXECUTED 30007584: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED
}
30007588: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
3000758c: eb002f5d bl 30013308 <__errno> <== NOT EXECUTED
30007590: e3a03009 mov r3, #9 <== NOT EXECUTED
30007594: e5803000 str r3, [r0] <== NOT EXECUTED
30007598: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000759c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
300075a0: eb002f58 bl 30013308 <__errno> <== NOT EXECUTED
300075a4: e3a03016 mov r3, #22 <== NOT EXECUTED
300075a8: e5803000 str r3, [r0] <== NOT EXECUTED
300075ac: e3e00000 mvn r0, #0 <== NOT EXECUTED
300075b0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006e28 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
30006e28: e92d000e push {r1, r2, r3}
30006e2c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006e30: e59f31cc ldr r3, [pc, #460] ; 30007004 <fcntl+0x1dc>
int fcntl(
int fd,
int cmd,
...
)
{
30006e34: e24dd004 sub sp, sp, #4
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006e38: e5932000 ldr r2, [r3]
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
30006e3c: e28d3028 add r3, sp, #40 ; 0x28
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006e40: e1500002 cmp r0, r2
int fcntl(
int fd,
int cmd,
...
)
{
30006e44: e59d4024 ldr r4, [sp, #36] ; 0x24
int ret; va_list ap; va_start( ap, cmd );
30006e48: e58d3000 str r3, [sp]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006e4c: 2a000060 bcs 30006fd4 <fcntl+0x1ac>
iop = rtems_libio_iop( fd );
30006e50: e59f71b0 ldr r7, [pc, #432] ; 30007008 <fcntl+0x1e0> 30006e54: e0600180 rsb r0, r0, r0, lsl #3 30006e58: e5976000 ldr r6, [r7] 30006e5c: e0865180 add r5, r6, r0, lsl #3
rtems_libio_check_is_open(iop);
30006e60: e595c014 ldr ip, [r5, #20] 30006e64: e31c0c01 tst ip, #256 ; 0x100
30006e68: 0a000059 beq 30006fd4 <fcntl+0x1ac>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
30006e6c: e3540009 cmp r4, #9 30006e70: 979ff104 ldrls pc, [pc, r4, lsl #2] 30006e74: ea000027 b 30006f18 <fcntl+0xf0> 30006e78: 30006f28 .word 0x30006f28 30006e7c: 30006f8c .word 0x30006f8c 30006e80: 30006f9c .word 0x30006f9c 30006e84: 30006fbc .word 0x30006fbc 30006e88: 30006ec4 .word 0x30006ec4 30006e8c: 30006ea0 .word 0x30006ea0 30006e90: 30006ea0 .word 0x30006ea0 30006e94: 30006ea0 .word 0x30006ea0 30006e98: 30006ea0 .word 0x30006ea0 30006e9c: 30006ea0 .word 0x30006ea0
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
30006ea0: eb003099 bl 3001310c <__errno> 30006ea4: e3a03086 mov r3, #134 ; 0x86 30006ea8: e5803000 str r3, [r0]
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30006eac: e3e06000 mvn r6, #0
va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; }
30006eb0: e1a00006 mov r0, r6
30006eb4: e28dd004 add sp, sp, #4
30006eb8: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
30006ebc: e28dd00c add sp, sp, #12
30006ec0: e12fff1e bx lr
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
30006ec4: e5930000 ldr r0, [r3] 30006ec8: eb000181 bl 300074d4 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
30006ecc: e5952014 ldr r2, [r5, #20] 30006ed0: e59f3134 ldr r3, [pc, #308] ; 3000700c <fcntl+0x1e4> 30006ed4: e3c22c02 bic r2, r2, #512 ; 0x200 30006ed8: e0003003 and r3, r0, r3 30006edc: e3c22001 bic r2, r2, #1 30006ee0: e1833002 orr r3, r3, r2 30006ee4: e5853014 str r3, [r5, #20]
rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0;
30006ee8: e3a06000 mov r6, #0
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
30006eec: e1a00004 mov r0, r4 30006ef0: e5953020 ldr r3, [r5, #32] 30006ef4: e1a01005 mov r1, r5 30006ef8: e1a0e00f mov lr, pc 30006efc: e593f030 ldr pc, [r3, #48] ; 0x30
if (err) {
30006f00: e2504000 subs r4, r0, #0
30006f04: 0affffe9 beq 30006eb0 <fcntl+0x88>
errno = err;
30006f08: eb00307f bl 3001310c <__errno> <== NOT EXECUTED
ret = -1;
30006f0c: e3e06000 mvn r6, #0 <== NOT EXECUTED
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
if (err) {
errno = err;
30006f10: e5804000 str r4, [r0] <== NOT EXECUTED 30006f14: eaffffe5 b 30006eb0 <fcntl+0x88> <== NOT EXECUTED
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
30006f18: eb00307b bl 3001310c <__errno> 30006f1c: e3a03016 mov r3, #22 30006f20: e5803000 str r3, [r0] 30006f24: eaffffe0 b 30006eac <fcntl+0x84>
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
30006f28: e593a000 ldr sl, [r3] <== NOT EXECUTED
if ( fd2 )
30006f2c: e35a0000 cmp sl, #0 <== NOT EXECUTED 30006f30: 0a00002c beq 30006fe8 <fcntl+0x1c0> <== NOT EXECUTED
diop = rtems_libio_iop( fd2 );
30006f34: e152000a cmp r2, sl <== NOT EXECUTED 30006f38: 806aa18a rsbhi sl, sl, sl, lsl #3 <== NOT EXECUTED 30006f3c: 8086a18a addhi sl, r6, sl, lsl #3 <== NOT EXECUTED 30006f40: 81a0900a movhi r9, sl <== NOT EXECUTED 30006f44: 93a09000 movls r9, #0 <== NOT EXECUTED 30006f48: 91a0a009 movls sl, r9 <== NOT EXECUTED
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
30006f4c: e28a8018 add r8, sl, #24 <== NOT EXECUTED
30006f50: e2857018 add r7, r5, #24 <== NOT EXECUTED
30006f54: e8b7000f ldm r7!, {r0, r1, r2, r3} <== NOT EXECUTED
ret = (int) (diop - rtems_libio_iops);
30006f58: e0666009 rsb r6, r6, r9 <== NOT EXECUTED
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
30006f5c: e8a8000f stmia r8!, {r0, r1, r2, r3} <== NOT EXECUTED
ret = (int) (diop - rtems_libio_iops);
30006f60: e1a061c6 asr r6, r6, #3 <== NOT EXECUTED 30006f64: e0863186 add r3, r6, r6, lsl #3 <== NOT EXECUTED 30006f68: e0833303 add r3, r3, r3, lsl #6 <== NOT EXECUTED 30006f6c: e0863183 add r3, r6, r3, lsl #3 <== NOT EXECUTED
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
30006f70: e5972000 ldr r2, [r7] <== NOT EXECUTED
ret = (int) (diop - rtems_libio_iops);
30006f74: e0833783 add r3, r3, r3, lsl #15 <== NOT EXECUTED 30006f78: e0866183 add r6, r6, r3, lsl #3 <== NOT EXECUTED
ret = -1;
break;
}
}
diop->flags = iop->flags;
30006f7c: e58ac014 str ip, [sl, #20] <== NOT EXECUTED
diop->pathinfo = iop->pathinfo;
30006f80: e5882000 str r2, [r8] <== NOT EXECUTED
ret = (int) (diop - rtems_libio_iops);
30006f84: e2666000 rsb r6, r6, #0 <== NOT EXECUTED 30006f88: ea00000e b 30006fc8 <fcntl+0x1a0> <== NOT EXECUTED
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
30006f8c: e31c0b02 tst ip, #2048 ; 0x800 30006f90: 03a06000 moveq r6, #0 30006f94: 13a06001 movne r6, #1 30006f98: eaffffd3 b 30006eec <fcntl+0xc4>
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
30006f9c: e5936000 ldr r6, [r3] 30006fa0: e3560000 cmp r6, #0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
30006fa4: 138ccb02 orrne ip, ip, #2048 ; 0x800
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
30006fa8: 03cccb02 biceq ip, ip, #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;
30006fac: 1585c014 strne ip, [r5, #20]
rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0;
30006fb0: 13a06000 movne r6, #0
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
30006fb4: 0585c014 streq ip, [r5, #20] 30006fb8: eaffffcb b 30006eec <fcntl+0xc4>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
30006fbc: e1a0000c mov r0, ip 30006fc0: eb000150 bl 30007508 <rtems_libio_to_fcntl_flags> 30006fc4: e1a06000 mov r6, r0
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
30006fc8: e3560000 cmp r6, #0
30006fcc: aaffffc6 bge 30006eec <fcntl+0xc4>
30006fd0: eaffffb6 b 30006eb0 <fcntl+0x88> <== NOT EXECUTED
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30006fd4: eb00304c bl 3001310c <__errno> <== NOT EXECUTED 30006fd8: e3a03009 mov r3, #9 <== NOT EXECUTED 30006fdc: e5803000 str r3, [r0] <== NOT EXECUTED 30006fe0: e3e06000 mvn r6, #0 <== NOT EXECUTED 30006fe4: eaffffb1 b 30006eb0 <fcntl+0x88> <== NOT EXECUTED
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
30006fe8: eb000159 bl 30007554 <rtems_libio_allocate> <== NOT EXECUTED
if ( diop == 0 ) {
30006fec: e250a000 subs sl, r0, #0 <== NOT EXECUTED 30006ff0: 0affffad beq 30006eac <fcntl+0x84> <== NOT EXECUTED 30006ff4: e595c014 ldr ip, [r5, #20] <== NOT EXECUTED 30006ff8: e1a0900a mov r9, sl <== NOT EXECUTED 30006ffc: e5976000 ldr r6, [r7] <== NOT EXECUTED 30007000: eaffffd1 b 30006f4c <fcntl+0x124> <== NOT EXECUTED
30007020 <fdatasync>:
int fd
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007020: e59f3068 ldr r3, [pc, #104] ; 30007090 <fdatasync+0x70> <== NOT EXECUTED
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
30007024: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007028: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000702c: e1500003 cmp r0, r3 <== NOT EXECUTED 30007030: 2a00000c bcs 30007068 <fdatasync+0x48> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
30007034: e59f3058 ldr r3, [pc, #88] ; 30007094 <fdatasync+0x74> <== NOT EXECUTED 30007038: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 3000703c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007040: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
30007044: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 30007048: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3000704c: 0a000005 beq 30007068 <fdatasync+0x48> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007050: e3130004 tst r3, #4 <== NOT EXECUTED 30007054: 0a000008 beq 3000707c <fdatasync+0x5c> <== NOT EXECUTED
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
30007058: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 3000705c: e1a0e00f mov lr, pc <== NOT EXECUTED 30007060: e593f02c ldr pc, [r3, #44] ; 0x2c <== NOT EXECUTED
}
30007064: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30007068: eb003027 bl 3001310c <__errno> <== NOT EXECUTED
3000706c: e3a03009 mov r3, #9 <== NOT EXECUTED
30007070: e5803000 str r3, [r0] <== NOT EXECUTED
30007074: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007078: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000707c: eb003022 bl 3001310c <__errno> <== NOT EXECUTED
30007080: e3a03016 mov r3, #22 <== NOT EXECUTED
30007084: e5803000 str r3, [r0] <== NOT EXECUTED
30007088: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000708c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300108f0 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
300108f0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
300108f4: e59f5460 ldr r5, [pc, #1120] ; 30010d5c <fifo_open+0x46c> <== NOT EXECUTED
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
300108f8: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
300108fc: e5958000 ldr r8, [r5] <== NOT EXECUTED
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
30010900: e1a04000 mov r4, r0 <== NOT EXECUTED
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
30010904: e3580000 cmp r8, #0 <== NOT EXECUTED
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
30010908: e1a06001 mov r6, r1 <== NOT EXECUTED
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
3001090c: 0a000024 beq 300109a4 <fifo_open+0xb4> <== NOT EXECUTED
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30010910: e3a01000 mov r1, #0 <== NOT EXECUTED 30010914: e1a00008 mov r0, r8 <== NOT EXECUTED 30010918: e1a02001 mov r2, r1 <== NOT EXECUTED 3001091c: ebffed5e bl 3000be9c <rtems_semaphore_obtain> <== NOT EXECUTED
}
if (sc == RTEMS_SUCCESSFUL) {
30010920: e250a000 subs sl, r0, #0 <== NOT EXECUTED 30010924: 1a0000e1 bne 30010cb0 <fifo_open+0x3c0> <== NOT EXECUTED
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
30010928: e5945000 ldr r5, [r4] <== NOT EXECUTED
if (pipe == NULL) {
3001092c: e3550000 cmp r5, #0 <== NOT EXECUTED 30010930: 0a00007f beq 30010b34 <fifo_open+0x244> <== NOT EXECUTED
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
30010934: e3a01000 mov r1, #0 <== NOT EXECUTED 30010938: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 3001093c: e1a02001 mov r2, r1 <== NOT EXECUTED 30010940: ebffed55 bl 3000be9c <rtems_semaphore_obtain> <== NOT EXECUTED
err = -EINTR;
if (*pipep == NULL) {
30010944: e5943000 ldr r3, [r4] <== NOT EXECUTED
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
30010948: e3500000 cmp r0, #0 <== NOT EXECUTED 3001094c: 01a07000 moveq r7, r0 <== NOT EXECUTED 30010950: 13e07003 mvnne r7, #3 <== NOT EXECUTED
err = -EINTR;
if (*pipep == NULL) {
30010954: e3530000 cmp r3, #0 <== NOT EXECUTED 30010958: 0a0000c4 beq 30010c70 <fifo_open+0x380> <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
3001095c: ebffffa9 bl 30010808 <pipe_unlock> <== NOT EXECUTED
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
30010960: e3570000 cmp r7, #0 <== NOT EXECUTED 30010964: 1a00000b bne 30010998 <fifo_open+0xa8> <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
30010968: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
3001096c: e5945000 ldr r5, [r4] <== NOT EXECUTED
switch (LIBIO_ACCMODE(iop)) {
30010970: e2033006 and r3, r3, #6 <== NOT EXECUTED 30010974: e3530004 cmp r3, #4 <== NOT EXECUTED 30010978: 0a000015 beq 300109d4 <fifo_open+0xe4> <== NOT EXECUTED 3001097c: e3530006 cmp r3, #6 <== NOT EXECUTED 30010980: 0a000057 beq 30010ae4 <fifo_open+0x1f4> <== NOT EXECUTED 30010984: e3530002 cmp r3, #2 <== NOT EXECUTED 30010988: 0a000035 beq 30010a64 <fifo_open+0x174> <== NOT EXECUTED
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
3001098c: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010990: ebffed8a bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
return 0;
30010994: e3a07000 mov r7, #0 <== NOT EXECUTED
out_error:
pipe_release(pipep, iop);
return err;
}
30010998: e1a00007 mov r0, r7 <== NOT EXECUTED
3001099c: e28dd00c add sp, sp, #12 <== NOT EXECUTED
300109a0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
300109a4: e59f73b4 ldr r7, [pc, #948] ; 30010d60 <fifo_open+0x470> <== NOT EXECUTED 300109a8: e1a01008 mov r1, r8 <== NOT EXECUTED 300109ac: e5970000 ldr r0, [r7] <== NOT EXECUTED 300109b0: e1a02008 mov r2, r8 <== NOT EXECUTED 300109b4: ebffed38 bl 3000be9c <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
300109b8: e5953000 ldr r3, [r5] <== NOT EXECUTED 300109bc: e3530000 cmp r3, #0 <== NOT EXECUTED 300109c0: 0a0000af beq 30010c84 <fifo_open+0x394> <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
300109c4: e5970000 ldr r0, [r7] <== NOT EXECUTED 300109c8: ebffed7c bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED 300109cc: e5958000 ldr r8, [r5] <== NOT EXECUTED 300109d0: eaffffce b 30010910 <fifo_open+0x20> <== NOT EXECUTED
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
300109d4: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
300109d8: e5951024 ldr r1, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
300109dc: e2832001 add r2, r3, #1 <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
300109e0: e2811001 add r1, r1, #1 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
300109e4: e3530000 cmp r3, #0 <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
300109e8: e5851024 str r1, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
300109ec: e5852014 str r2, [r5, #20] <== NOT EXECUTED 300109f0: 0a0000b0 beq 30010cb8 <fifo_open+0x3c8> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
300109f4: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED 300109f8: e3530000 cmp r3, #0 <== NOT EXECUTED 300109fc: 1affffe2 bne 3001098c <fifo_open+0x9c> <== NOT EXECUTED 30010a00: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 30010a04: e3130001 tst r3, #1 <== NOT EXECUTED
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
30010a08: 05957020 ldreq r7, [r5, #32] <== NOT EXECUTED
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
30010a0c: 0a000007 beq 30010a30 <fifo_open+0x140> <== NOT EXECUTED 30010a10: ea0000c0 b 30010d18 <fifo_open+0x428> <== NOT EXECUTED
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
30010a14: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010a18: ebffed1f bl 3000be9c <rtems_semaphore_obtain> <== NOT EXECUTED 30010a1c: e3500000 cmp r0, #0 <== NOT EXECUTED 30010a20: 1a00000a bne 30010a50 <fifo_open+0x160> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
30010a24: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 30010a28: e1530007 cmp r3, r7 <== NOT EXECUTED 30010a2c: 1affffd6 bne 3001098c <fifo_open+0x9c> <== NOT EXECUTED
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
30010a30: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010a34: ebffed61 bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
30010a38: e3a01000 mov r1, #0 <== NOT EXECUTED 30010a3c: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010a40: eb00071f bl 300126c4 <rtems_barrier_wait> <== NOT EXECUTED 30010a44: e2501000 subs r1, r0, #0 <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
30010a48: e1a02001 mov r2, r1 <== NOT EXECUTED
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
30010a4c: 0afffff0 beq 30010a14 <fifo_open+0x124> <== NOT EXECUTED
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
30010a50: e3e07003 mvn r7, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
30010a54: e1a00004 mov r0, r4 <== NOT EXECUTED 30010a58: e1a01006 mov r1, r6 <== NOT EXECUTED 30010a5c: ebffff6d bl 30010818 <pipe_release> <== NOT EXECUTED
return err;
30010a60: eaffffcc b 30010998 <fifo_open+0xa8> <== NOT EXECUTED
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
30010a64: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
30010a68: e5951020 ldr r1, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
30010a6c: e2832001 add r2, r3, #1 <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
30010a70: e2811001 add r1, r1, #1 <== NOT EXECUTED
if (pipe->Readers ++ == 0)
30010a74: e3530000 cmp r3, #0 <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
30010a78: e5851020 str r1, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
30010a7c: e5852010 str r2, [r5, #16] <== NOT EXECUTED 30010a80: 0a000094 beq 30010cd8 <fifo_open+0x3e8> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
30010a84: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 30010a88: e3530000 cmp r3, #0 <== NOT EXECUTED 30010a8c: 1affffbe bne 3001098c <fifo_open+0x9c> <== NOT EXECUTED
/* Not an error */
if (LIBIO_NODELAY(iop))
30010a90: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 30010a94: e3130001 tst r3, #1 <== NOT EXECUTED 30010a98: 1affffbb bne 3001098c <fifo_open+0x9c> <== NOT EXECUTED
break;
prevCounter = pipe->writerCounter;
30010a9c: e5957024 ldr r7, [r5, #36] ; 0x24 <== NOT EXECUTED 30010aa0: ea000006 b 30010ac0 <fifo_open+0x1d0> <== NOT EXECUTED
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
30010aa4: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010aa8: ebffecfb bl 3000be9c <rtems_semaphore_obtain> <== NOT EXECUTED 30010aac: e3500000 cmp r0, #0 <== NOT EXECUTED 30010ab0: 1affffe6 bne 30010a50 <fifo_open+0x160> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
30010ab4: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED 30010ab8: e1530007 cmp r3, r7 <== NOT EXECUTED 30010abc: 1affffb2 bne 3001098c <fifo_open+0x9c> <== NOT EXECUTED
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
30010ac0: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010ac4: ebffed3d bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
30010ac8: e3a01000 mov r1, #0 <== NOT EXECUTED 30010acc: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 30010ad0: eb0006fb bl 300126c4 <rtems_barrier_wait> <== NOT EXECUTED 30010ad4: e2501000 subs r1, r0, #0 <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
30010ad8: e1a02001 mov r2, r1 <== NOT EXECUTED
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
30010adc: 0afffff0 beq 30010aa4 <fifo_open+0x1b4> <== NOT EXECUTED 30010ae0: eaffffda b 30010a50 <fifo_open+0x160> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
30010ae4: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
30010ae8: e5951020 ldr r1, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
30010aec: e2832001 add r2, r3, #1 <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
30010af0: e2811001 add r1, r1, #1 <== NOT EXECUTED
if (pipe->Readers ++ == 0)
30010af4: e3530000 cmp r3, #0 <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
30010af8: e5851020 str r1, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
30010afc: e5852010 str r2, [r5, #16] <== NOT EXECUTED 30010b00: 0a000070 beq 30010cc8 <fifo_open+0x3d8> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
30010b04: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
30010b08: e5951024 ldr r1, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
30010b0c: e2832001 add r2, r3, #1 <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
30010b10: e2811001 add r1, r1, #1 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
30010b14: e3530000 cmp r3, #0 <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
30010b18: e5851024 str r1, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
30010b1c: e5852014 str r2, [r5, #20] <== NOT EXECUTED 30010b20: 1affff99 bne 3001098c <fifo_open+0x9c> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
30010b24: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 30010b28: e28d1008 add r1, sp, #8 <== NOT EXECUTED 30010b2c: eb0006cc bl 30012664 <rtems_barrier_release> <== NOT EXECUTED 30010b30: eaffff95 b 3001098c <fifo_open+0x9c> <== NOT EXECUTED
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
30010b34: e3a00034 mov r0, #52 ; 0x34 <== NOT EXECUTED 30010b38: ebffdfc6 bl 30008a58 <malloc> <== NOT EXECUTED
if (pipe == NULL)
30010b3c: e3500000 cmp r0, #0 <== NOT EXECUTED
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
30010b40: e1a05000 mov r5, r0 <== NOT EXECUTED 30010b44: e1a08000 mov r8, r0 <== NOT EXECUTED
if (pipe == NULL)
30010b48: 0a00007e beq 30010d48 <fifo_open+0x458> <== NOT EXECUTED
return err;
memset(pipe, 0, sizeof(pipe_control_t));
30010b4c: e1a02000 mov r2, r0 <== NOT EXECUTED 30010b50: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010b54: e2822004 add r2, r2, #4 <== NOT EXECUTED 30010b58: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010b5c: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010b60: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010b64: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010b68: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010b6c: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010b70: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010b74: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010b78: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010b7c: e482a004 str sl, [r2], #4 <== NOT EXECUTED
pipe->Size = PIPE_BUF;
30010b80: e3a03c02 mov r3, #512 ; 0x200 <== NOT EXECUTED
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
30010b84: e582a000 str sl, [r2] <== NOT EXECUTED
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
30010b88: e1a00003 mov r0, r3 <== NOT EXECUTED
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
30010b8c: e5853004 str r3, [r5, #4] <== NOT EXECUTED
pipe->Buffer = malloc(pipe->Size);
30010b90: ebffdfb0 bl 30008a58 <malloc> <== NOT EXECUTED
if (! pipe->Buffer)
30010b94: e3500000 cmp r0, #0 <== NOT EXECUTED
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
30010b98: e5850000 str r0, [r5] <== NOT EXECUTED
if (! pipe->Buffer)
30010b9c: 0a000067 beq 30010d40 <fifo_open+0x450> <== NOT EXECUTED
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
30010ba0: e59f71bc ldr r7, [pc, #444] ; 30010d64 <fifo_open+0x474> <== NOT EXECUTED
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
30010ba4: e59f01bc ldr r0, [pc, #444] ; 30010d68 <fifo_open+0x478> <== NOT EXECUTED
rtems_build_name ('P', 'I', 'r', c),
30010ba8: e5d73000 ldrb r3, [r7] <== NOT EXECUTED
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
30010bac: e1a0100a mov r1, sl <== NOT EXECUTED 30010bb0: e1830000 orr r0, r3, r0 <== NOT EXECUTED 30010bb4: e1a0200a mov r2, sl <== NOT EXECUTED 30010bb8: e285302c add r3, r5, #44 ; 0x2c <== NOT EXECUTED 30010bbc: eb00064a bl 300124ec <rtems_barrier_create> <== NOT EXECUTED 30010bc0: e2501000 subs r1, r0, #0 <== NOT EXECUTED 30010bc4: 1a00005b bne 30010d38 <fifo_open+0x448> <== NOT EXECUTED
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
30010bc8: e5d73000 ldrb r3, [r7] <== NOT EXECUTED
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(
30010bcc: e59f0198 ldr r0, [pc, #408] ; 30010d6c <fifo_open+0x47c> <== NOT EXECUTED 30010bd0: e1a02001 mov r2, r1 <== NOT EXECUTED 30010bd4: e1830000 orr r0, r3, r0 <== NOT EXECUTED 30010bd8: e2853030 add r3, r5, #48 ; 0x30 <== NOT EXECUTED 30010bdc: eb000642 bl 300124ec <rtems_barrier_create> <== NOT EXECUTED 30010be0: e2503000 subs r3, r0, #0 <== NOT EXECUTED 30010be4: 1a000051 bne 30010d30 <fifo_open+0x440> <== NOT EXECUTED
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
rtems_build_name ('P', 'I', 's', c), 1,
30010be8: e5d72000 ldrb r2, [r7] <== NOT EXECUTED
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(
30010bec: e59f017c ldr r0, [pc, #380] ; 30010d70 <fifo_open+0x480> <== NOT EXECUTED 30010bf0: e285c028 add ip, r5, #40 ; 0x28 <== NOT EXECUTED 30010bf4: e1820000 orr r0, r2, r0 <== NOT EXECUTED 30010bf8: e3a01001 mov r1, #1 <== NOT EXECUTED 30010bfc: e3a02010 mov r2, #16 <== NOT EXECUTED 30010c00: e58dc000 str ip, [sp] <== NOT EXECUTED 30010c04: ebffec0a bl 3000bc34 <rtems_semaphore_create> <== NOT EXECUTED 30010c08: e3500000 cmp r0, #0 <== NOT EXECUTED 30010c0c: 1a000045 bne 30010d28 <fifo_open+0x438> <== NOT EXECUTED
/* 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
30010c10: e28d8004 add r8, sp, #4 <== NOT EXECUTED
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
30010c14: e595102c ldr r1, [r5, #44] ; 0x2c <== NOT EXECUTED 30010c18: e1a02008 mov r2, r8 <== NOT EXECUTED 30010c1c: e59f0150 ldr r0, [pc, #336] ; 30010d74 <fifo_open+0x484> <== NOT EXECUTED 30010c20: ebfff296 bl 3000d680 <_Objects_Get> <== NOT EXECUTED
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
30010c24: e590304c ldr r3, [r0, #76] ; 0x4c <== NOT EXECUTED 30010c28: e3833201 orr r3, r3, #268435456 ; 0x10000000 <== NOT EXECUTED 30010c2c: e580304c str r3, [r0, #76] ; 0x4c <== NOT EXECUTED
_Thread_Enable_dispatch();
30010c30: ebfff5d9 bl 3000e39c <_Thread_Enable_dispatch> <== NOT EXECUTED 30010c34: e1a02008 mov r2, r8 <== NOT EXECUTED 30010c38: e5951030 ldr r1, [r5, #48] ; 0x30 <== NOT EXECUTED 30010c3c: e59f0130 ldr r0, [pc, #304] ; 30010d74 <fifo_open+0x484> <== NOT EXECUTED 30010c40: ebfff28e bl 3000d680 <_Objects_Get> <== NOT EXECUTED
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
30010c44: e590304c ldr r3, [r0, #76] ; 0x4c <== NOT EXECUTED 30010c48: e3833201 orr r3, r3, #268435456 ; 0x10000000 <== NOT EXECUTED 30010c4c: e580304c str r3, [r0, #76] ; 0x4c <== NOT EXECUTED
_Thread_Enable_dispatch();
30010c50: ebfff5d1 bl 3000e39c <_Thread_Enable_dispatch> <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
30010c54: e5d73000 ldrb r3, [r7] <== NOT EXECUTED 30010c58: e353007a cmp r3, #122 ; 0x7a <== NOT EXECUTED 30010c5c: e2832001 add r2, r3, #1 <== NOT EXECUTED
c = 'a';
30010c60: 03a03061 moveq r3, #97 ; 0x61 <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
30010c64: e5c72000 strb r2, [r7] <== NOT EXECUTED
c = 'a';
30010c68: 05c73000 strbeq r3, [r7] <== NOT EXECUTED 30010c6c: eaffff30 b 30010934 <fifo_open+0x44> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
30010c70: e3570000 cmp r7, #0 <== NOT EXECUTED 30010c74: 1a00001b bne 30010ce8 <fifo_open+0x3f8> <== NOT EXECUTED
pipe_free(pipe);
else
*pipep = pipe;
30010c78: e5845000 str r5, [r4] <== NOT EXECUTED
}
out:
pipe_unlock();
30010c7c: ebfffee1 bl 30010808 <pipe_unlock> <== NOT EXECUTED 30010c80: eaffff38 b 30010968 <fifo_open+0x78> <== NOT EXECUTED
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
30010c84: e1a03008 mov r3, r8 <== NOT EXECUTED 30010c88: e3a01001 mov r1, #1 <== NOT EXECUTED 30010c8c: e3a02054 mov r2, #84 ; 0x54 <== NOT EXECUTED 30010c90: e59f00e0 ldr r0, [pc, #224] ; 30010d78 <fifo_open+0x488> <== NOT EXECUTED 30010c94: e58d5000 str r5, [sp] <== NOT EXECUTED 30010c98: ebffebe5 bl 3000bc34 <rtems_semaphore_create> <== NOT EXECUTED 30010c9c: e1a08000 mov r8, r0 <== NOT EXECUTED 30010ca0: e5970000 ldr r0, [r7] <== NOT EXECUTED 30010ca4: ebffecc5 bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
30010ca8: e3580000 cmp r8, #0 <== NOT EXECUTED 30010cac: 0a000028 beq 30010d54 <fifo_open+0x464> <== NOT EXECUTED
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
30010cb0: e3e0700b mvn r7, #11 <== NOT EXECUTED 30010cb4: eaffff37 b 30010998 <fifo_open+0xa8> <== NOT EXECUTED
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
30010cb8: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 30010cbc: e28d1008 add r1, sp, #8 <== NOT EXECUTED 30010cc0: eb000667 bl 30012664 <rtems_barrier_release> <== NOT EXECUTED 30010cc4: eaffff4a b 300109f4 <fifo_open+0x104> <== NOT EXECUTED
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
30010cc8: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010ccc: e28d1008 add r1, sp, #8 <== NOT EXECUTED 30010cd0: eb000663 bl 30012664 <rtems_barrier_release> <== NOT EXECUTED 30010cd4: eaffff8a b 30010b04 <fifo_open+0x214> <== NOT EXECUTED
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
30010cd8: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010cdc: e28d1008 add r1, sp, #8 <== NOT EXECUTED 30010ce0: eb00065f bl 30012664 <rtems_barrier_release> <== NOT EXECUTED 30010ce4: eaffff66 b 30010a84 <fifo_open+0x194> <== NOT EXECUTED
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
30010ce8: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 30010cec: eb000630 bl 300125b4 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
30010cf0: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010cf4: eb00062e bl 300125b4 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
30010cf8: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010cfc: ebffec3d bl 3000bdf8 <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
30010d00: e5950000 ldr r0, [r5] <== NOT EXECUTED 30010d04: ebffdd39 bl 300081f0 <free> <== NOT EXECUTED
free(pipe);
30010d08: e1a00005 mov r0, r5 <== NOT EXECUTED 30010d0c: ebffdd37 bl 300081f0 <free> <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
30010d10: ebfffebc bl 30010808 <pipe_unlock> <== NOT EXECUTED 30010d14: eaffff1f b 30010998 <fifo_open+0xa8> <== NOT EXECUTED
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
30010d18: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010d1c: ebffeca7 bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
err = -ENXIO;
30010d20: e3e07005 mvn r7, #5 <== NOT EXECUTED
goto out_error;
30010d24: eaffff4a b 30010a54 <fifo_open+0x164> <== NOT EXECUTED
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
30010d28: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010d2c: eb000620 bl 300125b4 <rtems_barrier_delete> <== NOT EXECUTED
err_wbar: rtems_barrier_delete(pipe->readBarrier);
30010d30: e598002c ldr r0, [r8, #44] ; 0x2c <== NOT EXECUTED 30010d34: eb00061e bl 300125b4 <rtems_barrier_delete> <== NOT EXECUTED
err_rbar: free(pipe->Buffer);
30010d38: e5980000 ldr r0, [r8] <== NOT EXECUTED 30010d3c: ebffdd2b bl 300081f0 <free> <== NOT EXECUTED
err_buf: free(pipe);
30010d40: e1a00008 mov r0, r8 <== NOT EXECUTED 30010d44: ebffdd29 bl 300081f0 <free> <== NOT EXECUTED
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
30010d48: e3e0700b mvn r7, #11 <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
30010d4c: ebfffead bl 30010808 <pipe_unlock> <== NOT EXECUTED 30010d50: eaffff10 b 30010998 <fifo_open+0xa8> <== NOT EXECUTED
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
30010d54: e5958000 ldr r8, [r5] <== NOT EXECUTED 30010d58: eafffeec b 30010910 <fifo_open+0x20> <== NOT EXECUTED
3000655c <flockfile>:
#include <stdio.h>
/* This is a non-functional stub */
void flockfile(FILE* file)
{
}
3000655c: e12fff1e bx lr <== NOT EXECUTED
30009978 <fork>:
#include <sys/types.h>
#include <errno.h>
#include <rtems/seterr.h>
int fork( void )
{
30009978: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
3000997c: eb002415 bl 300129d8 <__errno> <== NOT EXECUTED 30009980: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009984: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009988: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000998c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007098 <fpathconf>:
{
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
30007098: e59f310c ldr r3, [pc, #268] ; 300071ac <fpathconf+0x114> <== NOT EXECUTED
long fpathconf(
int fd,
int name
)
{
3000709c: 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);
300070a0: e5933000 ldr r3, [r3] <== NOT EXECUTED 300070a4: e1500003 cmp r0, r3 <== NOT EXECUTED 300070a8: 2a000035 bcs 30007184 <fpathconf+0xec> <== NOT EXECUTED
iop = rtems_libio_iop(fd);
300070ac: e59f30fc ldr r3, [pc, #252] ; 300071b0 <fpathconf+0x118> <== NOT EXECUTED 300070b0: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 300070b4: e5933000 ldr r3, [r3] <== NOT EXECUTED 300070b8: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
300070bc: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 300070c0: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300070c4: 0a00002e beq 30007184 <fpathconf+0xec> <== NOT EXECUTED
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
300070c8: e3130002 tst r3, #2 <== NOT EXECUTED 300070cc: 0a000031 beq 30007198 <fpathconf+0x100> <== NOT EXECUTED
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
300070d0: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
switch ( name ) {
300070d4: e351000b cmp r1, #11 <== NOT EXECUTED 300070d8: 979ff101 ldrls pc, [pc, r1, lsl #2] <== NOT EXECUTED 300070dc: ea00000d b 30007118 <fpathconf+0x80> <== NOT EXECUTED 300070e0: 3000712c .word 0x3000712c <== NOT EXECUTED 300070e4: 30007134 .word 0x30007134 <== NOT EXECUTED 300070e8: 3000713c .word 0x3000713c <== NOT EXECUTED 300070ec: 30007144 .word 0x30007144 <== NOT EXECUTED 300070f0: 3000714c .word 0x3000714c <== NOT EXECUTED 300070f4: 30007154 .word 0x30007154 <== NOT EXECUTED 300070f8: 3000715c .word 0x3000715c <== NOT EXECUTED 300070fc: 30007164 .word 0x30007164 <== NOT EXECUTED 30007100: 3000716c .word 0x3000716c <== NOT EXECUTED 30007104: 30007174 .word 0x30007174 <== NOT EXECUTED 30007108: 3000717c .word 0x3000717c <== NOT EXECUTED 3000710c: 30007110 .word 0x30007110 <== NOT EXECUTED
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
30007110: e5930060 ldr r0, [r3, #96] ; 0x60 <== NOT EXECUTED
break;
30007114: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30007118: eb002ffb bl 3001310c <__errno> <== NOT EXECUTED 3000711c: e3a03016 mov r3, #22 <== NOT EXECUTED 30007120: e5803000 str r3, [r0] <== NOT EXECUTED 30007124: e3e00000 mvn r0, #0 <== NOT EXECUTED
break;
}
return return_value;
}
30007128: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
3000712c: e5930038 ldr r0, [r3, #56] ; 0x38 <== NOT EXECUTED
break;
30007130: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
30007134: e593003c ldr r0, [r3, #60] ; 0x3c <== NOT EXECUTED
break;
30007138: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
3000713c: e5930040 ldr r0, [r3, #64] ; 0x40 <== NOT EXECUTED
break;
30007140: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_NAME_MAX:
return_value = the_limits->name_max;
30007144: e5930044 ldr r0, [r3, #68] ; 0x44 <== NOT EXECUTED
break;
30007148: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_PATH_MAX:
return_value = the_limits->path_max;
3000714c: e5930048 ldr r0, [r3, #72] ; 0x48 <== NOT EXECUTED
break;
30007150: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
30007154: e593004c ldr r0, [r3, #76] ; 0x4c <== NOT EXECUTED
break;
30007158: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
3000715c: e5930054 ldr r0, [r3, #84] ; 0x54 <== NOT EXECUTED
break;
30007160: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
30007164: e5930058 ldr r0, [r3, #88] ; 0x58 <== NOT EXECUTED
break;
30007168: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
3000716c: e5930064 ldr r0, [r3, #100] ; 0x64 <== NOT EXECUTED
break;
30007170: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
30007174: e5930050 ldr r0, [r3, #80] ; 0x50 <== NOT EXECUTED
break;
30007178: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
3000717c: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED
break;
30007180: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
30007184: eb002fe0 bl 3001310c <__errno> <== NOT EXECUTED
30007188: e3a03009 mov r3, #9 <== NOT EXECUTED
3000718c: e5803000 str r3, [r0] <== NOT EXECUTED
30007190: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007194: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
30007198: eb002fdb bl 3001310c <__errno> <== NOT EXECUTED
3000719c: e3a03016 mov r3, #22 <== NOT EXECUTED
300071a0: e5803000 str r3, [r0] <== NOT EXECUTED
300071a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300071a8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006498 <free>:
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
30006498: e59f3088 ldr r3, [pc, #136] ; 30006528 <free+0x90>
#include <stdlib.h>
void free(
void *ptr
)
{
3000649c: e92d4030 push {r4, r5, lr}
MSBUMP(free_calls, 1);
300064a0: e593200c ldr r2, [r3, #12]
if ( !ptr )
300064a4: e2504000 subs r4, r0, #0
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
300064a8: e2822001 add r2, r2, #1 300064ac: e583200c str r2, [r3, #12]
if ( !ptr )
300064b0: 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()) &&
300064b4: e59f3070 ldr r3, [pc, #112] ; 3000652c <free+0x94> 300064b8: e5933000 ldr r3, [r3] 300064bc: e3530003 cmp r3, #3
300064c0: 0a000012 beq 30006510 <free+0x78>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
300064c4: e59f3064 ldr r3, [pc, #100] ; 30006530 <free+0x98> 300064c8: e5933000 ldr r3, [r3] 300064cc: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_free)(ptr);
300064d0: 11a00004 movne r0, r4 300064d4: 11a0e00f movne lr, pc 300064d8: 1593f008 ldrne pc, [r3, #8]
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
300064dc: e59f5050 ldr r5, [pc, #80] ; 30006534 <free+0x9c>
300064e0: e1a01004 mov r1, r4
300064e4: e5950000 ldr r0, [r5]
300064e8: eb001474 bl 3000b6c0 <_Protected_heap_Free>
300064ec: e3500000 cmp r0, #0
300064f0: 18bd8030 popne {r4, r5, pc}
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
300064f4: 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",
300064f8: e59f0038 ldr r0, [pc, #56] ; 30006538 <free+0xa0> 300064fc: e5932018 ldr r2, [r3, #24] 30006500: e593301c ldr r3, [r3, #28] 30006504: e1a01004 mov r1, r4
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
30006508: 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",
3000650c: ea00037b b 30007300 <printk>
/*
* 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() ) {
30006510: eb00005e bl 30006690 <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()) &&
30006514: e3500000 cmp r0, #0
30006518: 1affffe9 bne 300064c4 <free+0x2c>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
3000651c: e1a00004 mov r0, r4 <== NOT EXECUTED
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
30006520: 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);
30006524: ea000076 b 30006704 <malloc_deferred_free> <== NOT EXECUTED
30007ba0 <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
30007ba0: e59f3028 ldr r3, [pc, #40] ; 30007bd0 <free_user_env+0x30> <== NOT EXECUTED
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
30007ba4: e92d4010 push {r4, lr} <== NOT EXECUTED
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
30007ba8: e1500003 cmp r0, r3 <== NOT EXECUTED
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
30007bac: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
30007bb0: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
30007bb4: e2800004 add r0, r0, #4 <== NOT EXECUTED 30007bb8: ebfffb7e bl 300069b8 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &env->root_directory);
30007bbc: e2840018 add r0, r4, #24 <== NOT EXECUTED 30007bc0: ebfffb7c bl 300069b8 <rtems_filesystem_freenode> <== NOT EXECUTED
free(env);
30007bc4: e1a00004 mov r0, r4 <== NOT EXECUTED
} }
30007bc8: e8bd4010 pop {r4, lr} <== NOT EXECUTED
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
30007bcc: eafffb7e b 300069cc <free> <== NOT EXECUTED
300176a0 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
300176a0: e92d4030 push {r4, r5, lr}
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
300176a4: e2514000 subs r4, r1, #0
300176a8: 0a000019 beq 30017714 <fstat+0x74>
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
300176ac: e59f3074 ldr r3, [pc, #116] ; 30017728 <fstat+0x88> 300176b0: e5933000 ldr r3, [r3] 300176b4: e1500003 cmp r0, r3
300176b8: 2a000010 bcs 30017700 <fstat+0x60>
300176bc: e59f3068 ldr r3, [pc, #104] ; 3001772c <fstat+0x8c> 300176c0: e0600180 rsb r0, r0, r0, lsl #3 300176c4: e5933000 ldr r3, [r3] 300176c8: e0835180 add r5, r3, r0, lsl #3
rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop);
300176cc: e5953014 ldr r3, [r5, #20] 300176d0: e3130c01 tst r3, #256 ; 0x100
300176d4: 0a000009 beq 30017700 <fstat+0x60>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
300176d8: e1a00004 mov r0, r4 300176dc: e3a01000 mov r1, #0 300176e0: e3a02048 mov r2, #72 ; 0x48 300176e4: ebffecc7 bl 30012a08 <memset>
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
300176e8: e5953020 ldr r3, [r5, #32] 300176ec: e2850018 add r0, r5, #24 300176f0: e1a01004 mov r1, r4 300176f4: e1a0e00f mov lr, pc 300176f8: e593f018 ldr pc, [r3, #24]
}
300176fc: e8bd8030 pop {r4, r5, pc}
/* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop);
30017700: ebffea5b bl 30012074 <__errno> <== NOT EXECUTED
30017704: e3a03009 mov r3, #9 <== NOT EXECUTED
30017708: e5803000 str r3, [r0] <== NOT EXECUTED
3001770c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30017710: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
30017714: ebffea56 bl 30012074 <__errno> <== NOT EXECUTED
30017718: e3a0300e mov r3, #14 <== NOT EXECUTED
3001771c: e5803000 str r3, [r0] <== NOT EXECUTED
30017720: e3e00000 mvn r0, #0 <== NOT EXECUTED
30017724: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30007308 <fsync>:
int fd
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007308: e59f3068 ldr r3, [pc, #104] ; 30007378 <fsync+0x70> <== NOT EXECUTED
#include <rtems/seterr.h>
int fsync(
int fd
)
{
3000730c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007310: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007314: e1500003 cmp r0, r3 <== NOT EXECUTED 30007318: 2a00000c bcs 30007350 <fsync+0x48> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
3000731c: e59f3058 ldr r3, [pc, #88] ; 3000737c <fsync+0x74> <== NOT EXECUTED 30007320: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 30007324: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007328: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
3000732c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 30007330: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007334: 0a000005 beq 30007350 <fsync+0x48> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007338: e3130004 tst r3, #4 <== NOT EXECUTED 3000733c: 0a000008 beq 30007364 <fsync+0x5c> <== NOT EXECUTED
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
30007340: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 30007344: e1a0e00f mov lr, pc <== NOT EXECUTED 30007348: e593f028 ldr pc, [r3, #40] ; 0x28 <== NOT EXECUTED
}
3000734c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30007350: eb002f6d bl 3001310c <__errno> <== NOT EXECUTED
30007354: e3a03009 mov r3, #9 <== NOT EXECUTED
30007358: e5803000 str r3, [r0] <== NOT EXECUTED
3000735c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007360: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007364: eb002f68 bl 3001310c <__errno> <== NOT EXECUTED
30007368: e3a03016 mov r3, #22 <== NOT EXECUTED
3000736c: e5803000 str r3, [r0] <== NOT EXECUTED
30007370: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007374: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000e644 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
3000e644: e92d4070 push {r4, r5, r6, lr}
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000e648: e59f30c8 ldr r3, [pc, #200] ; 3000e718 <ftruncate+0xd4>
int ftruncate(
int fd,
off_t length
)
{
3000e64c: e24dd014 sub sp, sp, #20
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000e650: e5933000 ldr r3, [r3]
int ftruncate(
int fd,
off_t length
)
{
3000e654: e1a05001 mov r5, r1
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000e658: e1500003 cmp r0, r3
int ftruncate(
int fd,
off_t length
)
{
3000e65c: e1a06002 mov r6, r2
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000e660: 2a00001d bcs 3000e6dc <ftruncate+0x98>
iop = rtems_libio_iop( fd );
3000e664: e59f30b0 ldr r3, [pc, #176] ; 3000e71c <ftruncate+0xd8> 3000e668: e0600180 rsb r0, r0, r0, lsl #3 3000e66c: e5933000 ldr r3, [r3] 3000e670: e0834180 add r4, r3, r0, lsl #3
rtems_libio_check_is_open(iop);
3000e674: e5943014 ldr r3, [r4, #20] 3000e678: e3130c01 tst r3, #256 ; 0x100
3000e67c: 0a000016 beq 3000e6dc <ftruncate+0x98>
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
3000e680: e1a0c00d mov ip, sp
3000e684: e284e018 add lr, r4, #24
3000e688: e8be000f ldm lr!, {r0, r1, r2, r3}
3000e68c: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000e690: e59e3000 ldr r3, [lr]
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
3000e694: e1a0000d mov r0, sp
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
3000e698: e58c3000 str r3, [ip]
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
3000e69c: e59d300c ldr r3, [sp, #12] 3000e6a0: e1a0e00f mov lr, pc 3000e6a4: e593f010 ldr pc, [r3, #16] 3000e6a8: e3500001 cmp r0, #1
3000e6ac: 0a000014 beq 3000e704 <ftruncate+0xc0>
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000e6b0: e5943014 ldr r3, [r4, #20] 3000e6b4: e3130004 tst r3, #4
3000e6b8: 0a00000c beq 3000e6f0 <ftruncate+0xac>
return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
3000e6bc: e5943020 ldr r3, [r4, #32] 3000e6c0: e1a00004 mov r0, r4 3000e6c4: e1a01005 mov r1, r5 3000e6c8: e1a02006 mov r2, r6 3000e6cc: e1a0e00f mov lr, pc 3000e6d0: e593f020 ldr pc, [r3, #32]
}
3000e6d4: e28dd014 add sp, sp, #20
3000e6d8: e8bd8070 pop {r4, r5, r6, pc}
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
3000e6dc: eb000e64 bl 30012074 <__errno> <== NOT EXECUTED 3000e6e0: e3a03009 mov r3, #9 <== NOT EXECUTED 3000e6e4: e5803000 str r3, [r0] <== NOT EXECUTED 3000e6e8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000e6ec: eafffff8 b 3000e6d4 <ftruncate+0x90> <== NOT EXECUTED
loc = iop->pathinfo;
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000e6f0: eb000e5f bl 30012074 <__errno> <== NOT EXECUTED 3000e6f4: e3a03016 mov r3, #22 <== NOT EXECUTED 3000e6f8: e5803000 str r3, [r0] <== NOT EXECUTED 3000e6fc: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000e700: eafffff3 b 3000e6d4 <ftruncate+0x90> <== NOT EXECUTED
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
3000e704: eb000e5a bl 30012074 <__errno> <== NOT EXECUTED 3000e708: e3a03015 mov r3, #21 <== NOT EXECUTED 3000e70c: e5803000 str r3, [r0] <== NOT EXECUTED 3000e710: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000e714: eaffffee b 3000e6d4 <ftruncate+0x90> <== NOT EXECUTED
30006618 <ftrylockfile>:
#include <rtems/seterr.h>
#include <errno.h>
/* This is a non-functional stub */
int ftrylockfile(FILE* file)
{
30006618: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000661c: eb002e99 bl 30012088 <__errno> <== NOT EXECUTED 30006620: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 30006624: e5803000 str r3, [r0] <== NOT EXECUTED
}
30006628: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000662c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006630 <funlockfile>:
#include <stdio.h>
/* This is a non-functional stub */
void funlockfile(FILE* file)
{
}
30006630: e12fff1e bx lr <== NOT EXECUTED
30006b08 <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;
30006b08: e59f3008 ldr r3, [pc, #8] ; 30006b18 <getgid+0x10> <== NOT EXECUTED 30006b0c: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
30006b10: e1d303b4 ldrh r0, [r3, #52] ; 0x34 <== NOT EXECUTED 30006b14: e12fff1e bx lr <== NOT EXECUTED
30007128 <getgr_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
30007128: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3000712c: e59d801c ldr r8, [sp, #28] <== NOT EXECUTED
30007130: e1a05000 mov r5, r0 <== NOT EXECUTED
30007134: e1a0a001 mov sl, r1 <== NOT EXECUTED
30007138: e1a04002 mov r4, r2 <== NOT EXECUTED
3000713c: e1a07003 mov r7, r3 <== NOT EXECUTED
FILE *fp;
int match;
init_etc_passwd_group();
30007140: ebffffc0 bl 30007048 <init_etc_passwd_group> <== NOT EXECUTED
if ((fp = fopen("/etc/group", "r")) == NULL)
30007144: e59f00b0 ldr r0, [pc, #176] ; 300071fc <getgr_r+0xd4> <== NOT EXECUTED 30007148: e59f10b0 ldr r1, [pc, #176] ; 30007200 <getgr_r+0xd8> <== NOT EXECUTED 3000714c: eb0031e8 bl 300138f4 <fopen> <== NOT EXECUTED 30007150: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30007154: 1a000006 bne 30007174 <getgr_r+0x4c> <== NOT EXECUTED 30007158: ea000022 b 300071e8 <getgr_r+0xc0> <== NOT EXECUTED
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
goto error_einval;
if (name) {
match = (strcmp(grp->gr_name, name) == 0);
3000715c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30007160: eb003594 bl 300147b8 <strcmp> <== NOT EXECUTED 30007164: e2700001 rsbs r0, r0, #1 <== NOT EXECUTED 30007168: 33a00000 movcc r0, #0 <== NOT EXECUTED
} else {
match = (grp->gr_gid == gid);
}
if (match) {
3000716c: e3500000 cmp r0, #0 <== NOT EXECUTED 30007170: 1a00000f bne 300071b4 <getgr_r+0x8c> <== NOT EXECUTED
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
30007174: e1a01004 mov r1, r4 <== NOT EXECUTED 30007178: e1a02007 mov r2, r7 <== NOT EXECUTED 3000717c: e1a03008 mov r3, r8 <== NOT EXECUTED 30007180: e1a00006 mov r0, r6 <== NOT EXECUTED 30007184: ebffff10 bl 30006dcc <scangr> <== NOT EXECUTED 30007188: e3500000 cmp r0, #0 <== NOT EXECUTED
goto error_einval;
if (name) {
match = (strcmp(grp->gr_name, name) == 0);
3000718c: e1a01005 mov r1, r5 <== NOT EXECUTED
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
30007190: 0a00000d beq 300071cc <getgr_r+0xa4> <== NOT EXECUTED
goto error_einval;
if (name) {
30007194: e3550000 cmp r5, #0 <== NOT EXECUTED 30007198: 1affffef bne 3000715c <getgr_r+0x34> <== NOT EXECUTED
match = (strcmp(grp->gr_name, name) == 0);
} else {
match = (grp->gr_gid == gid);
3000719c: e1d400b8 ldrh r0, [r4, #8] <== NOT EXECUTED 300071a0: e150000a cmp r0, sl <== NOT EXECUTED 300071a4: 13a00000 movne r0, #0 <== NOT EXECUTED 300071a8: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
if (match) {
300071ac: e3500000 cmp r0, #0 <== NOT EXECUTED 300071b0: 0affffef beq 30007174 <getgr_r+0x4c> <== NOT EXECUTED
fclose(fp);
300071b4: e1a00006 mov r0, r6 <== NOT EXECUTED 300071b8: eb002ff6 bl 30013198 <fclose> <== NOT EXECUTED
*result = grp;
300071bc: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
return 0;
300071c0: e3a00000 mov r0, #0 <== NOT EXECUTED
match = (grp->gr_gid == gid);
}
if (match) {
fclose(fp);
*result = grp;
300071c4: e5834000 str r4, [r3] <== NOT EXECUTED
return 0;
300071c8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
}
error_einval:
fclose(fp);
300071cc: e1a00006 mov r0, r6 <== NOT EXECUTED 300071d0: eb002ff0 bl 30013198 <fclose> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
300071d4: eb002fa1 bl 30013060 <__errno> <== NOT EXECUTED 300071d8: e3a03016 mov r3, #22 <== NOT EXECUTED 300071dc: e5803000 str r3, [r0] <== NOT EXECUTED 300071e0: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
300071e4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
int match;
init_etc_passwd_group();
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
300071e8: eb002f9c bl 30013060 <__errno> <== NOT EXECUTED
300071ec: e3a03016 mov r3, #22 <== NOT EXECUTED
300071f0: e5803000 str r3, [r0] <== NOT EXECUTED
300071f4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300071f8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30007534 <getgrent>:
struct group *getgrent(void)
{
30007534: e92d4010 push {r4, lr} <== NOT EXECUTED
if (group_fp == NULL)
30007538: e59f4024 ldr r4, [pc, #36] ; 30007564 <getgrent+0x30> <== NOT EXECUTED
3000753c: e59401c4 ldr r0, [r4, #452] ; 0x1c4 <== NOT EXECUTED
30007540: e3500000 cmp r0, #0 <== NOT EXECUTED
30007544: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return NULL;
if (!scangr(group_fp, &grent, grbuf, sizeof grbuf))
30007548: e28410ec add r1, r4, #236 ; 0xec <== NOT EXECUTED 3000754c: e28420fc add r2, r4, #252 ; 0xfc <== NOT EXECUTED 30007550: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 30007554: ebfffe1c bl 30006dcc <scangr> <== NOT EXECUTED
return NULL;
30007558: e3500000 cmp r0, #0 <== NOT EXECUTED 3000755c: 128400ec addne r0, r4, #236 ; 0xec <== NOT EXECUTED
return &grent; }
30007560: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300074f4 <getgrgid>:
struct group *getgrgid(
gid_t gid
)
{
300074f4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
300074f8: e59f1030 ldr r1, [pc, #48] ; 30007530 <getgrgid+0x3c> <== NOT EXECUTED
}
struct group *getgrgid(
gid_t gid
)
{
300074fc: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30007500: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
30007504: e28dc004 add ip, sp, #4 <== NOT EXECUTED 30007508: e2812010 add r2, r1, #16 <== NOT EXECUTED 3000750c: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 30007510: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 30007514: e58dc000 str ip, [sp] <== NOT EXECUTED 30007518: ebffffe6 bl 300074b8 <getgrgid_r> <== NOT EXECUTED 3000751c: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
30007520: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
return NULL;
30007524: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
30007528: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000752c: e8bd8000 pop {pc} <== NOT EXECUTED
300074b8 <getgrgid_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
300074b8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
300074bc: e1a0c002 mov ip, r2 <== NOT EXECUTED
300074c0: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
300074c4: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getgr_r(NULL, gid, grp, buffer, bufsize, result);
300074c8: e58d3000 str r3, [sp] <== NOT EXECUTED
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
300074cc: e1a01800 lsl r1, r0, #16 <== NOT EXECUTED
return getgr_r(NULL, gid, grp, buffer, bufsize, result);
300074d0: e1a0300c mov r3, ip <== NOT EXECUTED 300074d4: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 300074d8: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 300074dc: e1a0200e mov r2, lr <== NOT EXECUTED 300074e0: e3a00000 mov r0, #0 <== NOT EXECUTED 300074e4: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 300074e8: ebffff0e bl 30007128 <getgr_r> <== NOT EXECUTED
}
300074ec: e28dd008 add sp, sp, #8 <== NOT EXECUTED
300074f0: e8bd8000 pop {pc} <== NOT EXECUTED
30007480 <getgrnam>:
struct group *getgrnam(
const char *name
)
{
30007480: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
30007484: e59f1028 ldr r1, [pc, #40] ; 300074b4 <getgrnam+0x34> <== NOT EXECUTED
}
struct group *getgrnam(
const char *name
)
{
30007488: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
3000748c: e28dc004 add ip, sp, #4 <== NOT EXECUTED 30007490: e2812010 add r2, r1, #16 <== NOT EXECUTED 30007494: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 30007498: e58dc000 str ip, [sp] <== NOT EXECUTED 3000749c: ebffffea bl 3000744c <getgrnam_r> <== NOT EXECUTED 300074a0: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
300074a4: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
return NULL;
300074a8: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
300074ac: e28dd008 add sp, sp, #8 <== NOT EXECUTED
300074b0: e8bd8000 pop {pc} <== NOT EXECUTED
3000744c <getgrnam_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
3000744c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007450: e1a0c002 mov ip, r2 <== NOT EXECUTED
30007454: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
30007458: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getgr_r(name, 0, grp, buffer, bufsize, result);
3000745c: e58d3000 str r3, [sp] <== NOT EXECUTED 30007460: e1a0300c mov r3, ip <== NOT EXECUTED 30007464: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 30007468: e3a01000 mov r1, #0 <== NOT EXECUTED 3000746c: e1a0200e mov r2, lr <== NOT EXECUTED 30007470: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 30007474: ebffff2b bl 30007128 <getgr_r> <== NOT EXECUTED
}
30007478: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000747c: e8bd8000 pop {pc} <== NOT EXECUTED
30006b1c <getgroups>:
int gidsetsize __attribute__((unused)),
gid_t grouplist[] __attribute__((unused))
)
{
return 0; /* no supplemental group ids */
}
30006b1c: e3a00000 mov r0, #0 <== NOT EXECUTED 30006b20: e12fff1e bx lr <== NOT EXECUTED
300098c0 <getitimer>:
int getitimer(
int which,
struct itimerval *value
)
{
if ( !value )
300098c0: e3510000 cmp r1, #0 <== NOT EXECUTED
int getitimer(
int which,
struct itimerval *value
)
{
300098c4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !value )
300098c8: 0a00000b beq 300098fc <getitimer+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
300098cc: e3500002 cmp r0, #2 <== NOT EXECUTED 300098d0: 9a000004 bls 300098e8 <getitimer+0x28> <== NOT EXECUTED
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
300098d4: eb0023f9 bl 300128c0 <__errno> <== NOT EXECUTED 300098d8: e3a03016 mov r3, #22 <== NOT EXECUTED 300098dc: e5803000 str r3, [r0] <== NOT EXECUTED
}
300098e0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300098e4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
switch ( which ) {
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
300098e8: eb0023f4 bl 300128c0 <__errno> <== NOT EXECUTED 300098ec: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300098f0: e5803000 str r3, [r0] <== NOT EXECUTED
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
300098f4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300098f8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int which,
struct itimerval *value
)
{
if ( !value )
rtems_set_errno_and_return_minus_one( EFAULT );
300098fc: eb0023ef bl 300128c0 <__errno> <== NOT EXECUTED 30009900: e3a0300e mov r3, #14 <== NOT EXECUTED 30009904: e5803000 str r3, [r0] <== NOT EXECUTED 30009908: eafffff4 b 300098e0 <getitimer+0x20> <== NOT EXECUTED
30006b70 <getlogin>:
* 4.2.4 Get User Name, P1003.1b-1993, p. 87
*
* NOTE: P1003.1c/D10, p. 49 adds getlogin_r().
*/
char *getlogin( void )
{
30006b70: e92d4010 push {r4, lr} <== NOT EXECUTED
(void) getlogin_r( _POSIX_types_Getlogin_buffer, LOGIN_NAME_MAX );
30006b74: e59f4018 ldr r4, [pc, #24] ; 30006b94 <getlogin+0x24> <== NOT EXECUTED 30006b78: e3a01009 mov r1, #9 <== NOT EXECUTED 30006b7c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30006b80: e280003a add r0, r0, #58 ; 0x3a <== NOT EXECUTED 30006b84: ebffffe6 bl 30006b24 <getlogin_r> <== NOT EXECUTED
return _POSIX_types_Getlogin_buffer;
30006b88: e5940000 ldr r0, [r4] <== NOT EXECUTED
}
30006b8c: e280003a add r0, r0, #58 ; 0x3a <== NOT EXECUTED
30006b90: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30006b24 <getlogin_r>:
*/
int getlogin_r(
char *name,
size_t namesize
)
{
30006b24: e92d4010 push {r4, lr} <== NOT EXECUTED
struct passwd *pw;
char *pname;
if ( !name )
30006b28: e2504000 subs r4, r0, #0 <== NOT EXECUTED
return EFAULT;
30006b2c: 03a0000e moveq r0, #14 <== NOT EXECUTED
)
{
struct passwd *pw;
char *pname;
if ( !name )
30006b30: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EFAULT;
if ( namesize < LOGIN_NAME_MAX )
30006b34: e3510008 cmp r1, #8 <== NOT EXECUTED 30006b38: 8a000001 bhi 30006b44 <getlogin_r+0x20> <== NOT EXECUTED
return ERANGE;
30006b3c: e3a00022 mov r0, #34 ; 0x22 <== NOT EXECUTED
if ( pw )
pname = pw->pw_name;
strncpy( name, pname, LOGIN_NAME_MAX );
return 0;
}
30006b40: e8bd8010 pop {r4, pc} <== NOT EXECUTED
return ERANGE;
/* Set the pointer to a default name */
pname = "";
pw = getpwuid(getuid());
30006b44: eb0002b9 bl 30007630 <getuid> <== NOT EXECUTED 30006b48: eb00020e bl 30007388 <getpwuid> <== NOT EXECUTED
if ( pw )
30006b4c: e3500000 cmp r0, #0 <== NOT EXECUTED
pname = pw->pw_name;
30006b50: 15901000 ldrne r1, [r0] <== NOT EXECUTED
if ( namesize < LOGIN_NAME_MAX )
return ERANGE;
/* Set the pointer to a default name */
pname = "";
30006b54: 059f1010 ldreq r1, [pc, #16] ; 30006b6c <getlogin_r+0x48> <== NOT EXECUTED
pw = getpwuid(getuid());
if ( pw )
pname = pw->pw_name;
strncpy( name, pname, LOGIN_NAME_MAX );
30006b58: e1a00004 mov r0, r4 <== NOT EXECUTED 30006b5c: e3a02009 mov r2, #9 <== NOT EXECUTED 30006b60: eb003808 bl 30014b88 <strncpy> <== NOT EXECUTED
return 0;
30006b64: e3a00000 mov r0, #0 <== NOT EXECUTED
30006b68: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300066e0 <getpagesize>:
* return a reasonable value.
*/
int getpagesize(void)
{
return PAGE_SIZE;
}
300066e0: e3a00a01 mov r0, #4096 ; 0x1000 <== NOT EXECUTED 300066e4: e12fff1e bx lr <== NOT EXECUTED
30006b98 <getpgrp>:
* This always succeeds and returns the process group id. For rtems,
* this will always be the local node;
*/
return _Objects_Local_node;
}
30006b98: e3a00001 mov r0, #1 <== NOT EXECUTED 30006b9c: e12fff1e bx lr <== NOT EXECUTED
30006bb4 <getppid>:
*
* 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83
*/
pid_t getppid( void )
{
30006bb4: e59f3004 ldr r3, [pc, #4] ; 30006bc0 <getppid+0xc> <== NOT EXECUTED
return _POSIX_types_Ppid; }
30006bb8: e5930000 ldr r0, [r3] <== NOT EXECUTED 30006bbc: e12fff1e bx lr <== NOT EXECUTED
30007204 <getpw_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
30007204: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
30007208: e59d801c ldr r8, [sp, #28] <== NOT EXECUTED
3000720c: e1a05000 mov r5, r0 <== NOT EXECUTED
30007210: e1a0a001 mov sl, r1 <== NOT EXECUTED
30007214: e1a04002 mov r4, r2 <== NOT EXECUTED
30007218: e1a07003 mov r7, r3 <== NOT EXECUTED
FILE *fp;
int match;
init_etc_passwd_group();
3000721c: ebffff89 bl 30007048 <init_etc_passwd_group> <== NOT EXECUTED
if ((fp = fopen("/etc/passwd", "r")) == NULL)
30007220: e59f00b0 ldr r0, [pc, #176] ; 300072d8 <getpw_r+0xd4> <== NOT EXECUTED 30007224: e59f10b0 ldr r1, [pc, #176] ; 300072dc <getpw_r+0xd8> <== NOT EXECUTED 30007228: eb0031b1 bl 300138f4 <fopen> <== NOT EXECUTED 3000722c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30007230: 1a000006 bne 30007250 <getpw_r+0x4c> <== NOT EXECUTED 30007234: ea000022 b 300072c4 <getpw_r+0xc0> <== NOT EXECUTED
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize))
goto error_einval;
if (name) {
match = (strcmp(pwd->pw_name, name) == 0);
30007238: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000723c: eb00355d bl 300147b8 <strcmp> <== NOT EXECUTED 30007240: e2700001 rsbs r0, r0, #1 <== NOT EXECUTED 30007244: 33a00000 movcc r0, #0 <== NOT EXECUTED
} else {
match = (pwd->pw_uid == uid);
}
if (match) {
30007248: e3500000 cmp r0, #0 <== NOT EXECUTED 3000724c: 1a00000f bne 30007290 <getpw_r+0x8c> <== NOT EXECUTED
if ((fp = fopen("/etc/passwd", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize))
30007250: e1a01004 mov r1, r4 <== NOT EXECUTED 30007254: e1a02007 mov r2, r7 <== NOT EXECUTED 30007258: e1a03008 mov r3, r8 <== NOT EXECUTED 3000725c: e1a00006 mov r0, r6 <== NOT EXECUTED 30007260: ebffff2f bl 30006f24 <scanpw> <== NOT EXECUTED 30007264: e3500000 cmp r0, #0 <== NOT EXECUTED
goto error_einval;
if (name) {
match = (strcmp(pwd->pw_name, name) == 0);
30007268: e1a01005 mov r1, r5 <== NOT EXECUTED
if ((fp = fopen("/etc/passwd", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize))
3000726c: 0a00000d beq 300072a8 <getpw_r+0xa4> <== NOT EXECUTED
goto error_einval;
if (name) {
30007270: e3550000 cmp r5, #0 <== NOT EXECUTED 30007274: 1affffef bne 30007238 <getpw_r+0x34> <== NOT EXECUTED
match = (strcmp(pwd->pw_name, name) == 0);
} else {
match = (pwd->pw_uid == uid);
30007278: e1d400b8 ldrh r0, [r4, #8] <== NOT EXECUTED 3000727c: e150000a cmp r0, sl <== NOT EXECUTED 30007280: 13a00000 movne r0, #0 <== NOT EXECUTED 30007284: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
if (match) {
30007288: e3500000 cmp r0, #0 <== NOT EXECUTED 3000728c: 0affffef beq 30007250 <getpw_r+0x4c> <== NOT EXECUTED
fclose(fp);
30007290: e1a00006 mov r0, r6 <== NOT EXECUTED 30007294: eb002fbf bl 30013198 <fclose> <== NOT EXECUTED
*result = pwd;
30007298: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
return 0;
3000729c: e3a00000 mov r0, #0 <== NOT EXECUTED
match = (pwd->pw_uid == uid);
}
if (match) {
fclose(fp);
*result = pwd;
300072a0: e5834000 str r4, [r3] <== NOT EXECUTED
return 0;
300072a4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
}
error_einval:
fclose(fp);
300072a8: e1a00006 mov r0, r6 <== NOT EXECUTED 300072ac: eb002fb9 bl 30013198 <fclose> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
300072b0: eb002f6a bl 30013060 <__errno> <== NOT EXECUTED 300072b4: e3a03016 mov r3, #22 <== NOT EXECUTED 300072b8: e5803000 str r3, [r0] <== NOT EXECUTED 300072bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
300072c0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
int match;
init_etc_passwd_group();
if ((fp = fopen("/etc/passwd", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
300072c4: eb002f65 bl 30013060 <__errno> <== NOT EXECUTED
300072c8: e3a03016 mov r3, #22 <== NOT EXECUTED
300072cc: e5803000 str r3, [r0] <== NOT EXECUTED
300072d0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300072d4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
300073c8 <getpwent>:
struct passwd *getpwent(void)
{
300073c8: e92d4010 push {r4, lr} <== NOT EXECUTED
if (passwd_fp == NULL)
300073cc: e59f4024 ldr r4, [pc, #36] ; 300073f8 <getpwent+0x30> <== NOT EXECUTED
300073d0: e59400e8 ldr r0, [r4, #232] ; 0xe8 <== NOT EXECUTED
300073d4: e3500000 cmp r0, #0 <== NOT EXECUTED
300073d8: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return NULL;
if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf))
300073dc: e2841004 add r1, r4, #4 <== NOT EXECUTED 300073e0: e2842020 add r2, r4, #32 <== NOT EXECUTED 300073e4: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 300073e8: ebfffecd bl 30006f24 <scanpw> <== NOT EXECUTED
return NULL;
300073ec: e3500000 cmp r0, #0 <== NOT EXECUTED 300073f0: 12840004 addne r0, r4, #4 <== NOT EXECUTED
return &pwent; }
300073f4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30007314 <getpwnam>:
struct passwd *getpwnam(
const char *name
)
{
30007314: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
30007318: e59f1028 ldr r1, [pc, #40] ; 30007348 <getpwnam+0x34> <== NOT EXECUTED
}
struct passwd *getpwnam(
const char *name
)
{
3000731c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
30007320: e28dc004 add ip, sp, #4 <== NOT EXECUTED 30007324: e281201c add r2, r1, #28 <== NOT EXECUTED 30007328: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 3000732c: e58dc000 str ip, [sp] <== NOT EXECUTED 30007330: ebffffea bl 300072e0 <getpwnam_r> <== NOT EXECUTED 30007334: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
30007338: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
return NULL;
3000733c: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
30007340: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30007344: e8bd8000 pop {pc} <== NOT EXECUTED
300072e0 <getpwnam_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
300072e0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
300072e4: e1a0c002 mov ip, r2 <== NOT EXECUTED
300072e8: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
300072ec: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getpw_r(name, 0, pwd, buffer, bufsize, result);
300072f0: e58d3000 str r3, [sp] <== NOT EXECUTED 300072f4: e1a0300c mov r3, ip <== NOT EXECUTED 300072f8: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 300072fc: e3a01000 mov r1, #0 <== NOT EXECUTED 30007300: e1a0200e mov r2, lr <== NOT EXECUTED 30007304: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 30007308: ebffffbd bl 30007204 <getpw_r> <== NOT EXECUTED
}
3000730c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30007310: e8bd8000 pop {pc} <== NOT EXECUTED
30007388 <getpwuid>:
struct passwd *getpwuid(
uid_t uid
)
{
30007388: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
3000738c: e59f1030 ldr r1, [pc, #48] ; 300073c4 <getpwuid+0x3c> <== NOT EXECUTED
}
struct passwd *getpwuid(
uid_t uid
)
{
30007390: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30007394: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
30007398: e28dc004 add ip, sp, #4 <== NOT EXECUTED 3000739c: e281201c add r2, r1, #28 <== NOT EXECUTED 300073a0: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 300073a4: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 300073a8: e58dc000 str ip, [sp] <== NOT EXECUTED 300073ac: ebffffe6 bl 3000734c <getpwuid_r> <== NOT EXECUTED 300073b0: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
300073b4: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
return NULL;
300073b8: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
300073bc: e28dd008 add sp, sp, #8 <== NOT EXECUTED
300073c0: e8bd8000 pop {pc} <== NOT EXECUTED
3000734c <getpwuid_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
3000734c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007350: e1a0c002 mov ip, r2 <== NOT EXECUTED
30007354: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
30007358: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getpw_r(NULL, uid, pwd, buffer, bufsize, result);
3000735c: e58d3000 str r3, [sp] <== NOT EXECUTED
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
30007360: e1a01800 lsl r1, r0, #16 <== NOT EXECUTED
return getpw_r(NULL, uid, pwd, buffer, bufsize, result);
30007364: e1a0300c mov r3, ip <== NOT EXECUTED 30007368: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 3000736c: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 30007370: e1a0200e mov r2, lr <== NOT EXECUTED 30007374: e3a00000 mov r0, #0 <== NOT EXECUTED 30007378: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3000737c: ebffffa0 bl 30007204 <getpw_r> <== NOT EXECUTED
}
30007380: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30007384: e8bd8000 pop {pc} <== NOT EXECUTED
3000681c <getrusage>:
#include <rtems.h>
#include <rtems/seterr.h>
int getrusage(int who, struct rusage *usage)
{
3000681c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
struct timespec uptime;
struct timeval rtime;
if ( !usage )
30006820: e2515000 subs r5, r1, #0 <== NOT EXECUTED
#include <rtems.h>
#include <rtems/seterr.h>
int getrusage(int who, struct rusage *usage)
{
30006824: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30006828: e1a04000 mov r4, r0 <== NOT EXECUTED
struct timespec uptime;
struct timeval rtime;
if ( !usage )
3000682c: 0a00001b beq 300068a0 <getrusage+0x84> <== 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) {
30006830: e3500000 cmp r0, #0 <== NOT EXECUTED 30006834: 0a00000c beq 3000686c <getrusage+0x50> <== NOT EXECUTED
usage->ru_stime = rtime;
return 0;
}
if (who == RUSAGE_CHILDREN) {
30006838: e3700001 cmn r0, #1 <== NOT EXECUTED 3000683c: 0a000005 beq 30006858 <getrusage+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
}
rtems_set_errno_and_return_minus_one( EINVAL );
30006840: eb002ec2 bl 30012350 <__errno> <== NOT EXECUTED 30006844: e3a03016 mov r3, #22 <== NOT EXECUTED 30006848: e5803000 str r3, [r0] <== NOT EXECUTED 3000684c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
30006850: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30006854: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
return 0;
}
if (who == RUSAGE_CHILDREN) {
rtems_set_errno_and_return_minus_one( ENOSYS );
30006858: eb002ebc bl 30012350 <__errno> <== NOT EXECUTED 3000685c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30006860: e5803000 str r3, [r0] <== NOT EXECUTED 30006864: e1a00004 mov r0, r4 <== NOT EXECUTED 30006868: eafffff8 b 30006850 <getrusage+0x34> <== NOT EXECUTED
* 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) {
rtems_clock_get_uptime( &uptime );
3000686c: e1a0000d mov r0, sp <== NOT EXECUTED 30006870: eb000bfa bl 30009860 <rtems_clock_get_uptime> <== NOT EXECUTED
rtime.tv_sec = uptime.tv_sec;
rtime.tv_usec = uptime.tv_nsec / 1000;
30006874: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 30006878: e59f3034 ldr r3, [pc, #52] ; 300068b4 <getrusage+0x98> <== 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;
3000687c: e59d2000 ldr r2, [sp] <== NOT EXECUTED
rtime.tv_usec = uptime.tv_nsec / 1000;
30006880: e0c30391 smull r0, r3, r1, r3 <== NOT EXECUTED
30006884: e1a01fc1 asr r1, r1, #31 <== NOT EXECUTED
30006888: e0613343 rsb r3, r1, r3, asr #6 <== NOT EXECUTED
3000688c: e885000c stm r5, {r2, r3} <== NOT EXECUTED
30006890: e5852008 str r2, [r5, #8] <== NOT EXECUTED
30006894: e585300c str r3, [r5, #12] <== NOT EXECUTED
usage->ru_utime = rtime;
usage->ru_stime = rtime;
return 0;
30006898: e1a00004 mov r0, r4 <== NOT EXECUTED 3000689c: eaffffeb b 30006850 <getrusage+0x34> <== NOT EXECUTED
{
struct timespec uptime;
struct timeval rtime;
if ( !usage )
rtems_set_errno_and_return_minus_one( EFAULT );
300068a0: eb002eaa bl 30012350 <__errno> <== NOT EXECUTED 300068a4: e3a0300e mov r3, #14 <== NOT EXECUTED 300068a8: e5803000 str r3, [r0] <== NOT EXECUTED 300068ac: e3e00000 mvn r0, #0 <== NOT EXECUTED 300068b0: eaffffe6 b 30006850 <getrusage+0x34> <== NOT EXECUTED
3000653c <gettimeofday>:
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
3000653c: e92d4030 push {r4, r5, lr}
/* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp )
30006540: e2504000 subs r4, r0, #0
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
30006544: e24dd008 sub sp, sp, #8
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
30006548: 0a00000f beq 3000658c <gettimeofday+0x50>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000654c: e10f5000 mrs r5, CPSR 30006550: e3853080 orr r3, r5, #128 ; 0x80 30006554: e129f003 msr CPSR_fc, r3
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
_TOD_Get( &now );
30006558: e1a0000d mov r0, sp 3000655c: eb0010f9 bl 3000a948 <_TOD_Get>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30006560: e129f005 msr CPSR_fc, r5
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
30006564: e59f2034 ldr r2, [pc, #52] ; 300065a0 <gettimeofday+0x64>
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
30006568: e59d3004 ldr r3, [sp, #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;
3000656c: e3a00000 mov r0, #0
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
30006570: e0c21293 smull r1, r2, r3, r2 30006574: e1a03fc3 asr r3, r3, #31 30006578: e0633342 rsb r3, r3, r2, asr #6
time->tv_sec = now.tv_sec;
3000657c: e59d2000 ldr r2, [sp]
time->tv_usec = useconds;
30006580: e884000c stm r4, {r2, r3}
}
30006584: e28dd008 add sp, sp, #8
30006588: e8bd8030 pop {r4, r5, pc}
void * __tz __attribute__((unused))
)
{
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
rtems_set_errno_and_return_minus_one( EFAULT );
3000658c: eb002eb8 bl 30012074 <__errno> <== NOT EXECUTED 30006590: e3a0300e mov r3, #14 <== NOT EXECUTED 30006594: e5803000 str r3, [r0] <== NOT EXECUTED 30006598: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000659c: eafffff8 b 30006584 <gettimeofday+0x48> <== NOT EXECUTED
30007630 <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;
30007630: e59f3008 ldr r3, [pc, #8] ; 30007640 <getuid+0x10> <== NOT EXECUTED 30007634: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
30007638: e1d303b2 ldrh r0, [r3, #50] ; 0x32 <== NOT EXECUTED 3000763c: e12fff1e bx lr <== NOT EXECUTED
300115c8 <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
300115c8: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
300115cc: e5914000 ldr r4, [r1]
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
300115d0: 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 );
300115d4: e2843054 add r3, r4, #84 ; 0x54 300115d8: e1520003 cmp r2, r3
300115dc: 1a000011 bne 30011628 <imfs_dir_rmnod+0x60>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
300115e0: e5913010 ldr r3, [r1, #16] 300115e4: e593301c ldr r3, [r3, #28] 300115e8: e1540003 cmp r4, r3
300115ec: 0a000008 beq 30011614 <imfs_dir_rmnod+0x4c>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
300115f0: e594505c ldr r5, [r4, #92] ; 0x5c 300115f4: e3550000 cmp r5, #0
300115f8: 1a000005 bne 30011614 <imfs_dir_rmnod+0x4c>
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
300115fc: e1a00004 mov r0, r4 30011600: ebfff37f bl 3000e404 <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
30011604: e1a00004 mov r0, r4 30011608: ebfff390 bl 3000e450 <IMFS_check_node_remove>
return 0;
3001160c: e1a00005 mov r0, r5
}
30011610: e8bd8030 pop {r4, r5, pc}
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
rtems_set_errno_and_return_minus_one( EBUSY );
30011614: eb000296 bl 30012074 <__errno> <== NOT EXECUTED
30011618: e3a03010 mov r3, #16 <== NOT EXECUTED
3001161c: e5803000 str r3, [r0] <== NOT EXECUTED
30011620: e3e00000 mvn r0, #0 <== NOT EXECUTED
30011624: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
30011628: eb000291 bl 30012074 <__errno> <== NOT EXECUTED
3001162c: e3a0305a mov r3, #90 ; 0x5a <== NOT EXECUTED
30011630: e5803000 str r3, [r0] <== NOT EXECUTED
30011634: e3e00000 mvn r0, #0 <== NOT EXECUTED
30011638: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30007048 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
30007048: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
3000704c: e59f30b0 ldr r3, [pc, #176] ; 30007104 <init_etc_passwd_group+0xbc><== NOT EXECUTED
30007050: e5d32000 ldrb r2, [r3] <== NOT EXECUTED
30007054: e3520000 cmp r2, #0 <== NOT EXECUTED
30007058: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
return;
etc_passwd_initted = 1;
3000705c: e3a05001 mov r5, #1 <== NOT EXECUTED
mkdir("/etc", 0777);
30007060: e59f10a0 ldr r1, [pc, #160] ; 30007108 <init_etc_passwd_group+0xc0><== NOT EXECUTED
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
30007064: e5c35000 strb r5, [r3] <== NOT EXECUTED
mkdir("/etc", 0777);
30007068: e59f009c ldr r0, [pc, #156] ; 3000710c <init_etc_passwd_group+0xc4><== NOT EXECUTED 3000706c: eb000246 bl 3000798c <mkdir> <== NOT EXECUTED
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
30007070: e59f0098 ldr r0, [pc, #152] ; 30007110 <init_etc_passwd_group+0xc8><== NOT EXECUTED 30007074: e59f1098 ldr r1, [pc, #152] ; 30007114 <init_etc_passwd_group+0xcc><== NOT EXECUTED 30007078: eb00321d bl 300138f4 <fopen> <== NOT EXECUTED 3000707c: e3500000 cmp r0, #0 <== NOT EXECUTED 30007080: 0a000007 beq 300070a4 <init_etc_passwd_group+0x5c> <== NOT EXECUTED
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
30007084: eb003043 bl 30013198 <fclose> <== NOT EXECUTED
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
30007088: e59f0088 ldr r0, [pc, #136] ; 30007118 <init_etc_passwd_group+0xd0><== NOT EXECUTED 3000708c: e59f1080 ldr r1, [pc, #128] ; 30007114 <init_etc_passwd_group+0xcc><== NOT EXECUTED 30007090: eb003217 bl 300138f4 <fopen> <== NOT EXECUTED 30007094: e3500000 cmp r0, #0 <== NOT EXECUTED 30007098: 0a00000d beq 300070d4 <init_etc_passwd_group+0x8c> <== NOT EXECUTED
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
}
}
3000709c: e8bd4030 pop {r4, r5, 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);
300070a0: ea00303c b 30013198 <fclose> <== NOT EXECUTED
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
300070a4: e59f0064 ldr r0, [pc, #100] ; 30007110 <init_etc_passwd_group+0xc8><== NOT EXECUTED 300070a8: e59f106c ldr r1, [pc, #108] ; 3000711c <init_etc_passwd_group+0xd4><== NOT EXECUTED 300070ac: eb003210 bl 300138f4 <fopen> <== NOT EXECUTED 300070b0: e2504000 subs r4, r0, #0 <== NOT EXECUTED 300070b4: 0afffff3 beq 30007088 <init_etc_passwd_group+0x40> <== NOT EXECUTED
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
300070b8: e59f0060 ldr r0, [pc, #96] ; 30007120 <init_etc_passwd_group+0xd8><== NOT EXECUTED 300070bc: e1a01005 mov r1, r5 <== NOT EXECUTED 300070c0: e3a02066 mov r2, #102 ; 0x66 <== NOT EXECUTED 300070c4: e1a03004 mov r3, r4 <== NOT EXECUTED 300070c8: eb003411 bl 30014114 <fwrite> <== NOT EXECUTED
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
300070cc: e1a00004 mov r0, r4 <== NOT EXECUTED 300070d0: eaffffeb b 30007084 <init_etc_passwd_group+0x3c> <== NOT EXECUTED
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
300070d4: e59f003c ldr r0, [pc, #60] ; 30007118 <init_etc_passwd_group+0xd0><== NOT EXECUTED
300070d8: e59f103c ldr r1, [pc, #60] ; 3000711c <init_etc_passwd_group+0xd4><== NOT EXECUTED
300070dc: eb003204 bl 300138f4 <fopen> <== NOT EXECUTED
300070e0: e2504000 subs r4, r0, #0 <== NOT EXECUTED
300070e4: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
fprintf( fp, "root:x:0:root\n"
300070e8: e59f0034 ldr r0, [pc, #52] ; 30007124 <init_etc_passwd_group+0xdc><== NOT EXECUTED 300070ec: e3a01001 mov r1, #1 <== NOT EXECUTED 300070f0: e3a0202a mov r2, #42 ; 0x2a <== NOT EXECUTED 300070f4: e1a03004 mov r3, r4 <== NOT EXECUTED 300070f8: eb003405 bl 30014114 <fwrite> <== NOT EXECUTED
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
300070fc: e1a00004 mov r0, r4 <== NOT EXECUTED 30007100: eaffffe5 b 3000709c <init_etc_passwd_group+0x54> <== NOT EXECUTED
3000841c <iproc>:
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
3000841c: e5913030 ldr r3, [r1, #48] ; 0x30 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008420: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
30008424: e3130020 tst r3, #32 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008428: e20040ff and r4, r0, #255 ; 0xff <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
3000842c: 1200407f andne r4, r0, #127 ; 0x7f <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
30008430: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008434: e1a05001 mov r5, r1 <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
30008438: 0a000007 beq 3000845c <iproc+0x40> <== NOT EXECUTED
c = tolower (c);
3000843c: e59f21a0 ldr r2, [pc, #416] ; 300085e4 <iproc+0x1c8> <== NOT EXECUTED 30008440: e5922000 ldr r2, [r2] <== NOT EXECUTED 30008444: e0822004 add r2, r2, r4 <== NOT EXECUTED 30008448: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED 3000844c: e2022003 and r2, r2, #3 <== NOT EXECUTED 30008450: e3520001 cmp r2, #1 <== NOT EXECUTED 30008454: 02844020 addeq r4, r4, #32 <== NOT EXECUTED 30008458: e20440ff and r4, r4, #255 ; 0xff <== NOT EXECUTED
if (c == '\r') {
3000845c: e354000d cmp r4, #13 <== NOT EXECUTED 30008460: 0a000014 beq 300084b8 <iproc+0x9c> <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
30008464: e354000a cmp r4, #10 <== NOT EXECUTED 30008468: 0a000036 beq 30008548 <iproc+0x12c> <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
3000846c: e3540000 cmp r4, #0 <== NOT EXECUTED 30008470: 1a000016 bne 300084d0 <iproc+0xb4> <== NOT EXECUTED
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
30008474: e59f216c ldr r2, [pc, #364] ; 300085e8 <iproc+0x1cc> <== NOT EXECUTED 30008478: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 3000847c: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 30008480: e2422001 sub r2, r2, #1 <== NOT EXECUTED 30008484: e1530002 cmp r3, r2 <== NOT EXECUTED 30008488: aa000008 bge 300084b0 <iproc+0x94> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
3000848c: e595203c ldr r2, [r5, #60] ; 0x3c <== NOT EXECUTED 30008490: e3120008 tst r2, #8 <== NOT EXECUTED 30008494: 1a00002e bne 30008554 <iproc+0x138> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
30008498: e595101c ldr r1, [r5, #28] <== NOT EXECUTED 3000849c: e2832001 add r2, r3, #1 <== NOT EXECUTED 300084a0: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
} return 0;
300084a4: e3a00000 mov r0, #0 <== NOT EXECUTED
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
300084a8: e5852020 str r2, [r5, #32] <== NOT EXECUTED
300084ac: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
} return 0;
300084b0: e3a00000 mov r0, #0 <== NOT EXECUTED
}
300084b4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
300084b8: e3130080 tst r3, #128 ; 0x80 <== NOT EXECUTED
return 0;
300084bc: 13a00000 movne r0, #0 <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
300084c0: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
300084c4: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300084c8: 03a0400d moveq r4, #13 <== NOT EXECUTED 300084cc: 13a0400a movne r4, #10 <== NOT EXECUTED
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
300084d0: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED 300084d4: e3130002 tst r3, #2 <== NOT EXECUTED 300084d8: 0affffe5 beq 30008474 <iproc+0x58> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
300084dc: e5d52043 ldrb r2, [r5, #67] ; 0x43 <== NOT EXECUTED 300084e0: e1520004 cmp r2, r4 <== NOT EXECUTED 300084e4: 0a000039 beq 300085d0 <iproc+0x1b4> <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
300084e8: e5d52044 ldrb r2, [r5, #68] ; 0x44 <== NOT EXECUTED 300084ec: e1520004 cmp r2, r4 <== NOT EXECUTED 300084f0: 0a000025 beq 3000858c <iproc+0x170> <== NOT EXECUTED
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
300084f4: e5d52045 ldrb r2, [r5, #69] ; 0x45 <== NOT EXECUTED 300084f8: e1520004 cmp r2, r4 <== NOT EXECUTED
return 1;
300084fc: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
30008500: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
return 1;
} else if (c == '\n') {
30008504: e354000a cmp r4, #10 <== NOT EXECUTED 30008508: 0a000024 beq 300085a0 <iproc+0x184> <== NOT EXECUTED
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
3000850c: e5d5204c ldrb r2, [r5, #76] ; 0x4c <== NOT EXECUTED 30008510: e1520004 cmp r2, r4 <== NOT EXECUTED 30008514: 0a000002 beq 30008524 <iproc+0x108> <== NOT EXECUTED 30008518: e5d52051 ldrb r2, [r5, #81] ; 0x51 <== NOT EXECUTED 3000851c: e1520004 cmp r2, r4 <== NOT EXECUTED 30008520: 1affffd3 bne 30008474 <iproc+0x58> <== NOT EXECUTED
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
30008524: e3130008 tst r3, #8 <== NOT EXECUTED 30008528: 1a000013 bne 3000857c <iproc+0x160> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
3000852c: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 30008530: e595101c ldr r1, [r5, #28] <== NOT EXECUTED 30008534: e2832001 add r2, r3, #1 <== NOT EXECUTED 30008538: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
return 1;
3000853c: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
30008540: e5852020 str r2, [r5, #32] <== NOT EXECUTED
return 1;
30008544: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
30008548: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED 3000854c: 13a0400d movne r4, #13 <== NOT EXECUTED 30008550: eaffffde b 300084d0 <iproc+0xb4> <== NOT EXECUTED
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
30008554: e1a00004 mov r0, r4 <== NOT EXECUTED 30008558: e1a01005 mov r1, r5 <== NOT EXECUTED 3000855c: ebffff03 bl 30008170 <echo> <== NOT EXECUTED 30008560: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
30008564: e595101c ldr r1, [r5, #28] <== NOT EXECUTED 30008568: e2832001 add r2, r3, #1 <== NOT EXECUTED 3000856c: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
} return 0;
30008570: e3a00000 mov r0, #0 <== NOT EXECUTED
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
30008574: e5852020 str r2, [r5, #32] <== NOT EXECUTED
30008578: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
3000857c: e1a00004 mov r0, r4 <== NOT EXECUTED 30008580: e1a01005 mov r1, r5 <== NOT EXECUTED 30008584: ebfffef9 bl 30008170 <echo> <== NOT EXECUTED 30008588: eaffffe7 b 3000852c <iproc+0x110> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
3000858c: e1a00005 mov r0, r5 <== NOT EXECUTED 30008590: e3a01001 mov r1, #1 <== NOT EXECUTED 30008594: ebffff1a bl 30008204 <erase> <== NOT EXECUTED
return 0;
30008598: e3a00000 mov r0, #0 <== NOT EXECUTED
3000859c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
300085a0: e3130048 tst r3, #72 ; 0x48 <== NOT EXECUTED
echo (c, tty);
300085a4: 11a00004 movne r0, r4 <== NOT EXECUTED 300085a8: 11a01005 movne r1, r5 <== NOT EXECUTED 300085ac: 1bfffeef blne 30008170 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
300085b0: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 300085b4: e595101c ldr r1, [r5, #28] <== NOT EXECUTED 300085b8: e3a0000a mov r0, #10 <== NOT EXECUTED 300085bc: e2832001 add r2, r3, #1 <== NOT EXECUTED 300085c0: e7c10003 strb r0, [r1, r3] <== NOT EXECUTED
return 1;
300085c4: e3a00001 mov r0, #1 <== NOT EXECUTED
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
300085c8: e5852020 str r2, [r5, #32] <== NOT EXECUTED
return 1;
300085cc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
300085d0: e1a00005 mov r0, r5 <== NOT EXECUTED 300085d4: e3a01000 mov r1, #0 <== NOT EXECUTED 300085d8: ebffff09 bl 30008204 <erase> <== NOT EXECUTED
return 0;
300085dc: e3a00000 mov r0, #0 <== NOT EXECUTED
300085e0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30007644 <issetugid>:
#if defined(RTEMS_NEWLIB) && !defined(HAVE_ISSETUGID)
int issetugid (void)
{
return 0;
}
30007644: e3a00000 mov r0, #0 <== NOT EXECUTED 30007648: e12fff1e bx lr <== NOT EXECUTED
3000a070 <kill>:
int kill(
pid_t pid,
int sig
)
{
return killinfo( pid, sig, NULL );
3000a070: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a074: ea001978 b 3001065c <killinfo> <== NOT EXECUTED
30026cbc <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
30026cbc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
30026cc0: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
30026cc4: e1a04000 mov r4, r0 <== NOT EXECUTED
30026cc8: e1a05001 mov r5, r1 <== NOT EXECUTED
30026ccc: e1a08002 mov r8, r2 <== NOT EXECUTED
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
30026cd0: ebffff40 bl 300269d8 <getpid> <== NOT EXECUTED 30026cd4: e1500004 cmp r0, r4 <== NOT EXECUTED 30026cd8: 1a000093 bne 30026f2c <killinfo+0x270> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
30026cdc: e3550000 cmp r5, #0 <== NOT EXECUTED 30026ce0: 0a000096 beq 30026f40 <killinfo+0x284> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
30026ce4: e2454001 sub r4, r5, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
30026ce8: e354001f cmp r4, #31 <== NOT EXECUTED 30026cec: 8a000093 bhi 30026f40 <killinfo+0x284> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
30026cf0: e59f6274 ldr r6, [pc, #628] ; 30026f6c <killinfo+0x2b0> <== NOT EXECUTED 30026cf4: e1a07085 lsl r7, r5, #1 <== NOT EXECUTED 30026cf8: e0873005 add r3, r7, r5 <== NOT EXECUTED 30026cfc: e0863103 add r3, r6, r3, lsl #2 <== NOT EXECUTED 30026d00: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30026d04: e3530001 cmp r3, #1 <== NOT EXECUTED
return 0;
30026d08: 03a00000 moveq r0, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
30026d0c: 0a00006d beq 30026ec8 <killinfo+0x20c> <== NOT EXECUTED
/* * 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 ) )
30026d10: e3550008 cmp r5, #8 <== NOT EXECUTED 30026d14: 13550004 cmpne r5, #4 <== NOT EXECUTED 30026d18: 0a00006c beq 30026ed0 <killinfo+0x214> <== NOT EXECUTED 30026d1c: e355000b cmp r5, #11 <== NOT EXECUTED 30026d20: 0a00006a beq 30026ed0 <killinfo+0x214> <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
30026d24: e3a03001 mov r3, #1 <== NOT EXECUTED
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
30026d28: e3580000 cmp r8, #0 <== NOT EXECUTED
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
30026d2c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
30026d30: e58d5000 str r5, [sp] <== NOT EXECUTED 30026d34: e1a04413 lsl r4, r3, r4 <== NOT EXECUTED
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
30026d38: 15983000 ldrne r3, [r8] <== NOT EXECUTED
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
30026d3c: 058d8008 streq r8, [sp, #8] <== NOT EXECUTED
} else {
siginfo->si_value = *value;
30026d40: 158d3008 strne r3, [sp, #8] <== NOT EXECUTED 30026d44: e59f3224 ldr r3, [pc, #548] ; 30026f70 <killinfo+0x2b4> <== NOT EXECUTED 30026d48: e5932000 ldr r2, [r3] <== NOT EXECUTED 30026d4c: e2822001 add r2, r2, #1 <== NOT EXECUTED 30026d50: e5832000 str r2, [r3] <== NOT EXECUTED
/*
* 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;
30026d54: e59f3218 ldr r3, [pc, #536] ; 30026f74 <killinfo+0x2b8> <== NOT EXECUTED 30026d58: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
30026d5c: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED 30026d60: e59330d0 ldr r3, [r3, #208] ; 0xd0 <== NOT EXECUTED 30026d64: e1d43003 bics r3, r4, r3 <== NOT EXECUTED 30026d68: 1a000048 bne 30026e90 <killinfo+0x1d4> <== NOT EXECUTED
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
30026d6c: e59fc204 ldr ip, [pc, #516] ; 30026f78 <killinfo+0x2bc> <== NOT EXECUTED 30026d70: e49c3004 ldr r3, [ip], #4 <== 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 );
30026d74: e153000c cmp r3, ip <== NOT EXECUTED 30026d78: 0a000013 beq 30026dcc <killinfo+0x110> <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30026d7c: e5932030 ldr r2, [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;
30026d80: e1a00003 mov r0, r3 <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30026d84: e1140002 tst r4, r2 <== 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 ];
30026d88: e59320fc ldr r2, [r3, #252] ; 0xfc <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30026d8c: 1a00003f bne 30026e90 <killinfo+0x1d4> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
30026d90: e59220d0 ldr r2, [r2, #208] ; 0xd0 <== NOT EXECUTED 30026d94: e1d42002 bics r2, r4, r2 <== NOT EXECUTED 30026d98: 0a000008 beq 30026dc0 <killinfo+0x104> <== NOT EXECUTED 30026d9c: ea00003b b 30026e90 <killinfo+0x1d4> <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30026da0: e5932030 ldr r2, [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;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
30026da4: 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)
30026da8: e1140002 tst r4, r2 <== 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;
30026dac: e1a00003 mov r0, r3 <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
30026db0: 1a000036 bne 30026e90 <killinfo+0x1d4> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
30026db4: e59120d0 ldr r2, [r1, #208] ; 0xd0 <== NOT EXECUTED 30026db8: e1d42002 bics r2, r4, r2 <== NOT EXECUTED 30026dbc: 1a000033 bne 30026e90 <killinfo+0x1d4> <== 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 ) {
30026dc0: 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 );
30026dc4: e153000c cmp r3, ip <== NOT EXECUTED 30026dc8: 1afffff4 bne 30026da0 <killinfo+0xe4> <== NOT EXECUTED
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
30026dcc: e59f31a8 ldr r3, [pc, #424] ; 30026f7c <killinfo+0x2c0> <== NOT EXECUTED 30026dd0: e59fa1a8 ldr sl, [pc, #424] ; 30026f80 <killinfo+0x2c4> <== NOT EXECUTED 30026dd4: e5d3e000 ldrb lr, [r3] <== NOT EXECUTED
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
30026dd8: e3a08000 mov r8, #0 <== NOT EXECUTED
interested_priority = PRIORITY_MAXIMUM + 1;
30026ddc: e28ee001 add lr, lr, #1 <== NOT EXECUTED
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 ] )
30026de0: e5ba3004 ldr r3, [sl, #4]! <== NOT EXECUTED 30026de4: e3530000 cmp r3, #0 <== NOT EXECUTED 30026de8: 0a000022 beq 30026e78 <killinfo+0x1bc> <== NOT EXECUTED
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
30026dec: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
30026df0: e1d3c1b0 ldrh ip, [r3, #16] <== NOT EXECUTED
object_table = the_info->local_table;
30026df4: e593101c ldr r1, [r3, #28] <== NOT EXECUTED
for ( index = 1 ; index <= maximum ; index++ ) {
30026df8: e35c0000 cmp ip, #0 <== NOT EXECUTED 30026dfc: 0a00001d beq 30026e78 <killinfo+0x1bc> <== NOT EXECUTED 30026e00: e3a02001 mov r2, #1 <== NOT EXECUTED
the_thread = (Thread_Control *) object_table[ index ];
30026e04: e5b13004 ldr r3, [r1, #4]! <== NOT EXECUTED
if ( !the_thread )
30026e08: e3530000 cmp r3, #0 <== NOT EXECUTED 30026e0c: 0a000016 beq 30026e6c <killinfo+0x1b0> <== NOT EXECUTED
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
30026e10: e5930014 ldr r0, [r3, #20] <== NOT EXECUTED 30026e14: e150000e cmp r0, lr <== NOT EXECUTED 30026e18: 8a000013 bhi 30026e6c <killinfo+0x1b0> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
30026e1c: e59390fc ldr r9, [r3, #252] ; 0xfc <== NOT EXECUTED 30026e20: e59990d0 ldr r9, [r9, #208] ; 0xd0 <== NOT EXECUTED 30026e24: e1d49009 bics r9, r4, r9 <== NOT EXECUTED 30026e28: 0a00000f beq 30026e6c <killinfo+0x1b0> <== NOT EXECUTED
*
* 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 ) {
30026e2c: e150000e cmp r0, lr <== NOT EXECUTED 30026e30: 3a000037 bcc 30026f14 <killinfo+0x258> <== 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 ) ) {
30026e34: e3580000 cmp r8, #0 <== NOT EXECUTED 30026e38: 0a00000b beq 30026e6c <killinfo+0x1b0> <== NOT EXECUTED 30026e3c: e5989010 ldr r9, [r8, #16] <== NOT EXECUTED 30026e40: e3590000 cmp r9, #0 <== NOT EXECUTED 30026e44: 0a000008 beq 30026e6c <killinfo+0x1b0> <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
30026e48: e593b010 ldr fp, [r3, #16] <== NOT EXECUTED 30026e4c: e35b0000 cmp fp, #0 <== NOT EXECUTED 30026e50: 0a00002f beq 30026f14 <killinfo+0x258> <== NOT EXECUTED
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
30026e54: e3190201 tst r9, #268435456 ; 0x10000000 <== NOT EXECUTED 30026e58: 1a000003 bne 30026e6c <killinfo+0x1b0> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
30026e5c: e20bb201 and fp, fp, #268435456 ; 0x10000000 <== NOT EXECUTED
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
30026e60: e35b0000 cmp fp, #0 <== NOT EXECUTED 30026e64: 11a0e000 movne lr, r0 <== NOT EXECUTED 30026e68: 11a08003 movne r8, r3 <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
30026e6c: e2822001 add r2, r2, #1 <== NOT EXECUTED 30026e70: e15c0002 cmp ip, r2 <== NOT EXECUTED 30026e74: 2affffe2 bcs 30026e04 <killinfo+0x148> <== NOT EXECUTED
* + 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++) {
30026e78: e59f3104 ldr r3, [pc, #260] ; 30026f84 <killinfo+0x2c8> <== NOT EXECUTED 30026e7c: e15a0003 cmp sl, r3 <== NOT EXECUTED 30026e80: 1affffd6 bne 30026de0 <killinfo+0x124> <== NOT EXECUTED
}
}
}
}
if ( interested ) {
30026e84: e3580000 cmp r8, #0 <== NOT EXECUTED 30026e88: 0a000005 beq 30026ea4 <killinfo+0x1e8> <== NOT EXECUTED 30026e8c: e1a00008 mov r0, r8 <== NOT EXECUTED
/*
* 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 ) ) {
30026e90: e1a01005 mov r1, r5 <== NOT EXECUTED 30026e94: e1a0200d mov r2, sp <== NOT EXECUTED 30026e98: eb000046 bl 30026fb8 <_POSIX_signals_Unblock_thread> <== NOT EXECUTED 30026e9c: e3500000 cmp r0, #0 <== NOT EXECUTED 30026ea0: 1a000006 bne 30026ec0 <killinfo+0x204> <== 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 );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
30026ea4: e0875005 add r5, r7, r5 <== 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 );
30026ea8: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
30026eac: e1a05105 lsl r5, r5, #2 <== 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 );
30026eb0: eb000036 bl 30026f90 <_POSIX_signals_Set_process_signals> <== NOT EXECUTED
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
30026eb4: e7963005 ldr r3, [r6, r5] <== NOT EXECUTED 30026eb8: e3530002 cmp r3, #2 <== NOT EXECUTED 30026ebc: 0a000007 beq 30026ee0 <killinfo+0x224> <== NOT EXECUTED
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
30026ec0: ebffaa12 bl 30011710 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30026ec4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30026ec8: e28dd00c add sp, sp, #12 <== NOT EXECUTED
30026ecc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* 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 ) )
return pthread_kill( pthread_self(), sig );
30026ed0: eb0000b9 bl 300271bc <pthread_self> <== NOT EXECUTED 30026ed4: e1a01005 mov r1, r5 <== NOT EXECUTED 30026ed8: eb000081 bl 300270e4 <pthread_kill> <== NOT EXECUTED 30026edc: eafffff9 b 30026ec8 <killinfo+0x20c> <== NOT EXECUTED
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
30026ee0: e59f00a0 ldr r0, [pc, #160] ; 30026f88 <killinfo+0x2cc> <== NOT EXECUTED 30026ee4: ebffa30e bl 3000fb24 <_Chain_Get> <== NOT EXECUTED
if ( !psiginfo ) {
30026ee8: e250c000 subs ip, r0, #0 <== NOT EXECUTED 30026eec: 0a000018 beq 30026f54 <killinfo+0x298> <== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
30026ef0: e28c3008 add r3, ip, #8 <== NOT EXECUTED
30026ef4: e1a0200d mov r2, sp <== NOT EXECUTED
30026ef8: e8920007 ldm r2, {r0, r1, r2} <== NOT EXECUTED
30026efc: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
30026f00: e59f0084 ldr r0, [pc, #132] ; 30026f8c <killinfo+0x2d0> <== NOT EXECUTED 30026f04: e1a0100c mov r1, ip <== NOT EXECUTED 30026f08: e0800005 add r0, r0, r5 <== NOT EXECUTED 30026f0c: ebffa2f1 bl 3000fad8 <_Chain_Append> <== NOT EXECUTED 30026f10: eaffffea b 30026ec0 <killinfo+0x204> <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
30026f14: e2822001 add r2, r2, #1 <== NOT EXECUTED 30026f18: e15c0002 cmp ip, r2 <== 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 ) ) {
30026f1c: e1a0e000 mov lr, r0 <== NOT EXECUTED 30026f20: e1a08003 mov r8, r3 <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
30026f24: 2affffb6 bcs 30026e04 <killinfo+0x148> <== NOT EXECUTED 30026f28: eaffffd2 b 30026e78 <killinfo+0x1bc> <== NOT EXECUTED
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
30026f2c: ebffc217 bl 30017790 <__errno> <== NOT EXECUTED 30026f30: e3a03003 mov r3, #3 <== NOT EXECUTED 30026f34: e5803000 str r3, [r0] <== NOT EXECUTED 30026f38: e3e00000 mvn r0, #0 <== NOT EXECUTED 30026f3c: eaffffe1 b 30026ec8 <killinfo+0x20c> <== NOT EXECUTED
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
30026f40: ebffc212 bl 30017790 <__errno> <== NOT EXECUTED 30026f44: e3a03016 mov r3, #22 <== NOT EXECUTED 30026f48: e5803000 str r3, [r0] <== NOT EXECUTED 30026f4c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30026f50: eaffffdc b 30026ec8 <killinfo+0x20c> <== NOT EXECUTED
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
_Thread_Enable_dispatch();
30026f54: ebffa9ed bl 30011710 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
30026f58: ebffc20c bl 30017790 <__errno> <== NOT EXECUTED 30026f5c: e3a0300b mov r3, #11 <== NOT EXECUTED 30026f60: e5803000 str r3, [r0] <== NOT EXECUTED 30026f64: e3e00000 mvn r0, #0 <== NOT EXECUTED 30026f68: eaffffd6 b 30026ec8 <killinfo+0x20c> <== NOT EXECUTED
30008d78 <lchown>:
int lchown(
const char *path,
uid_t owner,
gid_t group
)
{
30008d78: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 30008d7c: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
return _chown_helper( path, owner, group, false );
30008d80: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 30008d84: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED 30008d88: e3a03000 mov r3, #0 <== NOT EXECUTED 30008d8c: eaffff01 b 30008998 <_chown_helper> <== NOT EXECUTED
30009b84 <link>:
int link(
const char *existing,
const char *new
)
{
30009b84: e92d4070 push {r4, r5, r6, lr}
30009b88: e24dd034 sub sp, sp, #52 ; 0x34
30009b8c: e1a05001 mov r5, r1
30009b90: e1a06000 mov r6, r0
/*
* Get the node we are linking to.
*/
result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
30009b94: eb003d96 bl 300191f4 <strlen> 30009b98: e28d4018 add r4, sp, #24 30009b9c: e3a03001 mov r3, #1 30009ba0: e1a01000 mov r1, r0 30009ba4: e58d3000 str r3, [sp] 30009ba8: e3a02000 mov r2, #0 30009bac: e1a00006 mov r0, r6 30009bb0: e1a03004 mov r3, r4 30009bb4: ebfffdf2 bl 30009384 <rtems_filesystem_evaluate_path>
0, &existing_loc, true );
if ( result != 0 )
30009bb8: e3500000 cmp r0, #0
return -1;
30009bbc: 13e05000 mvnne r5, #0
* Get the node we are linking to.
*/
result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
0, &existing_loc, true );
if ( result != 0 )
30009bc0: 0a000002 beq 30009bd0 <link+0x4c>
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
return result;
}
30009bc4: e1a00005 mov r0, r5
30009bc8: e28dd034 add sp, sp, #52 ; 0x34
30009bcc: e8bd8070 pop {r4, r5, r6, pc}
/*
* Get the parent of the node we are creating.
*/
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
30009bd0: e28d6004 add r6, sp, #4 30009bd4: e1a00005 mov r0, r5 30009bd8: e1a02006 mov r2, r6 30009bdc: e28d1030 add r1, sp, #48 ; 0x30 30009be0: eb0004c3 bl 3000aef4 <rtems_filesystem_get_start_loc>
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
30009be4: e59d0030 ldr r0, [sp, #48] ; 0x30 30009be8: e1a01006 mov r1, r6 30009bec: e0850000 add r0, r5, r0 30009bf0: e28d202c add r2, sp, #44 ; 0x2c 30009bf4: e59d3010 ldr r3, [sp, #16] 30009bf8: e1a0e00f mov lr, pc 30009bfc: e593f004 ldr pc, [r3, #4]
if ( result != 0 ) {
30009c00: e3500000 cmp r0, #0
30009c04: 1a000018 bne 30009c6c <link+0xe8>
/*
* Check to see if the caller is trying to link across file system
* boundaries.
*/
if ( parent_loc.mt_entry != existing_loc.mt_entry ) {
30009c08: e59d3028 ldr r3, [sp, #40] ; 0x28 30009c0c: e59d2014 ldr r2, [sp, #20] 30009c10: e1520003 cmp r2, r3
30009c14: 1a00000b bne 30009c48 <link+0xc4>
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
30009c18: e1a01006 mov r1, r6 <== NOT EXECUTED 30009c1c: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED 30009c20: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30009c24: e1a00004 mov r0, r4 <== NOT EXECUTED 30009c28: e1a0e00f mov lr, pc <== NOT EXECUTED 30009c2c: e593f008 ldr pc, [r3, #8] <== NOT EXECUTED 30009c30: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &existing_loc );
30009c34: e1a00004 mov r0, r4 <== NOT EXECUTED 30009c38: ebfffe89 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &parent_loc );
30009c3c: e1a00006 mov r0, r6 <== NOT EXECUTED 30009c40: ebfffe87 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
30009c44: eaffffde b 30009bc4 <link+0x40> <== 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 ) {
rtems_filesystem_freenode( &existing_loc );
30009c48: e1a00004 mov r0, r4 30009c4c: ebfffe84 bl 30009664 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &parent_loc );
30009c50: e1a00006 mov r0, r6 30009c54: ebfffe82 bl 30009664 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
30009c58: eb003062 bl 30015de8 <__errno> 30009c5c: e3a03012 mov r3, #18 30009c60: e5803000 str r3, [r0] 30009c64: e3e05000 mvn r5, #0 30009c68: eaffffd5 b 30009bc4 <link+0x40>
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
if ( result != 0 ) {
rtems_filesystem_freenode( &existing_loc );
30009c6c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009c70: ebfffe7b bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
return -1;
30009c74: e3e05000 mvn r5, #0 <== NOT EXECUTED 30009c78: eaffffd1 b 30009bc4 <link+0x40> <== NOT EXECUTED
30009990 <lio_listio>:
int mode __attribute__((unused)),
struct aiocb * const list[] __attribute__((unused)),
int nent __attribute__((unused)),
struct sigevent *sig __attribute__((unused))
)
{
30009990: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009994: eb00240f bl 300129d8 <__errno> <== NOT EXECUTED 30009998: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 3000999c: e5803000 str r3, [r0] <== NOT EXECUTED
}
300099a0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300099a4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30017744 <lseek>:
{
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
30017744: e59fc0fc ldr ip, [pc, #252] ; 30017848 <lseek+0x104>
off_t lseek(
int fd,
off_t offset,
int whence
)
{
30017748: e92d4870 push {r4, r5, r6, fp, lr}
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
3001774c: e59cc000 ldr ip, [ip] 30017750: e150000c cmp r0, ip
30017754: 2a000035 bcs 30017830 <lseek+0xec> iop = rtems_libio_iop( fd );
30017758: e59fc0ec ldr ip, [pc, #236] ; 3001784c <lseek+0x108> 3001775c: e0600180 rsb r0, r0, r0, lsl #3 30017760: e59cc000 ldr ip, [ip] 30017764: e08c4180 add r4, ip, r0, lsl #3
rtems_libio_check_is_open(iop);
30017768: e5940014 ldr r0, [r4, #20] 3001776c: e3100c01 tst r0, #256 ; 0x100
30017770: 0a00002e beq 30017830 <lseek+0xec>
/*
* Now process the lseek().
*/
old_offset = iop->offset;
switch ( whence ) {
30017774: e3530001 cmp r3, #1
/*
* Now process the lseek().
*/
old_offset = iop->offset;
30017778: e284600c add r6, r4, #12
3001777c: e8960060 ldm r6, {r5, r6}
switch ( whence ) {
30017780: 0a00001d beq 300177fc <lseek+0xb8>
30017784: e3530002 cmp r3, #2
30017788: 0a00000e beq 300177c8 <lseek+0x84>
3001778c: e3530000 cmp r3, #0
30017790: 1a00001e bne 30017810 <lseek+0xcc>
case SEEK_SET:
iop->offset = offset;
30017794: e584100c str r1, [r4, #12] 30017798: e5842010 str r2, [r4, #16]
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
3001779c: e594c020 ldr ip, [r4, #32] 300177a0: e1a00004 mov r0, r4 300177a4: e1a0e00f mov lr, pc 300177a8: e59cf014 ldr pc, [ip, #20]
if ( status == (off_t) -1 )
300177ac: 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 );
300177b0: e1a02000 mov r2, r0 300177b4: e1a03001 mov r3, r1
if ( status == (off_t) -1 )
300177b8: 0a000008 beq 300177e0 <lseek+0x9c>
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
300177bc: e1a00002 mov r0, r2
300177c0: e1a01003 mov r1, r3
300177c4: e8bd8870 pop {r4, r5, r6, fp, pc}
case SEEK_CUR:
iop->offset += offset;
break;
case SEEK_END:
iop->offset = iop->size + offset;
300177c8: e9941800 ldmib r4, {fp, ip}
300177cc: e09bb001 adds fp, fp, r1
300177d0: e0acc002 adc ip, ip, r2
300177d4: e584b00c str fp, [r4, #12]
300177d8: e584c010 str ip, [r4, #16]
break;
300177dc: eaffffee b 3001779c <lseek+0x58>
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
if ( status == (off_t) -1 )
300177e0: e3710001 cmn r1, #1
300177e4: 1afffff4 bne 300177bc <lseek+0x78>
iop->offset = old_offset;
300177e8: e584500c str r5, [r4, #12] 300177ec: e5846010 str r6, [r4, #16]
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
300177f0: e1a00002 mov r0, r2
300177f4: e1a01003 mov r1, r3
300177f8: e8bd8870 pop {r4, r5, r6, fp, pc}
case SEEK_SET:
iop->offset = offset;
break;
case SEEK_CUR:
iop->offset += offset;
300177fc: e091b005 adds fp, r1, r5 30017800: e0a2c006 adc ip, r2, r6 30017804: e584b00c str fp, [r4, #12] 30017808: e584c010 str ip, [r4, #16]
break;
3001780c: eaffffe2 b 3001779c <lseek+0x58>
case SEEK_END:
iop->offset = iop->size + offset;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30017810: ebffea17 bl 30012074 <__errno> 30017814: e3a03016 mov r3, #22 30017818: e5803000 str r3, [r0] 3001781c: e3e02000 mvn r2, #0 30017820: e3e03000 mvn r3, #0
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
30017824: e1a00002 mov r0, r2
30017828: e1a01003 mov r1, r3
3001782c: e8bd8870 pop {r4, r5, r6, fp, pc}
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30017830: ebffea0f bl 30012074 <__errno> <== NOT EXECUTED 30017834: e3a03009 mov r3, #9 <== NOT EXECUTED 30017838: e5803000 str r3, [r0] <== NOT EXECUTED 3001783c: e3e02000 mvn r2, #0 <== NOT EXECUTED 30017840: e3e03000 mvn r3, #0 <== NOT EXECUTED 30017844: eaffffdc b 300177bc <lseek+0x78> <== NOT EXECUTED
30008828 <lstat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
30008828: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
3000882c: e2515000 subs r5, r1, #0 <== NOT EXECUTED
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
30008830: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 30008834: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
30008838: 0a000018 beq 300088a0 <lstat+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
3000883c: eb003622 bl 300160cc <strlen> <== NOT EXECUTED 30008840: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30008844: e1a01000 mov r1, r0 <== NOT EXECUTED 30008848: e3a02000 mov r2, #0 <== NOT EXECUTED 3000884c: e1a00006 mov r0, r6 <== NOT EXECUTED 30008850: e1a03004 mov r3, r4 <== NOT EXECUTED 30008854: e58d2000 str r2, [sp] <== NOT EXECUTED 30008858: ebfffe25 bl 300080f4 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
3000885c: e2501000 subs r1, r0, #0 <== NOT EXECUTED
return -1;
30008860: 13e05000 mvnne r5, #0 <== NOT EXECUTED
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
30008864: 1a00000a bne 30008894 <lstat+0x6c> <== NOT EXECUTED
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
30008868: e1a00005 mov r0, r5 <== NOT EXECUTED 3000886c: e3a02048 mov r2, #72 ; 0x48 <== NOT EXECUTED 30008870: eb003401 bl 3001587c <memset> <== NOT EXECUTED
status = (*loc.handlers->fstat_h)( &loc, buf );
30008874: e1a01005 mov r1, r5 <== NOT EXECUTED 30008878: e1a00004 mov r0, r4 <== NOT EXECUTED 3000887c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30008880: e1a0e00f mov lr, pc <== NOT EXECUTED 30008884: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED 30008888: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
3000888c: e1a00004 mov r0, r4 <== NOT EXECUTED 30008890: ebfffe51 bl 300081dc <rtems_filesystem_freenode> <== NOT EXECUTED
return status;
}
30008894: e1a00005 mov r0, r5 <== NOT EXECUTED
30008898: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3000889c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
300088a0: eb002f41 bl 300145ac <__errno> <== NOT EXECUTED 300088a4: e3a0300e mov r3, #14 <== NOT EXECUTED 300088a8: e5803000 str r3, [r0] <== NOT EXECUTED 300088ac: e3e05000 mvn r5, #0 <== NOT EXECUTED 300088b0: eafffff7 b 30008894 <lstat+0x6c> <== NOT EXECUTED
30006800 <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
30006800: e59f30d4 ldr r3, [pc, #212] ; 300068dc <malloc+0xdc>
#include "malloc_p.h"
void *malloc(
size_t size
)
{
30006804: e92d4030 push {r4, r5, lr}
void *return_this;
MSBUMP(malloc_calls, 1);
30006808: e5932004 ldr r2, [r3, #4]
#include "malloc_p.h"
void *malloc(
size_t size
)
{
3000680c: e1a04000 mov r4, r0
void *return_this;
MSBUMP(malloc_calls, 1);
30006810: e2822001 add r2, r2, #1 30006814: e5832004 str r2, [r3, #4]
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
30006818: ebffffb0 bl 300066e0 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
3000681c: e3540000 cmp r4, #0
return (void *) 0;
30006820: 01a05004 moveq r5, r4
malloc_deferred_frees_process();
/*
* Validate the parameters
*/
if ( !size )
30006824: 0a000018 beq 3000688c <malloc+0x8c>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30006828: e59f30b0 ldr r3, [pc, #176] ; 300068e0 <malloc+0xe0> 3000682c: e5933000 ldr r3, [r3] 30006830: e3530003 cmp r3, #3
30006834: 0a000024 beq 300068cc <malloc+0xcc>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
30006838: e59f30a4 ldr r3, [pc, #164] ; 300068e4 <malloc+0xe4> 3000683c: e3a02000 mov r2, #0 30006840: e5930000 ldr r0, [r3] 30006844: e1a01004 mov r1, r4 30006848: e1a03002 mov r3, r2 3000684c: eb001388 bl 3000b674 <_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 ) {
30006850: e2505000 subs r5, r0, #0
30006854: 0a00000e beq 30006894 <malloc+0x94>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
30006858: e59f3088 ldr r3, [pc, #136] ; 300068e8 <malloc+0xe8> 3000685c: e5933000 ldr r3, [r3] 30006860: e3530000 cmp r3, #0
(*rtems_malloc_dirty_helper)( return_this, size );
30006864: 11a00005 movne r0, r5 30006868: 11a01004 movne r1, r4 3000686c: 11a0e00f movne lr, pc 30006870: 112fff13 bxne r3
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
30006874: e59f3070 ldr r3, [pc, #112] ; 300068ec <malloc+0xec> 30006878: e5933000 ldr r3, [r3] 3000687c: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
30006880: 11a00005 movne r0, r5 30006884: 11a0e00f movne lr, pc 30006888: 1593f004 ldrne pc, [r3, #4]
return return_this;
}
3000688c: e1a00005 mov r0, r5
30006890: e8bd8030 pop {r4, r5, pc}
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
30006894: e59f3054 ldr r3, [pc, #84] ; 300068f0 <malloc+0xf0> 30006898: e5933000 ldr r3, [r3] 3000689c: e3530000 cmp r3, #0
300068a0: 0a000005 beq 300068bc <malloc+0xbc>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
300068a4: e1a00004 mov r0, r4 <== NOT EXECUTED 300068a8: e1a0e00f mov lr, pc <== NOT EXECUTED 300068ac: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
if ( !return_this ) {
300068b0: e3500000 cmp r0, #0 <== NOT EXECUTED 300068b4: 11a05000 movne r5, r0 <== NOT EXECUTED 300068b8: 1affffe6 bne 30006858 <malloc+0x58> <== NOT EXECUTED
errno = ENOMEM;
300068bc: eb002dec bl 30012074 <__errno> 300068c0: e3a0300c mov r3, #12 300068c4: e5803000 str r3, [r0]
return (void *) 0;
300068c8: eaffffef b 3000688c <malloc+0x8c>
/*
* 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() )
300068cc: ebffff6f bl 30006690 <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()) &&
300068d0: e2505000 subs r5, r0, #0
300068d4: 1affffd7 bne 30006838 <malloc+0x38>
300068d8: eaffffeb b 3000688c <malloc+0x8c> <== NOT EXECUTED
30006704 <malloc_deferred_free>:
void malloc_deferred_free(
void *pointer
)
{
30006704: 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 );
30006708: e59f0000 ldr r0, [pc, #0] ; 30006710 <malloc_deferred_free+0xc><== NOT EXECUTED 3000670c: ea000f83 b 3000a520 <_Chain_Append> <== NOT EXECUTED
300066e0 <malloc_deferred_frees_process>:
void malloc_deferred_frees_process(void)
{
300066e0: 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)
300066e4: ea000000 b 300066ec <malloc_deferred_frees_process+0xc>
free(to_be_freed);
300066e8: ebffff6a bl 30006498 <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
300066ec: e59f000c ldr r0, [pc, #12] ; 30006700 <malloc_deferred_frees_process+0x20> 300066f0: eb000f9d bl 3000a56c <_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)
300066f4: e3500000 cmp r0, #0
300066f8: 1afffffa bne 300066e8 <malloc_deferred_frees_process+0x8>
free(to_be_freed);
}
300066fc: e49df004 pop {pc} ; (ldr pc, [sp], #4)
300069bc <malloc_get_heap_pointer>:
#include <rtems.h>
#include <rtems/libcsupport.h>
#include "malloc_p.h"
Heap_Control *malloc_get_heap_pointer( void )
{
300069bc: e59f3004 ldr r3, [pc, #4] ; 300069c8 <malloc_get_heap_pointer+0xc><== NOT EXECUTED
return RTEMS_Malloc_Heap; }
300069c0: e5930000 ldr r0, [r3] <== NOT EXECUTED 300069c4: e12fff1e bx lr <== NOT EXECUTED
30006748 <malloc_get_statistics>:
#include "malloc_p.h"
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
30006748: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !stats )
3000674c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30006750: 0a00000e beq 30006790 <malloc_get_statistics+0x48> <== NOT EXECUTED
return -1;
_RTEMS_Lock_allocator();
30006754: e59f503c ldr r5, [pc, #60] ; 30006798 <malloc_get_statistics+0x50><== NOT EXECUTED 30006758: e5950000 ldr r0, [r5] <== NOT EXECUTED 3000675c: eb000f52 bl 3000a4ac <_API_Mutex_Lock> <== NOT EXECUTED
*stats = rtems_malloc_statistics;
30006760: e59fe034 ldr lr, [pc, #52] ; 3000679c <malloc_get_statistics+0x54><== NOT EXECUTED
30006764: e1a0c004 mov ip, r4 <== NOT EXECUTED
30006768: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
3000676c: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30006770: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30006774: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30006778: e89e0007 ldm lr, {r0, r1, r2} <== NOT EXECUTED
3000677c: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
_RTEMS_Unlock_allocator();
30006780: e5950000 ldr r0, [r5] <== NOT EXECUTED 30006784: eb000f64 bl 3000a51c <_API_Mutex_Unlock> <== NOT EXECUTED
return 0;
30006788: e3a00000 mov r0, #0 <== NOT EXECUTED
3000678c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
if ( !stats )
return -1;
30006790: e3e00000 mvn r0, #0 <== NOT EXECUTED
_RTEMS_Lock_allocator(); *stats = rtems_malloc_statistics; _RTEMS_Unlock_allocator(); return 0; }
30006794: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000a730 <malloc_info>:
int malloc_info(
Heap_Information_block *the_info
)
{
if ( !the_info )
3000a730: e2501000 subs r1, r0, #0 <== NOT EXECUTED
*/
int malloc_info(
Heap_Information_block *the_info
)
{
3000a734: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !the_info )
3000a738: 0a000004 beq 3000a750 <malloc_info+0x20> <== NOT EXECUTED
return -1;
_Protected_heap_Get_information( RTEMS_Malloc_Heap, the_info );
3000a73c: e59f3014 ldr r3, [pc, #20] ; 3000a758 <malloc_info+0x28> <== NOT EXECUTED 3000a740: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000a744: eb001974 bl 30010d1c <_Protected_heap_Get_information> <== NOT EXECUTED
return 0;
3000a748: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a74c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int malloc_info(
Heap_Information_block *the_info
)
{
if ( !the_info )
return -1;
3000a750: e3e00000 mvn r0, #0 <== NOT EXECUTED
_Protected_heap_Get_information( RTEMS_Malloc_Heap, the_info );
return 0;
}
3000a754: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006690 <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 )
30006690: e59f3024 ldr r3, [pc, #36] ; 300066bc <malloc_is_system_state_OK+0x2c> 30006694: e5933000 ldr r3, [r3] 30006698: e3530000 cmp r3, #0
3000669c: 1a000004 bne 300066b4 <malloc_is_system_state_OK+0x24>
return false;
if ( _ISR_Nest_level > 0 )
300066a0: e59f3018 ldr r3, [pc, #24] ; 300066c0 <malloc_is_system_state_OK+0x30>
#include "malloc_p.h"
rtems_chain_control RTEMS_Malloc_GC_list;
bool malloc_is_system_state_OK(void)
300066a4: e5930000 ldr r0, [r3] 300066a8: e2700001 rsbs r0, r0, #1 300066ac: 33a00000 movcc r0, #0 300066b0: e12fff1e bx lr
{
if ( _Thread_Dispatch_disable_level > 0 )
return false;
300066b4: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( _ISR_Nest_level > 0 )
return false;
return true;
}
300066b8: e12fff1e bx lr <== NOT EXECUTED
3000a93c <malloc_report_statistics>:
#ifdef RTEMS_NEWLIB
#include "malloc_p.h"
void malloc_report_statistics(void)
{
malloc_report_statistics_with_plugin( NULL, printk_plugin );
3000a93c: e59f1004 ldr r1, [pc, #4] ; 3000a948 <malloc_report_statistics+0xc><== NOT EXECUTED 3000a940: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a944: ea000000 b 3000a94c <malloc_report_statistics_with_plugin> <== NOT EXECUTED
3000a94c <malloc_report_statistics_with_plugin>:
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a94c: e92d4df0 push {r4, r5, r6, r7, r8, sl, fp, lr} <== NOT EXECUTED
rtems_malloc_statistics_t *s;
uintmax_t allocated;
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
3000a950: e59f4100 ldr r4, [pc, #256] ; 3000aa58 <malloc_report_statistics_with_plugin+0x10c><== 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,
3000a954: e3a03064 mov r3, #100 ; 0x64 <== NOT EXECUTED
rtems_malloc_statistics_t *s;
uintmax_t allocated;
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
3000a958: e2846024 add r6, r4, #36 ; 0x24 <== NOT EXECUTED
3000a95c: e8960060 ldm r6, {r5, r6} <== NOT EXECUTED
3000a960: e284c01c add ip, r4, #28 <== NOT EXECUTED
3000a964: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
3000a968: e05bb005 subs fp, fp, r5 <== NOT EXECUTED
3000a96c: e0ccc006 sbc ip, ip, r6 <== 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,
3000a970: e086539b umull r5, r6, fp, r3 <== NOT EXECUTED 3000a974: e1a0200c mov r2, ip <== NOT EXECUTED 3000a978: e0226293 mla r2, r3, r2, r6 <== NOT EXECUTED
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a97c: e24dd024 sub sp, sp, #36 ; 0x24 <== 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,
3000a980: e58d501c str r5, [sp, #28] <== NOT EXECUTED 3000a984: e58d6020 str r6, [sp, #32] <== 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,
3000a988: e5946000 ldr r6, [r4] <== NOT EXECUTED
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
3000a98c: e58d2020 str r2, [sp, #32] <== NOT EXECUTED
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a990: e1a08000 mov r8, r0 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a994: e1a02006 mov r2, r6 <== NOT EXECUTED
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a998: e1a0a001 mov sl, r1 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a99c: e3a03000 mov r3, #0 <== NOT EXECUTED
3000a9a0: e28d101c add r1, sp, #28 <== NOT EXECUTED
3000a9a4: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3000a9a8: e1a0552b lsr r5, fp, #10 <== NOT EXECUTED
3000a9ac: e1855b0c orr r5, r5, ip, lsl #22 <== NOT EXECUTED
3000a9b0: e1a0b52c lsr fp, ip, #10 <== NOT EXECUTED
3000a9b4: eb005d18 bl 30021e1c <__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,
3000a9b8: e5947018 ldr r7, [r4, #24] <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a9bc: e98d0003 stmib sp, {r0, r1} <== NOT EXECUTED
s->space_available / 1024,
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
3000a9c0: e0873107 add r3, r7, r7, lsl #2 <== NOT EXECUTED 3000a9c4: e0833103 add r3, r3, r3, lsl #2 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a9c8: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a9cc: e1a07527 lsr r7, r7, #10 <== NOT EXECUTED 3000a9d0: e1a00103 lsl r0, r3, #2 <== NOT EXECUTED 3000a9d4: e58d700c str r7, [sp, #12] <== NOT EXECUTED 3000a9d8: ebfff3fa bl 300079c8 <__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),
3000a9dc: e594101c ldr r1, [r4, #28] <== NOT EXECUTED
(uint32_t) (s->lifetime_freed / 1024)
3000a9e0: e5942024 ldr r2, [r4, #36] ; 0x24 <== 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),
3000a9e4: e594e020 ldr lr, [r4, #32] <== NOT EXECUTED 3000a9e8: e1a0c521 lsr ip, r1, #10 <== NOT EXECUTED
(uint32_t) (s->lifetime_freed / 1024)
3000a9ec: e5941028 ldr r1, [r4, #40] ; 0x28 <== NOT EXECUTED 3000a9f0: e1a03522 lsr r3, r2, #10 <== 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),
3000a9f4: e18ccb0e orr ip, ip, lr, lsl #22 <== NOT EXECUTED
(uint32_t) (s->lifetime_freed / 1024)
3000a9f8: e1833b01 orr r3, r3, r1, lsl #22 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a9fc: e1a02526 lsr r2, r6, #10 <== NOT EXECUTED 3000aa00: e58d0010 str r0, [sp, #16] <== NOT EXECUTED 3000aa04: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000aa08: e59f104c ldr r1, [pc, #76] ; 3000aa5c <malloc_report_statistics_with_plugin+0x110><== NOT EXECUTED 3000aa0c: e1a03005 mov r3, r5 <== NOT EXECUTED 3000aa10: e58dc014 str ip, [sp, #20] <== NOT EXECUTED 3000aa14: e58db000 str fp, [sp] <== NOT EXECUTED 3000aa18: e1a00008 mov r0, r8 <== NOT EXECUTED 3000aa1c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000aa20: 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)(
3000aa24: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
3000aa28: e594100c ldr r1, [r4, #12] <== NOT EXECUTED
3000aa2c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
3000aa30: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
3000aa34: e58d1000 str r1, [sp] <== NOT EXECUTED
3000aa38: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
3000aa3c: e994000c ldmib r4, {r2, r3} <== NOT EXECUTED
3000aa40: e59f1018 ldr r1, [pc, #24] ; 3000aa60 <malloc_report_statistics_with_plugin+0x114><== NOT EXECUTED
3000aa44: e1a00008 mov r0, r8 <== NOT EXECUTED
3000aa48: e1a0e00f mov lr, pc <== NOT EXECUTED
3000aa4c: e12fff1a bx sl <== NOT EXECUTED
s->memalign_calls,
s->free_calls,
s->realloc_calls,
s->calloc_calls
);
}
3000aa50: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
3000aa54: e8bd8df0 pop {r4, r5, r6, r7, r8, sl, fp, pc} <== NOT EXECUTED
30006bac <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;
30006bac: e59f309c ldr r3, [pc, #156] ; 30006c50 <malloc_sbrk_extend_and_allocate+0xa4><== NOT EXECUTED
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
30006bb0: 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;
30006bb4: e5934000 ldr r4, [r3] <== NOT EXECUTED
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
30006bb8: e1a05000 mov r5, r0 <== NOT EXECUTED
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
30006bbc: e3540000 cmp r4, #0 <== NOT EXECUTED
return (void *) 0;
30006bc0: 01a00004 moveq r0, r4 <== NOT EXECUTED
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
30006bc4: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
30006bc8: e1a01004 mov r1, r4 <== NOT EXECUTED 30006bcc: e0850004 add r0, r5, r4 <== NOT EXECUTED 30006bd0: eb003c3d bl 30015ccc <__aeabi_uidiv> <== NOT EXECUTED 30006bd4: e0040490 mul r4, r0, r4 <== NOT EXECUTED
starting_address = (void *) sbrk(the_size);
30006bd8: e1a00004 mov r0, r4 <== NOT EXECUTED 30006bdc: ebfff7df bl 30004b60 <sbrk> <== NOT EXECUTED
if ( starting_address == (void*) -1 )
30006be0: e3700001 cmn r0, #1 <== NOT EXECUTED 30006be4: 0a000010 beq 30006c2c <malloc_sbrk_extend_and_allocate+0x80><== NOT EXECUTED
return (void *) 0;
if ( !_Protected_heap_Extend(
30006be8: e59f6064 ldr r6, [pc, #100] ; 30006c54 <malloc_sbrk_extend_and_allocate+0xa8><== NOT EXECUTED 30006bec: e1a01000 mov r1, r0 <== NOT EXECUTED 30006bf0: e1a02004 mov r2, r4 <== NOT EXECUTED 30006bf4: e5960000 ldr r0, [r6] <== NOT EXECUTED 30006bf8: eb001365 bl 3000b994 <_Protected_heap_Extend> <== NOT EXECUTED 30006bfc: e2507000 subs r7, r0, #0 <== NOT EXECUTED 30006c00: 0a00000b beq 30006c34 <malloc_sbrk_extend_and_allocate+0x88><== NOT EXECUTED
sbrk(-the_size);
errno = ENOMEM;
return (void *) 0;
}
MSBUMP(space_available, the_size);
30006c04: e59fc04c ldr ip, [pc, #76] ; 30006c58 <malloc_sbrk_extend_and_allocate+0xac><== NOT EXECUTED 30006c08: e3a02000 mov r2, #0 <== NOT EXECUTED 30006c0c: e59c3000 ldr r3, [ip] <== NOT EXECUTED 30006c10: e5960000 ldr r0, [r6] <== NOT EXECUTED 30006c14: e0844003 add r4, r4, r3 <== NOT EXECUTED 30006c18: e1a01005 mov r1, r5 <== NOT EXECUTED 30006c1c: e1a03002 mov r3, r2 <== NOT EXECUTED 30006c20: e58c4000 str r4, [ip] <== NOT EXECUTED
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
30006c24: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
30006c28: ea001346 b 3000b948 <_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;
30006c2c: e3a00000 mov r0, #0 <== NOT EXECUTED
MSBUMP(space_available, the_size);
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
30006c30: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( starting_address == (void*) -1 )
return (void *) 0;
if ( !_Protected_heap_Extend(
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
30006c34: e2640000 rsb r0, r4, #0 <== NOT EXECUTED 30006c38: ebfff7c8 bl 30004b60 <sbrk> <== NOT EXECUTED
errno = ENOMEM;
30006c3c: eb002e8a bl 3001266c <__errno> <== NOT EXECUTED 30006c40: e3a0300c mov r3, #12 <== NOT EXECUTED 30006c44: e5803000 str r3, [r0] <== NOT EXECUTED
return (void *) 0;
30006c48: e1a00007 mov r0, r7 <== NOT EXECUTED
30006c4c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30006c5c <malloc_sbrk_initialize>:
)
{
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
30006c5c: e59f3034 ldr r3, [pc, #52] ; 30006c98 <malloc_sbrk_initialize+0x3c><== 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) {
30006c60: e3500000 cmp r0, #0 <== NOT EXECUTED
void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
30006c64: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
30006c68: 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) {
30006c6c: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
uaddress = (uintptr_t)sbrk(length);
30006c70: e1a00001 mov r0, r1 <== NOT EXECUTED 30006c74: ebfff7b9 bl 30004b60 <sbrk> <== NOT EXECUTED
if (uaddress == (uintptr_t) -1) {
30006c78: e3700001 cmn r0, #1 <== NOT EXECUTED 30006c7c: 0a000003 beq 30006c90 <malloc_sbrk_initialize+0x34> <== NOT EXECUTED
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
/* DOES NOT RETURN!!! */
}
if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {
30006c80: e3100007 tst r0, #7 <== NOT EXECUTED
old_address = uaddress;
uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
30006c84: 12800008 addne r0, r0, #8 <== NOT EXECUTED 30006c88: 13c00007 bicne r0, r0, #7 <== NOT EXECUTED
}
starting_address = (void *)uaddress;
}
return starting_address;
}
30006c8c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if (!starting_address) {
uaddress = (uintptr_t)sbrk(length);
if (uaddress == (uintptr_t) -1) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
30006c90: e280001b add r0, r0, #27 <== NOT EXECUTED 30006c94: eb000e2d bl 3000a550 <rtems_fatal_error_occurred> <== NOT EXECUTED
30006c9c <malloc_set_heap_pointer>:
void malloc_set_heap_pointer(
Heap_Control *new_heap
)
{
RTEMS_Malloc_Heap = new_heap;
30006c9c: e59f3004 ldr r3, [pc, #4] ; 30006ca8 <malloc_set_heap_pointer+0xc><== NOT EXECUTED 30006ca0: e5830000 str r0, [r3] <== NOT EXECUTED
}
30006ca4: e12fff1e bx lr <== NOT EXECUTED
3000ab68 <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 );
3000ab68: e2512000 subs r2, r1, #0 <== NOT EXECUTED 3000ab6c: 13a02001 movne r2, #1 <== NOT EXECUTED 3000ab70: e59f100c ldr r1, [pc, #12] ; 3000ab84 <malloc_walk+0x1c> <== NOT EXECUTED
#include "malloc_p.h"
#include <stdlib.h>
void malloc_walk(size_t source, size_t printf_enabled)
{
3000ab74: e1a03000 mov r3, r0 <== NOT EXECUTED
_Protected_heap_Walk( RTEMS_Malloc_Heap, (int) source, printf_enabled );
3000ab78: e5910000 ldr r0, [r1] <== NOT EXECUTED 3000ab7c: e1a01003 mov r1, r3 <== NOT EXECUTED 3000ab80: ea001892 b 30010dd0 <_Protected_heap_Walk> <== NOT EXECUTED
30010a40 <memfile_free_block>:
* Free a block from an in-memory file.
*/
void memfile_free_block(
void *memory
)
{
30010a40: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
free(memory);
30010a44: ebffd693 bl 30006498 <free> <== NOT EXECUTED
memfile_blocks_allocated--;
30010a48: e59f300c ldr r3, [pc, #12] ; 30010a5c <memfile_free_block+0x1c><== NOT EXECUTED 30010a4c: e5932000 ldr r2, [r3] <== NOT EXECUTED 30010a50: e2422001 sub r2, r2, #1 <== NOT EXECUTED 30010a54: e5832000 str r2, [r3] <== NOT EXECUTED
}
30010a58: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30010a60 <memfile_free_blocks_in_table>:
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
30010a60: 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++ ) {
30010a64: e2517000 subs r7, r1, #0 <== NOT EXECUTED
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
30010a68: e1a04000 mov r4, r0 <== NOT EXECUTED
IMFS_assert( block_table );
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
30010a6c: e5900000 ldr r0, [r0] <== NOT EXECUTED
for ( i=0 ; i<entries ; i++ ) {
30010a70: da00000b ble 30010aa4 <memfile_free_blocks_in_table+0x44> <== NOT EXECUTED 30010a74: e3a05000 mov r5, #0 <== NOT EXECUTED 30010a78: e1a06000 mov r6, r0 <== NOT EXECUTED
if ( b[i] ) {
memfile_free_block( b[i] );
b[i] = 0;
30010a7c: e1a08005 mov r8, 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++ ) {
if ( b[i] ) {
30010a80: e4960004 ldr r0, [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++ ) {
30010a84: e2855001 add r5, r5, #1 <== NOT EXECUTED
if ( b[i] ) {
30010a88: e3500000 cmp r0, #0 <== NOT EXECUTED 30010a8c: 0a000001 beq 30010a98 <memfile_free_blocks_in_table+0x38> <== NOT EXECUTED
memfile_free_block( b[i] );
30010a90: ebffffea bl 30010a40 <memfile_free_block> <== NOT EXECUTED
b[i] = 0;
30010a94: e5068004 str r8, [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++ ) {
30010a98: e1570005 cmp r7, r5 <== NOT EXECUTED 30010a9c: cafffff7 bgt 30010a80 <memfile_free_blocks_in_table+0x20> <== NOT EXECUTED 30010aa0: e5940000 ldr r0, [r4] <== 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 );
30010aa4: ebffffe5 bl 30010a40 <memfile_free_block> <== NOT EXECUTED
*block_table = 0;
30010aa8: e3a03000 mov r3, #0 <== NOT EXECUTED 30010aac: e5843000 str r3, [r4] <== NOT EXECUTED
}
30010ab0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30010ff0 <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
30010ff0: e92d4010 push {r4, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
30010ff4: e5904018 ldr r4, [r0, #24]
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
30010ff8: e1a03000 mov r3, r0
* 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 )
30010ffc: e5940054 ldr r0, [r4, #84] ; 0x54
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
30011000: e24dd008 sub sp, sp, #8
* 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 )
30011004: e1500002 cmp r0, r2
30011008: ba00000e blt 30011048 <memfile_ftruncate+0x58> 3001100c: 0a00000a beq 3001103c <memfile_ftruncate+0x4c> /* * 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;
30011010: e5841050 str r1, [r4, #80] ; 0x50 30011014: e5842054 str r2, [r4, #84] ; 0x54
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
30011018: e1a0000d mov r0, sp
* 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; iop->size = the_jnode->info.file.size;
3001101c: e9830006 stmib r3, {r1, r2}
IMFS_update_atime( the_jnode );
30011020: e3a01000 mov r1, #0 30011024: ebffd544 bl 3000653c <gettimeofday> 30011028: e59d3000 ldr r3, [sp]
return 0;
3001102c: 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 );
30011030: e5843040 str r3, [r4, #64] ; 0x40
return 0;
}
30011034: e28dd008 add sp, sp, #8
30011038: e8bd8010 pop {r4, pc}
* 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 )
3001103c: e5940050 ldr r0, [r4, #80] ; 0x50 30011040: e1500001 cmp r0, r1
30011044: 2afffff1 bcs 30011010 <memfile_ftruncate+0x20>
return IMFS_memfile_extend( the_jnode, length );
30011048: e1a00004 mov r0, r4 <== NOT EXECUTED 3001104c: ebfffef2 bl 30010c1c <IMFS_memfile_extend> <== NOT EXECUTED 30011050: eafffff7 b 30011034 <memfile_ftruncate+0x44> <== NOT EXECUTED
30010580 <memfile_ioctl>:
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
return 0;
}
30010580: e3a00000 mov r0, #0 <== NOT EXECUTED 30010584: e12fff1e bx lr <== NOT EXECUTED
30011054 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
30011054: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
30011058: e5905018 ldr r5, [r0, #24]
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
3001105c: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
30011060: e595304c ldr r3, [r5, #76] ; 0x4c 30011064: e3530006 cmp r3, #6
30011068: 0a00000d beq 300110a4 <memfile_lseek+0x50>
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
3001106c: e1a00005 mov r0, r5
30011070: e284200c add r2, r4, #12
30011074: e8920006 ldm r2, {r1, r2}
30011078: ebfffee7 bl 30010c1c <IMFS_memfile_extend>
3001107c: e3500000 cmp r0, #0
30011080: 1a000018 bne 300110e8 <memfile_lseek+0x94>
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
30011084: e2853050 add r3, r5, #80 ; 0x50
30011088: e893000c ldm r3, {r2, r3}
3001108c: e984000c stmib r4, {r2, r3}
30011090: e284300c add r3, r4, #12
30011094: e893000c ldm r3, {r2, r3}
} return iop->offset; }
30011098: e1a00002 mov r0, r2
3001109c: e1a01003 mov r1, r3
300110a0: e8bd8030 pop {r4, r5, pc}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
if (iop->offset > the_jnode->info.linearfile.size)
300110a4: e5951054 ldr r1, [r5, #84] ; 0x54
300110a8: e280300c add r3, r0, #12
300110ac: e893000c ldm r3, {r2, r3}
300110b0: e1530001 cmp r3, r1
300110b4: e5950050 ldr r0, [r5, #80] ; 0x50
300110b8: ca000002 bgt 300110c8 <memfile_lseek+0x74> 300110bc: 1afffff5 bne 30011098 <memfile_lseek+0x44>
300110c0: e1520000 cmp r2, r0
300110c4: 9afffff3 bls 30011098 <memfile_lseek+0x44>
iop->offset = the_jnode->info.linearfile.size;
300110c8: e1a02000 mov r2, r0 <== NOT EXECUTED 300110cc: e1a03001 mov r3, r1 <== NOT EXECUTED 300110d0: e1a05000 mov r5, r0 <== NOT EXECUTED 300110d4: e584000c str r0, [r4, #12] <== NOT EXECUTED 300110d8: e5841010 str r1, [r4, #16] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
}
return iop->offset;
}
300110dc: e1a00002 mov r0, r2 <== NOT EXECUTED
300110e0: e1a01003 mov r1, r3 <== NOT EXECUTED
300110e4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
rtems_set_errno_and_return_minus_one( ENOSPC );
300110e8: eb0003e1 bl 30012074 <__errno> <== NOT EXECUTED 300110ec: e3a0301c mov r3, #28 <== NOT EXECUTED 300110f0: e5803000 str r3, [r0] <== NOT EXECUTED 300110f4: e3e02000 mvn r2, #0 <== NOT EXECUTED 300110f8: e3e03000 mvn r3, #0 <== NOT EXECUTED 300110fc: eaffffe5 b 30011098 <memfile_lseek+0x44> <== NOT EXECUTED
30010f40 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
30010f40: e92d4070 push {r4, r5, r6, lr}
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
30010f44: e5903014 ldr r3, [r0, #20]
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
30010f48: e24dd004 sub sp, sp, #4
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
30010f4c: e3130f81 tst r3, #516 ; 0x204
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
30010f50: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
30010f54: e5905018 ldr r5, [r0, #24]
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
30010f58: 0a000002 beq 30010f68 <memfile_open+0x28>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
30010f5c: e595204c ldr r2, [r5, #76] ; 0x4c 30010f60: e3520006 cmp r2, #6
30010f64: 0a00000a beq 30010f94 <memfile_open+0x54>
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
30010f68: e5950050 ldr r0, [r5, #80] ; 0x50 30010f6c: e5952054 ldr r2, [r5, #84] ; 0x54
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
30010f70: e3130c02 tst r3, #512 ; 0x200
iop->offset = the_jnode->info.file.size;
30010f74: 1584000c strne r0, [r4, #12] 30010f78: 15842010 strne r2, [r4, #16] 30010f7c: 15950050 ldrne r0, [r5, #80] ; 0x50 30010f80: 15952054 ldrne r2, [r5, #84] ; 0x54
iop->size = the_jnode->info.file.size;
30010f84: e9840005 stmib r4, {r0, r2}
return 0;
30010f88: e3a00000 mov r0, #0
}
30010f8c: e28dd004 add sp, sp, #4
30010f90: e8bd8070 pop {r4, r5, r6, pc}
/*
* 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;
30010f94: e595c050 ldr ip, [r5, #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;
30010f98: e3a00000 mov r0, #0 <== NOT EXECUTED
&& (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;
the_jnode->info.file.size = 0;
30010f9c: e3a01000 mov r1, #0 <== NOT EXECUTED 30010fa0: e3a02000 mov r2, #0 <== NOT EXECUTED
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
30010fa4: e3a06005 mov r6, #5 <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
30010fa8: 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;
30010fac: e5953058 ldr r3, [r5, #88] ; 0x58 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
30010fb0: e585604c str r6, [r5, #76] ; 0x4c <== NOT EXECUTED
the_jnode->info.file.size = 0;
30010fb4: e5851050 str r1, [r5, #80] ; 0x50 <== NOT EXECUTED 30010fb8: e5852054 str r2, [r5, #84] ; 0x54 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
30010fbc: e5850058 str r0, [r5, #88] ; 0x58 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
30010fc0: e585005c str r0, [r5, #92] ; 0x5c <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
30010fc4: e5850060 str r0, [r5, #96] ; 0x60 <== NOT EXECUTED
if ((count != 0)
30010fc8: 05943014 ldreq r3, [r4, #20] <== NOT EXECUTED 30010fcc: 01a00001 moveq r0, r1 <== NOT EXECUTED 30010fd0: 0affffe6 beq 30010f70 <memfile_open+0x30> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
30010fd4: e1a00005 mov r0, r5 <== NOT EXECUTED 30010fd8: e58dc000 str ip, [sp] <== NOT EXECUTED 30010fdc: ebffff5b bl 30010d50 <IMFS_memfile_write> <== NOT EXECUTED 30010fe0: e3700001 cmn r0, #1 <== NOT EXECUTED 30010fe4: 0affffe8 beq 30010f8c <memfile_open+0x4c> <== NOT EXECUTED 30010fe8: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 30010fec: eaffffdd b 30010f68 <memfile_open+0x28> <== NOT EXECUTED
30006904 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
30006904: e92d41f0 push {r4, r5, r6, r7, r8, lr}
30006908: e1a04001 mov r4, r1
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
3000690c: e2011a0f and r1, r1, #61440 ; 0xf000 30006910: e3510901 cmp r1, #16384 ; 0x4000
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
30006914: e24dd020 sub sp, sp, #32 30006918: e1a05000 mov r5, r0 3000691c: e1a07002 mov r7, r2 30006920: 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)
30006924: 0a00000f beq 30006968 <mknod+0x64>
30006928: 9a00000a bls 30006958 <mknod+0x54>
3000692c: e3510a06 cmp r1, #24576 ; 0x6000
30006930: 0a00000c beq 30006968 <mknod+0x64>
30006934: e3510902 cmp r1, #32768 ; 0x8000
30006938: 0a00000a beq 30006968 <mknod+0x64>
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000693c: eb002dcc bl 30012074 <__errno> <== NOT EXECUTED 30006940: e3a03016 mov r3, #22 <== NOT EXECUTED 30006944: e5803000 str r3, [r0] <== NOT EXECUTED 30006948: e3e04000 mvn r4, #0 <== NOT EXECUTED
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
rtems_filesystem_freenode( &temp_loc );
return result;
}
3000694c: e1a00004 mov r0, r4
30006950: e28dd020 add sp, sp, #32
30006954: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
30006958: e3510a01 cmp r1, #4096 ; 0x1000
3000695c: 0a000001 beq 30006968 <mknod+0x64>
30006960: e3510a02 cmp r1, #8192 ; 0x2000
30006964: 1afffff4 bne 3000693c <mknod+0x38>
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
30006968: e28d6004 add r6, sp, #4 3000696c: e1a00005 mov r0, r5 30006970: e1a02006 mov r2, r6 30006974: e28d101c add r1, sp, #28 30006978: eb00026c bl 30007330 <rtems_filesystem_get_start_loc>
result = (*temp_loc.ops->evalformake_h)(
3000697c: e59d001c ldr r0, [sp, #28] 30006980: e1a01006 mov r1, r6 30006984: e0850000 add r0, r5, r0 30006988: e28d2018 add r2, sp, #24 3000698c: e59d3010 ldr r3, [sp, #16] 30006990: e1a0e00f mov lr, pc 30006994: e593f004 ldr pc, [r3, #4]
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
30006998: e3500000 cmp r0, #0
return -1;
3000699c: 13e04000 mvnne r4, #0
result = (*temp_loc.ops->evalformake_h)(
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
300069a0: 1affffe9 bne 3000694c <mknod+0x48>
return -1;
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
300069a4: e1a01004 mov r1, r4 300069a8: e1a02007 mov r2, r7 300069ac: e1a03008 mov r3, r8 300069b0: e58d6000 str r6, [sp] 300069b4: e59d0018 ldr r0, [sp, #24] 300069b8: e59dc010 ldr ip, [sp, #16] 300069bc: e1a0e00f mov lr, pc 300069c0: e59cf014 ldr pc, [ip, #20] 300069c4: e1a04000 mov r4, r0
rtems_filesystem_freenode( &temp_loc );
300069c8: e1a00006 mov r0, r6 300069cc: ebfffeac bl 30006484 <rtems_filesystem_freenode>
return result;
300069d0: eaffffdd b 3000694c <mknod+0x48>
30006a60 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
30006a60: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
30006a64: e3530001 cmp r3, #1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
30006a68: e24dd030 sub sp, sp, #48 ; 0x30 30006a6c: e58d3008 str r3, [sp, #8] 30006a70: e1a07000 mov r7, r0 30006a74: e1a06001 mov r6, r1 30006a78: e1a09002 mov r9, r2
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
30006a7c: 8a00009a bhi 30006cec <mount+0x28c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
30006a80: e1a00002 mov r0, r2 30006a84: eb002031 bl 3000eb50 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
30006a88: e3500000 cmp r0, #0 30006a8c: e58d0014 str r0, [sp, #20]
30006a90: 0a000095 beq 30006cec <mount+0x28c>
{
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;
30006a94: e2565000 subs r5, r6, #0 30006a98: 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 : "/";
30006a9c: e3550000 cmp r5, #0
30006aa0: 0a00008a beq 30006cd0 <mount+0x270>
* 4) The mount point exists with the proper permissions to allow mounting
* 5) The selected mount point already has a file system mounted to it
*
*/
int mount(
30006aa4: e1a00006 mov r0, r6 30006aa8: eb00315b bl 3001301c <strlen> 30006aac: e2803001 add r3, r0, #1 30006ab0: e58d0010 str r0, [sp, #16] 30006ab4: e58d300c str r3, [sp, #12] 30006ab8: e58d6018 str r6, [sp, #24]
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;
30006abc: e1a00009 mov r0, r9 30006ac0: eb003155 bl 3001301c <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
30006ac4: e3570000 cmp r7, #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;
30006ac8: e280b001 add fp, r0, #1
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
30006acc: 01a08007 moveq r8, r7
30006ad0: 0a000002 beq 30006ae0 <mount+0x80>
30006ad4: e1a00007 mov r0, r7 30006ad8: eb00314f bl 3001301c <strlen> 30006adc: e2808001 add r8, r0, #1
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
30006ae0: e59d300c ldr r3, [sp, #12]
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
30006ae4: e3a00001 mov r0, #1
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
30006ae8: e2831074 add r1, r3, #116 ; 0x74 30006aec: e081100b add r1, r1, fp
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
30006af0: e0811008 add r1, r1, r8 30006af4: ebfffdfa bl 300062e4 <calloc>
if ( mt_entry != NULL ) {
30006af8: e2504000 subs r4, r0, #0
30006afc: 0a00006e beq 30006cbc <mount+0x25c>
char *str = (char *) mt_entry + sizeof( *mt_entry );
30006b00: e284a074 add sl, r4, #116 ; 0x74
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
30006b04: e08a300b add r3, sl, fp
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
30006b08: e1a01009 mov r1, r9 30006b0c: e1a0200b mov r2, fp 30006b10: e1a0000a mov r0, sl 30006b14: e58d3004 str r3, [sp, #4] 30006b18: eb002f83 bl 3001292c <memcpy>
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
30006b1c: e59d3004 ldr r3, [sp, #4]
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
30006b20: e1a01007 mov r1, r7 30006b24: e1a02008 mov r2, r8 30006b28: e1a00003 mov r0, r3
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
30006b2c: e584a06c str sl, [r4, #108] ; 0x6c
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
30006b30: e0839008 add r9, r3, r8
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
30006b34: eb002f7c bl 3001292c <memcpy>
mt_entry->dev = str;
30006b38: e59d3004 ldr r3, [sp, #4]
str += source_size;
memcpy( str, target, target_size );
30006b3c: e59d1018 ldr r1, [sp, #24] 30006b40: e59d200c ldr r2, [sp, #12]
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
30006b44: e5843070 str r3, [r4, #112] ; 0x70
str += source_size;
memcpy( str, target, target_size );
30006b48: e1a00009 mov r0, r9 30006b4c: eb002f76 bl 3001292c <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;
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
30006b50: e59fe20c ldr lr, [pc, #524] ; 30006d64 <mount+0x304>
30006b54: e284c038 add ip, r4, #56 ; 0x38
30006b58: e8be000f ldm lr!, {r0, r1, r2, r3}
30006b5c: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006b60: e8be000f ldm lr!, {r0, r1, r2, r3}
30006b64: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006b68: e89e000f ldm lr, {r0, r1, r2, r3}
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
30006b6c: e59de008 ldr lr, [sp, #8]
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
30006b70: 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;
30006b74: e5849068 str r9, [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;
30006b78: e584402c str r4, [r4, #44] ; 0x2c
mt_entry->options = options;
30006b7c: e584e030 str lr, [r4, #48] ; 0x30
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
30006b80: 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 ) {
30006b84: 1a000024 bne 30006c1c <mount+0x1bc>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
30006b88: e59f31d8 ldr r3, [pc, #472] ; 30006d68 <mount+0x308>
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
30006b8c: e5932000 ldr r2, [r3]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
30006b90: e2833004 add r3, r3, #4 30006b94: e1520003 cmp r2, r3
)
{
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;
30006b98: 01a07005 moveq r7, r5
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
30006b9c: 1a000057 bne 30006d00 <mount+0x2a0>
* 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 ) ) {
30006ba0: e1a00004 mov r0, r4 30006ba4: e59d1054 ldr r1, [sp, #84] ; 0x54 30006ba8: e59d3014 ldr r3, [sp, #20] 30006bac: e1a0e00f mov lr, pc 30006bb0: e12fff13 bx r3 30006bb4: e2506000 subs r6, r0, #0
30006bb8: 1a000057 bne 30006d1c <mount+0x2bc>
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 );
30006bbc: e59f71a8 ldr r7, [pc, #424] ; 30006d6c <mount+0x30c> 30006bc0: e1a02006 mov r2, r6 30006bc4: e1a01006 mov r1, r6 30006bc8: e5970000 ldr r0, [r7] 30006bcc: eb000be0 bl 30009b54 <rtems_semaphore_obtain> 30006bd0: e59f0190 ldr r0, [pc, #400] ; 30006d68 <mount+0x308> 30006bd4: e1a01004 mov r1, r4 30006bd8: eb000e50 bl 3000a520 <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
30006bdc: e5970000 ldr r0, [r7] 30006be0: eb000c24 bl 30009c78 <rtems_semaphore_release>
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
30006be4: e3550000 cmp r5, #0
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
30006be8: 11a00006 movne r0, r6
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
30006bec: 1a000008 bne 30006c14 <mount+0x1b4>
rtems_filesystem_root = mt_entry->mt_fs_root;
30006bf0: e59f3178 ldr r3, [pc, #376] ; 30006d70 <mount+0x310>
30006bf4: e284401c add r4, r4, #28
30006bf8: e593c000 ldr ip, [r3]
30006bfc: e8b4000f ldm r4!, {r0, r1, r2, r3}
30006c00: e28cc018 add ip, ip, #24
30006c04: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006c08: e5943000 ldr r3, [r4]
return 0;
30006c0c: 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;
30006c10: e58c3000 str r3, [ip]
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
30006c14: e28dd030 add sp, sp, #48 ; 0x30
30006c18: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
30006c1c: e28d701c add r7, sp, #28 30006c20: e3a0c001 mov ip, #1 30006c24: e1a00006 mov r0, r6 30006c28: e59d1010 ldr r1, [sp, #16] 30006c2c: e3a02007 mov r2, #7 30006c30: e1a03007 mov r3, r7 30006c34: e58dc000 str ip, [sp] 30006c38: ebfffdd7 bl 3000639c <rtems_filesystem_evaluate_path> 30006c3c: e3700001 cmn r0, #1
30006c40: 0a000031 beq 30006d0c <mount+0x2ac>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
30006c44: e1a00007 mov r0, r7 30006c48: e59d3028 ldr r3, [sp, #40] ; 0x28 30006c4c: e1a0e00f mov lr, pc 30006c50: e593f010 ldr pc, [r3, #16] 30006c54: e3500001 cmp r0, #1
30006c58: 1a000039 bne 30006d44 <mount+0x2e4>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
30006c5c: e59f0110 ldr r0, [pc, #272] ; 30006d74 <mount+0x314> 30006c60: e59d101c ldr r1, [sp, #28] 30006c64: ebffff5f bl 300069e8 <rtems_filesystem_mount_iterate> 30006c68: e3500000 cmp r0, #0
30006c6c: 1a000038 bne 30006d54 <mount+0x2f4>
* 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;
30006c70: e59d201c ldr r2, [sp, #28]
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
30006c74: e59d3028 ldr r3, [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;
30006c78: e5842008 str r2, [r4, #8]
mt_entry->mt_point_node.handlers = loc.handlers;
30006c7c: e59d2024 ldr r2, [sp, #36] ; 0x24
mt_entry->mt_point_node.ops = loc.ops;
30006c80: e5843014 str r3, [r4, #20]
* 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;
30006c84: e5842010 str r2, [r4, #16]
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
30006c88: e59d202c ldr r2, [sp, #44] ; 0x2c
/*
* 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 ) ) {
30006c8c: e1a00004 mov r0, r4
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
30006c90: e5842018 str r2, [r4, #24]
/*
* 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 ) ) {
30006c94: e1a0e00f mov lr, pc 30006c98: e593f020 ldr pc, [r3, #32] 30006c9c: e3500000 cmp r0, #0
30006ca0: 0affffbe beq 30006ba0 <mount+0x140>
return 0;
cleanup_and_bail:
free( mt_entry );
30006ca4: e1a00004 mov r0, r4 30006ca8: ebfffdfa bl 30006498 <free>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
30006cac: e1a00007 mov r0, r7 30006cb0: ebfffdf3 bl 30006484 <rtems_filesystem_freenode>
return -1;
30006cb4: e3e00000 mvn r0, #0 30006cb8: eaffffd5 b 30006c14 <mount+0x1b4>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
30006cbc: eb002cec bl 30012074 <__errno> <== NOT EXECUTED 30006cc0: e3a0300c mov r3, #12 <== NOT EXECUTED 30006cc4: e5803000 str r3, [r0] <== NOT EXECUTED 30006cc8: e3e00000 mvn r0, #0 <== NOT EXECUTED 30006ccc: eaffffd0 b 30006c14 <mount+0x1b4> <== NOT EXECUTED
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
30006cd0: e59fe0a0 ldr lr, [pc, #160] ; 30006d78 <mount+0x318> 30006cd4: e3a03002 mov r3, #2 30006cd8: e58de018 str lr, [sp, #24] 30006cdc: e3a0e001 mov lr, #1 30006ce0: e58d300c str r3, [sp, #12] 30006ce4: e58de010 str lr, [sp, #16] 30006ce8: eaffff73 b 30006abc <mount+0x5c>
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
if ( !mount_h )
rtems_set_errno_and_return_minus_one( EINVAL );
30006cec: eb002ce0 bl 30012074 <__errno> 30006cf0: e3a03016 mov r3, #22 30006cf4: e5803000 str r3, [r0] 30006cf8: e3e00000 mvn r0, #0 30006cfc: eaffffc4 b 30006c14 <mount+0x1b4>
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
errno = EINVAL;
30006d00: eb002cdb bl 30012074 <__errno> <== NOT EXECUTED 30006d04: e3a03016 mov r3, #22 <== NOT EXECUTED 30006d08: e5803000 str r3, [r0] <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
30006d0c: e1a00004 mov r0, r4 <== NOT EXECUTED 30006d10: ebfffde0 bl 30006498 <free> <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
30006d14: e3e00000 mvn r0, #0 <== NOT EXECUTED 30006d18: eaffffbd b 30006c14 <mount+0x1b4> <== NOT EXECUTED
if ( (*mount_h)( mt_entry, data ) ) {
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
30006d1c: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 30006d20: e1a00004 mov r0, r4 <== NOT EXECUTED 30006d24: e1a0e00f mov lr, pc <== NOT EXECUTED 30006d28: e593f028 ldr pc, [r3, #40] ; 0x28 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
30006d2c: e1a00004 mov r0, r4 <== NOT EXECUTED 30006d30: ebfffdd8 bl 30006498 <free> <== NOT EXECUTED
if ( loc_to_free )
30006d34: e3570000 cmp r7, #0 <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
return -1;
30006d38: 03e00000 mvneq r0, #0 <== NOT EXECUTED
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
30006d3c: 0affffb4 beq 30006c14 <mount+0x1b4> <== NOT EXECUTED 30006d40: eaffffd9 b 30006cac <mount+0x24c> <== NOT EXECUTED
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
errno = ENOTDIR;
30006d44: eb002cca bl 30012074 <__errno> 30006d48: e3a03014 mov r3, #20 30006d4c: e5803000 str r3, [r0]
goto cleanup_and_bail;
30006d50: eaffffd3 b 30006ca4 <mount+0x244>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
errno = EBUSY;
30006d54: eb002cc6 bl 30012074 <__errno> 30006d58: e3a03010 mov r3, #16 30006d5c: e5803000 str r3, [r0]
goto cleanup_and_bail;
30006d60: eaffffcf b 30006ca4 <mount+0x244>
300099a8 <mprotect>:
const void *addr __attribute__((unused)),
size_t len __attribute__((unused)),
int prot __attribute__((unused)) )
{
return 0;
}
300099a8: e3a00000 mov r0, #0 <== NOT EXECUTED 300099ac: e12fff1e bx lr <== NOT EXECUTED
3000efa8 <mq_close>:
*/
int mq_close(
mqd_t mqdes
)
{
3000efa8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000efac: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000efb0: 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(
3000efb4: e1a0200d mov r2, sp <== NOT EXECUTED 3000efb8: e59f0064 ldr r0, [pc, #100] ; 3000f024 <mq_close+0x7c> <== NOT EXECUTED 3000efbc: eb000d50 bl 30012504 <_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 ) {
3000efc0: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000efc4: e1a04000 mov r4, r0 <== NOT EXECUTED 3000efc8: e3550000 cmp r5, #0 <== NOT EXECUTED 3000efcc: 1a00000f bne 3000f010 <mq_close+0x68> <== 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;
3000efd0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
the_mq->open_count -= 1;
3000efd4: e5932018 ldr r2, [r3, #24] <== NOT EXECUTED
_POSIX_Message_queue_Delete( the_mq );
3000efd8: e1a00003 mov r0, r3 <== NOT EXECUTED
* being disassociated. This may result in the queue being really
* deleted.
*/
the_mq = the_mq_fd->Queue;
the_mq->open_count -= 1;
3000efdc: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000efe0: e5832018 str r2, [r3, #24] <== NOT EXECUTED
_POSIX_Message_queue_Delete( the_mq );
3000efe4: eb00000f bl 3000f028 <_POSIX_Message_queue_Delete> <== NOT EXECUTED
/*
* Now close this file descriptor.
*/
_Objects_Close(
3000efe8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000efec: e59f0030 ldr r0, [pc, #48] ; 3000f024 <mq_close+0x7c> <== NOT EXECUTED 3000eff0: eb000c37 bl 300120d4 <_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 );
3000eff4: e59f0028 ldr r0, [pc, #40] ; 3000f024 <mq_close+0x7c> <== NOT EXECUTED 3000eff8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000effc: eb000ce9 bl 300123a8 <_Objects_Free> <== NOT EXECUTED
&_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000f000: eb00109a bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000f004: e1a00005 mov r0, r5 <== NOT EXECUTED
/*
* OBJECTS_REMOTE:
* OBJECTS_ERROR:
*/
rtems_set_errno_and_return_minus_one( EBADF );
}
3000f008: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000f00c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* OBJECTS_REMOTE:
* OBJECTS_ERROR:
*/
rtems_set_errno_and_return_minus_one( EBADF );
3000f010: eb002ad5 bl 30019b6c <__errno> <== NOT EXECUTED 3000f014: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f018: e5803000 str r3, [r0] <== NOT EXECUTED 3000f01c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000f020: eafffff8 b 3000f008 <mq_close+0x60> <== NOT EXECUTED
3000f078 <mq_getattr>:
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
3000f078: e92d4030 push {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 )
3000f07c: e2514000 subs r4, r1, #0 <== NOT EXECUTED
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
3000f080: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000f084: e1a01000 mov r1, 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 )
3000f088: 0a000017 beq 3000f0ec <mq_getattr+0x74> <== 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(
3000f08c: e59f006c ldr r0, [pc, #108] ; 3000f100 <mq_getattr+0x88> <== NOT EXECUTED 3000f090: e1a0200d mov r2, sp <== NOT EXECUTED 3000f094: eb000d1a bl 30012504 <_Objects_Get> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000f098: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000f09c: e3550000 cmp r5, #0 <== NOT EXECUTED 3000f0a0: 1a00000c bne 3000f0d8 <mq_getattr+0x60> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
3000f0a4: 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;
3000f0a8: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
3000f0ac: e5931068 ldr r1, [r3, #104] ; 0x68 <== NOT EXECUTED
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
3000f0b0: e5932060 ldr r2, [r3, #96] ; 0x60 <== NOT EXECUTED
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
3000f0b4: e5933064 ldr r3, [r3, #100] ; 0x64 <== NOT EXECUTED
* Return the old values.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
mqstat->mq_flags = the_mq_fd->oflag;
3000f0b8: e5840000 str r0, [r4] <== NOT EXECUTED
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
3000f0bc: e5841008 str r1, [r4, #8] <== NOT EXECUTED
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
3000f0c0: e5842004 str r2, [r4, #4] <== NOT EXECUTED
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
3000f0c4: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000f0c8: eb001068 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000f0cc: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
3000f0d0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000f0d4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000f0d8: eb002aa3 bl 30019b6c <__errno> <== NOT EXECUTED 3000f0dc: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f0e0: e5803000 str r3, [r0] <== NOT EXECUTED 3000f0e4: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000f0e8: eafffff8 b 3000f0d0 <mq_getattr+0x58> <== NOT EXECUTED
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
CORE_message_queue_Attributes *the_mq_attr;
if ( !mqstat )
rtems_set_errno_and_return_minus_one( EINVAL );
3000f0ec: eb002a9e bl 30019b6c <__errno> <== NOT EXECUTED 3000f0f0: e3a03016 mov r3, #22 <== NOT EXECUTED 3000f0f4: e5803000 str r3, [r0] <== NOT EXECUTED 3000f0f8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000f0fc: eafffff3 b 3000f0d0 <mq_getattr+0x58> <== NOT EXECUTED
3000f128 <mq_notify>:
int mq_notify(
mqd_t mqdes,
const struct sigevent *notification
)
{
3000f128: e92d4010 push {r4, lr} <== NOT EXECUTED
3000f12c: e1a03000 mov r3, r0 <== NOT EXECUTED
3000f130: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000f134: e1a04001 mov r4, r1 <== NOT EXECUTED
3000f138: e59f0098 ldr r0, [pc, #152] ; 3000f1d8 <mq_notify+0xb0> <== NOT EXECUTED
3000f13c: e1a01003 mov r1, r3 <== NOT EXECUTED
3000f140: e1a0200d mov r2, sp <== NOT EXECUTED
3000f144: eb000cee bl 30012504 <_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 ) {
3000f148: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000f14c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f150: 0a000005 beq 3000f16c <mq_notify+0x44> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000f154: eb002a84 bl 30019b6c <__errno> <== NOT EXECUTED 3000f158: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f15c: e5803000 str r3, [r0] <== NOT EXECUTED 3000f160: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000f164: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000f168: e8bd8010 pop {r4, pc} <== NOT EXECUTED
switch ( location ) {
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
if ( notification ) {
3000f16c: 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;
3000f170: e590e010 ldr lr, [r0, #16] <== NOT EXECUTED
if ( notification ) {
3000f174: 0a00000e beq 3000f1b4 <mq_notify+0x8c> <== NOT EXECUTED
if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) {
3000f178: e59e307c ldr r3, [lr, #124] ; 0x7c <== NOT EXECUTED 3000f17c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f180: 1a00000e bne 3000f1c0 <mq_notify+0x98> <== NOT EXECUTED 3000f184: e58e3080 str r3, [lr, #128] ; 0x80 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
}
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
the_mq->notification = *notification;
3000f188: e28ec090 add ip, lr, #144 ; 0x90 <== NOT EXECUTED
3000f18c: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3000f190: e8ac000f stmia ip!, {r0, r1, r2, r3} <== 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;
3000f194: e59f2040 ldr r2, [pc, #64] ; 3000f1dc <mq_notify+0xb4> <== NOT EXECUTED 3000f198: e5943000 ldr r3, [r4] <== NOT EXECUTED 3000f19c: e58e207c str r2, [lr, #124] ; 0x7c <== NOT EXECUTED 3000f1a0: e58c3000 str r3, [ip] <== NOT EXECUTED
the_message_queue->notify_argument = the_argument;
3000f1a4: e58ee080 str lr, [lr, #128] ; 0x80 <== NOT EXECUTED
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL );
}
_Thread_Enable_dispatch();
3000f1a8: eb001030 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000f1ac: e3a00000 mov r0, #0 <== NOT EXECUTED 3000f1b0: eaffffeb b 3000f164 <mq_notify+0x3c> <== 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;
3000f1b4: e58e407c str r4, [lr, #124] ; 0x7c <== NOT EXECUTED
the_message_queue->notify_argument = the_argument;
3000f1b8: e58e4080 str r4, [lr, #128] ; 0x80 <== NOT EXECUTED 3000f1bc: eafffff9 b 3000f1a8 <mq_notify+0x80> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_mq = the_mq_fd->Queue;
if ( notification ) {
if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) {
_Thread_Enable_dispatch();
3000f1c0: eb00102a bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
3000f1c4: eb002a68 bl 30019b6c <__errno> <== NOT EXECUTED 3000f1c8: e3a03010 mov r3, #16 <== NOT EXECUTED 3000f1cc: e5803000 str r3, [r0] <== NOT EXECUTED 3000f1d0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000f1d4: eaffffe2 b 3000f164 <mq_notify+0x3c> <== NOT EXECUTED
3000f1e0 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
3000f1e0: e92d000e push {r1, r2, r3} <== NOT EXECUTED
3000f1e4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000f1e8: e59f3180 ldr r3, [pc, #384] ; 3000f370 <mq_open+0x190> <== NOT EXECUTED 3000f1ec: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 3000f1f0: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000f1f4: e59d7030 ldr r7, [sp, #48] ; 0x30 <== NOT EXECUTED 3000f1f8: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000f1fc: e5832000 str r2, [r3] <== NOT EXECUTED 3000f200: e1a0a000 mov sl, r0 <== 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 );
3000f204: e59f5168 ldr r5, [pc, #360] ; 3000f374 <mq_open+0x194> <== NOT EXECUTED
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
3000f208: e2178c02 ands r8, 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 * );
3000f20c: 128d303c addne r3, sp, #60 ; 0x3c <== NOT EXECUTED 3000f210: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f214: 158d300c strne r3, [sp, #12] <== NOT EXECUTED 3000f218: 159d9038 ldrne r9, [sp, #56] ; 0x38 <== NOT EXECUTED
/* struct mq_attr attr */
)
{
va_list arg;
mode_t mode;
struct mq_attr *attr = NULL;
3000f21c: 01a09008 moveq r9, r8 <== NOT EXECUTED 3000f220: eb000b86 bl 30012040 <_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 ) {
3000f224: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000f228: 0a000027 beq 3000f2cc <mq_open+0xec> <== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
3000f22c: e5847014 str r7, [r4, #20] <== NOT EXECUTED
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );
3000f230: e1a0000a mov r0, sl <== NOT EXECUTED 3000f234: e28d1008 add r1, sp, #8 <== NOT EXECUTED 3000f238: eb001c27 bl 300162dc <_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 ) {
3000f23c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000f240: 1a000017 bne 3000f2a4 <mq_open+0xc4> <== NOT EXECUTED
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
3000f244: e2077c0a and r7, r7, #2560 ; 0xa00 <== NOT EXECUTED 3000f248: e3570c0a cmp r7, #2560 ; 0xa00 <== NOT EXECUTED 3000f24c: 0a000024 beq 3000f2e4 <mq_open+0x104> <== NOT EXECUTED
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
_Objects_Get( &_POSIX_Message_queue_Information, id, location );
3000f250: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3000f254: e1a0200d mov r2, sp <== NOT EXECUTED 3000f258: e59f0118 ldr r0, [pc, #280] ; 3000f378 <mq_open+0x198> <== NOT EXECUTED 3000f25c: eb000ca8 bl 30012504 <_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;
3000f260: e5901018 ldr r1, [r0, #24] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000f264: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
3000f268: e1d420b8 ldrh r2, [r4, #8] <== NOT EXECUTED 3000f26c: e2811001 add r1, r1, #1 <== NOT EXECUTED 3000f270: e5801018 str r1, [r0, #24] <== 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 );
3000f274: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
the_mq->open_count += 1;
the_mq_fd->Queue = the_mq;
3000f278: e5840010 str r0, [r4, #16] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000f27c: 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;
3000f280: e584600c str r6, [r4, #12] <== NOT EXECUTED
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
3000f284: eb000ff9 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000f288: eb000ff8 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
return (mqd_t)the_mq_fd->Object.id;
3000f28c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
3000f290: e1a00003 mov r0, r3 <== NOT EXECUTED
3000f294: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000f298: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
3000f29c: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000f2a0: e12fff1e bx lr <== NOT EXECUTED
if ( status ) {
/*
* 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) ) ) {
3000f2a4: e3560002 cmp r6, #2 <== NOT EXECUTED 3000f2a8: 0a000016 beq 3000f308 <mq_open+0x128> <== 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 );
3000f2ac: e59f00c0 ldr r0, [pc, #192] ; 3000f374 <mq_open+0x194> <== NOT EXECUTED 3000f2b0: e1a01004 mov r1, r4 <== NOT EXECUTED 3000f2b4: eb000c3b bl 300123a8 <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000f2b8: eb000fec bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
3000f2bc: eb002a2a bl 30019b6c <__errno> <== NOT EXECUTED 3000f2c0: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000f2c4: e5806000 str r6, [r0] <== NOT EXECUTED 3000f2c8: eafffff0 b 3000f290 <mq_open+0xb0> <== NOT EXECUTED
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
_Thread_Enable_dispatch();
3000f2cc: eb000fe7 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENFILE );
3000f2d0: eb002a25 bl 30019b6c <__errno> <== NOT EXECUTED 3000f2d4: e3a03017 mov r3, #23 <== NOT EXECUTED 3000f2d8: e5803000 str r3, [r0] <== NOT EXECUTED 3000f2dc: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000f2e0: eaffffea b 3000f290 <mq_open+0xb0> <== NOT EXECUTED 3000f2e4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f2e8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000f2ec: eb000c2d bl 300123a8 <_Objects_Free> <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000f2f0: eb000fde bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
3000f2f4: eb002a1c bl 30019b6c <__errno> <== NOT EXECUTED 3000f2f8: e3a03011 mov r3, #17 <== NOT EXECUTED 3000f2fc: e5803000 str r3, [r0] <== NOT EXECUTED 3000f300: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000f304: eaffffe1 b 3000f290 <mq_open+0xb0> <== NOT EXECUTED
if ( status ) {
/*
* 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) ) ) {
3000f308: e3580000 cmp r8, #0 <== NOT EXECUTED 3000f30c: 0affffe6 beq 3000f2ac <mq_open+0xcc> <== 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(
3000f310: e1a0000a mov r0, sl <== NOT EXECUTED 3000f314: e3a01001 mov r1, #1 <== NOT EXECUTED 3000f318: e1a02009 mov r2, r9 <== NOT EXECUTED 3000f31c: e28d3004 add r3, sp, #4 <== NOT EXECUTED 3000f320: eb001b8e bl 30016160 <_POSIX_Message_queue_Create_support> <== NOT EXECUTED
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
3000f324: 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(
3000f328: e1a06000 mov r6, r0 <== NOT EXECUTED
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
3000f32c: 0a000009 beq 3000f358 <mq_open+0x178> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000f330: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
return (mqd_t) -1;
}
the_mq_fd->Queue = the_mq;
3000f334: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
3000f338: e1d420b8 ldrh r2, [r4, #8] <== NOT EXECUTED 3000f33c: e5841010 str r1, [r4, #16] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000f340: 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;
3000f344: e3a03000 mov r3, #0 <== NOT EXECUTED 3000f348: e584300c str r3, [r4, #12] <== NOT EXECUTED
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
3000f34c: eb000fc7 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
return (mqd_t) the_mq_fd->Object.id;
3000f350: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000f354: eaffffcd b 3000f290 <mq_open+0xb0> <== NOT EXECUTED 3000f358: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f35c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000f360: eb000c10 bl 300123a8 <_Objects_Free> <== NOT EXECUTED
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
3000f364: eb000fc1 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
return (mqd_t) -1;
3000f368: e1a03006 mov r3, r6 <== NOT EXECUTED 3000f36c: eaffffc7 b 3000f290 <mq_open+0xb0> <== NOT EXECUTED
3000f37c <mq_receive>:
mqd_t mqdes,
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio
)
{
3000f37c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return _POSIX_Message_queue_Receive_support(
3000f380: e3a0c001 mov ip, #1 <== NOT EXECUTED
mqd_t mqdes,
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio
)
{
3000f384: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
return _POSIX_Message_queue_Receive_support(
3000f388: e58dc000 str ip, [sp] <== NOT EXECUTED 3000f38c: e3a0c000 mov ip, #0 <== NOT EXECUTED 3000f390: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3000f394: eb000001 bl 3000f3a0 <_POSIX_Message_queue_Receive_support><== NOT EXECUTED
msg_len,
msg_prio,
true,
THREAD_QUEUE_WAIT_FOREVER
);
}
3000f398: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000f39c: e8bd8000 pop {pc} <== NOT EXECUTED
3000f4d4 <mq_send>:
mqd_t mqdes,
const char *msg_ptr,
size_t msg_len,
unsigned int msg_prio
)
{
3000f4d4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return _POSIX_Message_queue_Send_support(
3000f4d8: e3a0c001 mov ip, #1 <== NOT EXECUTED
mqd_t mqdes,
const char *msg_ptr,
size_t msg_len,
unsigned int msg_prio
)
{
3000f4dc: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
return _POSIX_Message_queue_Send_support(
3000f4e0: e58dc000 str ip, [sp] <== NOT EXECUTED 3000f4e4: e3a0c000 mov ip, #0 <== NOT EXECUTED 3000f4e8: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3000f4ec: eb000001 bl 3000f4f8 <_POSIX_Message_queue_Send_support> <== NOT EXECUTED
msg_len,
msg_prio,
true,
THREAD_QUEUE_WAIT_FOREVER
);
}
3000f4f0: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000f4f4: e8bd8000 pop {pc} <== NOT EXECUTED
3000f61c <mq_setattr>:
int mq_setattr(
mqd_t mqdes,
const struct mq_attr *mqstat,
struct mq_attr *omqstat
)
{
3000f61c: e92d4030 push {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 )
3000f620: e2515000 subs r5, r1, #0 <== NOT EXECUTED
int mq_setattr(
mqd_t mqdes,
const struct mq_attr *mqstat,
struct mq_attr *omqstat
)
{
3000f624: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000f628: e1a01000 mov r1, r0 <== NOT EXECUTED 3000f62c: 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 )
3000f630: 0a00001b beq 3000f6a4 <mq_setattr+0x88> <== 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(
3000f634: e59f007c ldr r0, [pc, #124] ; 3000f6b8 <mq_setattr+0x9c> <== NOT EXECUTED 3000f638: e1a0200d mov r2, sp <== NOT EXECUTED 3000f63c: eb000bb0 bl 30012504 <_Objects_Get> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
3000f640: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000f644: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f648: 1a000010 bne 3000f690 <mq_setattr+0x74> <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
3000f64c: 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;
3000f650: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
3000f654: 0a000007 beq 3000f678 <mq_setattr+0x5c> <== NOT EXECUTED
omqstat->mq_flags = the_mq_fd->oflag;
omqstat->mq_msgsize = the_core_mq->maximum_message_size;
3000f658: e5931068 ldr r1, [r3, #104] ; 0x68 <== NOT EXECUTED
omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages;
3000f65c: e5932060 ldr r2, [r3, #96] ; 0x60 <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
omqstat->mq_flags = the_mq_fd->oflag;
3000f660: e590c014 ldr ip, [r0, #20] <== NOT EXECUTED
omqstat->mq_msgsize = the_core_mq->maximum_message_size;
omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages;
omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages;
3000f664: e5933064 ldr r3, [r3, #100] ; 0x64 <== NOT EXECUTED
/*
* Return the old values.
*/
if ( omqstat ) {
omqstat->mq_flags = the_mq_fd->oflag;
3000f668: e584c000 str ip, [r4] <== NOT EXECUTED
omqstat->mq_msgsize = the_core_mq->maximum_message_size;
3000f66c: e5841008 str r1, [r4, #8] <== NOT EXECUTED
omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages;
3000f670: e5842004 str r2, [r4, #4] <== NOT EXECUTED
omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages;
3000f674: e584300c str r3, [r4, #12] <== NOT EXECUTED
}
the_mq_fd->oflag = mqstat->mq_flags;
3000f678: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000f67c: e5803014 str r3, [r0, #20] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000f680: eb000efa bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000f684: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
3000f688: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000f68c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
3000f690: eb002935 bl 30019b6c <__errno> <== NOT EXECUTED 3000f694: e3a03009 mov r3, #9 <== NOT EXECUTED 3000f698: e5803000 str r3, [r0] <== NOT EXECUTED 3000f69c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000f6a0: eafffff8 b 3000f688 <mq_setattr+0x6c> <== NOT EXECUTED
POSIX_Message_queue_Control_fd *the_mq_fd;
CORE_message_queue_Control *the_core_mq;
Objects_Locations location;
if ( !mqstat )
rtems_set_errno_and_return_minus_one( EINVAL );
3000f6a4: eb002930 bl 30019b6c <__errno> <== NOT EXECUTED 3000f6a8: e3a03016 mov r3, #22 <== NOT EXECUTED 3000f6ac: e5803000 str r3, [r0] <== NOT EXECUTED 3000f6b0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000f6b4: eafffff3 b 3000f688 <mq_setattr+0x6c> <== NOT EXECUTED
3000f6bc <mq_timedreceive>:
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio,
const struct timespec *abstime
)
{
3000f6bc: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000f6c0: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
3000f6c4: e1a05000 mov r5, r0 <== NOT EXECUTED
3000f6c8: 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 );
3000f6cc: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED 3000f6d0: e28d1008 add r1, sp, #8 <== NOT EXECUTED
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio,
const struct timespec *abstime
)
{
3000f6d4: e1a06003 mov r6, r3 <== NOT EXECUTED 3000f6d8: 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 );
3000f6dc: eb000043 bl 3000f7f0 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
return _POSIX_Message_queue_Receive_support(
3000f6e0: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
3000f6e4: e3500003 cmp r0, #3 <== NOT EXECUTED
3000f6e8: 13a00000 movne r0, #0 <== NOT EXECUTED
3000f6ec: 03a00001 moveq r0, #1 <== NOT EXECUTED
3000f6f0: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED
3000f6f4: e1a00005 mov r0, r5 <== NOT EXECUTED
3000f6f8: e1a01004 mov r1, r4 <== NOT EXECUTED
3000f6fc: e1a02007 mov r2, r7 <== NOT EXECUTED
3000f700: e1a03006 mov r3, r6 <== NOT EXECUTED
3000f704: ebffff25 bl 3000f3a0 <_POSIX_Message_queue_Receive_support><== NOT EXECUTED
msg_len,
msg_prio,
do_wait,
ticks
);
}
3000f708: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000f70c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000f710 <mq_timedsend>:
const char *msg_ptr,
size_t msg_len,
unsigned int msg_prio,
const struct timespec *abstime
)
{
3000f710: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000f714: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
3000f718: e1a05000 mov r5, r0 <== NOT EXECUTED
3000f71c: 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 );
3000f720: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED 3000f724: e28d1008 add r1, sp, #8 <== NOT EXECUTED
const char *msg_ptr,
size_t msg_len,
unsigned int msg_prio,
const struct timespec *abstime
)
{
3000f728: e1a06003 mov r6, r3 <== NOT EXECUTED 3000f72c: 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 );
3000f730: eb00002e bl 3000f7f0 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
return _POSIX_Message_queue_Send_support(
3000f734: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
3000f738: e3500003 cmp r0, #3 <== NOT EXECUTED
3000f73c: 13a00000 movne r0, #0 <== NOT EXECUTED
3000f740: 03a00001 moveq r0, #1 <== NOT EXECUTED
3000f744: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED
3000f748: e1a00005 mov r0, r5 <== NOT EXECUTED
3000f74c: e1a01004 mov r1, r4 <== NOT EXECUTED
3000f750: e1a02007 mov r2, r7 <== NOT EXECUTED
3000f754: e1a03006 mov r3, r6 <== NOT EXECUTED
3000f758: ebffff66 bl 3000f4f8 <_POSIX_Message_queue_Send_support> <== NOT EXECUTED
msg_len,
msg_prio,
do_wait,
ticks
);
}
3000f75c: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000f760: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000f774 <mq_unlink>:
*/
int mq_unlink(
const char *name
)
{
3000f774: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000f778: e59f3068 ldr r3, [pc, #104] ; 3000f7e8 <mq_unlink+0x74> <== NOT EXECUTED
3000f77c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000f780: e5932000 ldr r2, [r3] <== NOT EXECUTED
3000f784: e2822001 add r2, r2, #1 <== NOT EXECUTED
3000f788: 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 );
3000f78c: e1a0100d mov r1, sp <== NOT EXECUTED 3000f790: eb001ad1 bl 300162dc <_POSIX_Message_queue_Name_to_id> <== NOT EXECUTED
if ( status != 0 ) {
3000f794: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000f798: 1a00000d bne 3000f7d4 <mq_unlink+0x60> <== NOT EXECUTED
_POSIX_Message_queue_Namespace_remove( the_mq );
_POSIX_Message_queue_Delete( the_mq );
_Thread_Enable_dispatch();
return 0;
}
3000f79c: e59f0048 ldr r0, [pc, #72] ; 3000f7ec <mq_unlink+0x78> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
3000f7a0: e1dd20b0 ldrh r2, [sp] <== NOT EXECUTED 3000f7a4: 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(
3000f7a8: e7934102 ldr r4, [r3, r2, lsl #2] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Namespace_remove (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Namespace_remove(
3000f7ac: e1a01004 mov r1, r4 <== NOT EXECUTED
&_POSIX_Message_queue_Information,
_Objects_Get_index( the_mq_id )
);
the_mq->linked = false;
3000f7b0: e5c45015 strb r5, [r4, #21] <== NOT EXECUTED 3000f7b4: eb000ba9 bl 30012660 <_Objects_Namespace_remove> <== NOT EXECUTED
_POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq );
3000f7b8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f7bc: ebfffe19 bl 3000f028 <_POSIX_Message_queue_Delete> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000f7c0: eb000eaa bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000f7c4: e1a03005 mov r3, r5 <== NOT EXECUTED
}
3000f7c8: e1a00003 mov r0, r3 <== NOT EXECUTED
3000f7cc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000f7d0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_Thread_Disable_dispatch();
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );
if ( status != 0 ) {
_Thread_Enable_dispatch();
3000f7d4: eb000ea5 bl 30013270 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( status );
3000f7d8: eb0028e3 bl 30019b6c <__errno> <== NOT EXECUTED 3000f7dc: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000f7e0: e5805000 str r5, [r0] <== NOT EXECUTED 3000f7e4: eafffff7 b 3000f7c8 <mq_unlink+0x54> <== NOT EXECUTED
3001edb4 <nanosleep>:
int nanosleep(
const struct timespec *rqtp,
struct timespec *rmtp
)
{
3001edb4: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3001edb8: e1a05000 mov r5, r0 <== NOT EXECUTED
3001edbc: 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 ) )
3001edc0: eb000065 bl 3001ef5c <_Timespec_Is_valid> <== NOT EXECUTED 3001edc4: e3500000 cmp r0, #0 <== NOT EXECUTED 3001edc8: 0a000035 beq 3001eea4 <nanosleep+0xf0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
ticks = _Timespec_To_ticks( rqtp );
3001edcc: e1a00005 mov r0, r5 <== NOT EXECUTED 3001edd0: ebffc6e8 bl 30010978 <_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 ) {
3001edd4: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3001edd8: 0a000022 beq 3001ee68 <nanosleep+0xb4> <== NOT EXECUTED 3001eddc: e59f30e8 ldr r3, [pc, #232] ; 3001eecc <nanosleep+0x118> <== NOT EXECUTED 3001ede0: e5932000 ldr r2, [r3] <== NOT EXECUTED 3001ede4: e2822001 add r2, r2, #1 <== NOT EXECUTED 3001ede8: e5832000 str r2, [r3] <== NOT EXECUTED
/*
* Block for the desired amount of time
*/
_Thread_Disable_dispatch();
_Thread_Set_state(
3001edec: e59f60dc ldr r6, [pc, #220] ; 3001eed0 <nanosleep+0x11c> <== NOT EXECUTED 3001edf0: e3a01281 mov r1, #268435464 ; 0x10000008 <== NOT EXECUTED 3001edf4: e5960004 ldr r0, [r6, #4] <== NOT EXECUTED 3001edf8: ebffb7e5 bl 3000cd94 <_Thread_Set_state> <== NOT EXECUTED
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3001edfc: e5961004 ldr r1, [r6, #4] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3001ee00: e59f00cc ldr r0, [pc, #204] ; 3001eed4 <nanosleep+0x120> <== NOT EXECUTED
_Thread_Disable_dispatch();
_Thread_Set_state(
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
3001ee04: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001ee08: e3a03000 mov r3, #0 <== NOT EXECUTED 3001ee0c: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED
the_watchdog->routine = routine;
3001ee10: e5810064 str r0, [r1, #100] ; 0x64 <== NOT EXECUTED
the_watchdog->id = id;
3001ee14: e5812068 str r2, [r1, #104] ; 0x68 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3001ee18: e581306c str r3, [r1, #108] ; 0x6c <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001ee1c: e5815054 str r5, [r1, #84] ; 0x54 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3001ee20: e59f00b0 ldr r0, [pc, #176] ; 3001eed8 <nanosleep+0x124> <== NOT EXECUTED 3001ee24: e2811048 add r1, r1, #72 ; 0x48 <== NOT EXECUTED 3001ee28: ebffb97c bl 3000d420 <_Watchdog_Insert> <== NOT EXECUTED
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
_Thread_Enable_dispatch();
3001ee2c: ebffb5b0 bl 3000c4f4 <_Thread_Enable_dispatch> <== NOT EXECUTED
/* calculate time remaining */
if ( rmtp ) {
3001ee30: e3540000 cmp r4, #0 <== NOT EXECUTED 3001ee34: 0a000018 beq 3001ee9c <nanosleep+0xe8> <== NOT EXECUTED
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
3001ee38: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED
_Timespec_From_ticks( ticks, rmtp );
3001ee3c: e1a01004 mov r1, r4 <== NOT EXECUTED
/* calculate time remaining */
if ( rmtp ) {
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
3001ee40: e593405c ldr r4, [r3, #92] ; 0x5c <== NOT EXECUTED 3001ee44: e5933060 ldr r3, [r3, #96] ; 0x60 <== NOT EXECUTED 3001ee48: e0634004 rsb r4, r3, r4 <== NOT EXECUTED
_Thread_Enable_dispatch();
/* calculate time remaining */
if ( rmtp ) {
ticks -=
3001ee4c: e0845005 add r5, r4, r5 <== NOT EXECUTED
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
_Timespec_From_ticks( ticks, rmtp );
3001ee50: e1a00005 mov r0, r5 <== NOT EXECUTED 3001ee54: eb00002f bl 3001ef18 <_Timespec_From_ticks> <== NOT EXECUTED
*/
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
3001ee58: e3550000 cmp r5, #0 <== NOT EXECUTED 3001ee5c: 1a000015 bne 3001eeb8 <nanosleep+0x104> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINTR );
#endif
}
return 0;
3001ee60: e1a00005 mov r0, r5 <== NOT EXECUTED
}
3001ee64: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3001ee68: e59f305c ldr r3, [pc, #92] ; 3001eecc <nanosleep+0x118> <== NOT EXECUTED
3001ee6c: e5932000 ldr r2, [r3] <== NOT EXECUTED
3001ee70: e2822001 add r2, r2, #1 <== NOT EXECUTED
3001ee74: e5832000 str r2, [r3] <== NOT EXECUTED
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
3001ee78: e59f305c ldr r3, [pc, #92] ; 3001eedc <nanosleep+0x128> <== NOT EXECUTED 3001ee7c: e1a0e00f mov lr, pc <== NOT EXECUTED 3001ee80: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
*/
if ( !ticks ) {
_Thread_Disable_dispatch();
_Scheduler_Yield();
_Thread_Enable_dispatch();
3001ee84: ebffb59a bl 3000c4f4 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( rmtp ) {
3001ee88: e3540000 cmp r4, #0 <== NOT EXECUTED
rmtp->tv_sec = 0;
3001ee8c: 15845000 strne r5, [r4] <== NOT EXECUTED
rmtp->tv_nsec = 0;
3001ee90: 15845004 strne r5, [r4, #4] <== NOT EXECUTED
}
return 0;
3001ee94: 11a00005 movne r0, r5 <== NOT EXECUTED
if ( !ticks ) {
_Thread_Disable_dispatch();
_Scheduler_Yield();
_Thread_Enable_dispatch();
if ( rmtp ) {
3001ee98: 18bd8070 popne {r4, r5, r6, pc} <== NOT EXECUTED
if ( ticks )
rtems_set_errno_and_return_minus_one( EINTR );
#endif
}
return 0;
3001ee9c: e1a00004 mov r0, r4 <== NOT EXECUTED
3001eea0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
*
* NOTE: This behavior is beyond the POSIX specification.
* FSU and GNU/Linux pthreads shares this behavior.
*/
if ( !_Timespec_Is_valid( rqtp ) )
rtems_set_errno_and_return_minus_one( EINVAL );
3001eea4: ebffcda9 bl 30012550 <__errno> <== NOT EXECUTED
3001eea8: e3a03016 mov r3, #22 <== NOT EXECUTED
3001eeac: e5803000 str r3, [r0] <== NOT EXECUTED
3001eeb0: e3e00000 mvn r0, #0 <== NOT EXECUTED
3001eeb4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
rtems_set_errno_and_return_minus_one( EINTR );
3001eeb8: ebffcda4 bl 30012550 <__errno> <== NOT EXECUTED
3001eebc: e3a03004 mov r3, #4 <== NOT EXECUTED
3001eec0: e5803000 str r3, [r0] <== NOT EXECUTED
3001eec4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3001eec8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30006d80 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
30006d80: e92d4010 push {r4, lr}
30006d84: e1a04000 mov r4, r0
switch ( fileno(fp) ) {
30006d88: eb002dbc bl 30012480 <fileno> 30006d8c: e3500002 cmp r0, #2
30006d90: 9a000003 bls 30006da4 <newlib_free_buffers+0x24>
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
30006d94: e1a00004 mov r0, r4 <== NOT EXECUTED 30006d98: eb002d03 bl 300121ac <fclose> <== NOT EXECUTED
} return 0; }
30006d9c: e3a00000 mov r0, #0
30006da0: e8bd8010 pop {r4, pc}
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
30006da4: e1d430bc ldrh r3, [r4, #12] 30006da8: e3130080 tst r3, #128 ; 0x80
30006dac: 0afffffa beq 30006d9c <newlib_free_buffers+0x1c>
free( fp->_bf._base );
30006db0: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30006db4: ebfffdb7 bl 30006498 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
30006db8: e1d420bc ldrh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
30006dbc: e3a03000 mov r3, #0 <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
30006dc0: e3c22080 bic r2, r2, #128 ; 0x80 <== NOT EXECUTED 30006dc4: e1c420bc strh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
30006dc8: e5843000 str r3, [r4] <== NOT EXECUTED 30006dcc: e5843010 str r3, [r4, #16] <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
30006dd0: e3a00000 mov r0, #0 <== NOT EXECUTED
30006dd4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30006178 <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *pargp __attribute__((unused))
)
{
30006178: e92d4010 push {r4, lr}
rtems_device_driver status;
if ( !initialized ) {
3000617c: e59f3044 ldr r3, [pc, #68] ; 300061c8 <null_initialize+0x50>
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *pargp __attribute__((unused))
)
{
30006180: e1a04000 mov r4, r0
rtems_device_driver status;
if ( !initialized ) {
30006184: e5d32000 ldrb r2, [r3] 30006188: e3520000 cmp r2, #0
3000618c: 0a000001 beq 30006198 <null_initialize+0x20>
NULL_major = major;
}
return RTEMS_SUCCESSFUL;
}
30006190: e3a00000 mov r0, #0
30006194: e8bd8010 pop {r4, pc}
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
30006198: e3a0c001 mov ip, #1
status = rtems_io_register_name(
3000619c: e59f0028 ldr r0, [pc, #40] ; 300061cc <null_initialize+0x54> 300061a0: e1a01004 mov r1, r4
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
300061a4: e5c3c000 strb ip, [r3]
status = rtems_io_register_name(
300061a8: eb00005e bl 30006328 <rtems_io_register_name>
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
300061ac: e3500000 cmp r0, #0
300061b0: 1a000003 bne 300061c4 <null_initialize+0x4c>
rtems_fatal_error_occurred(status);
NULL_major = major;
300061b4: e59f3014 ldr r3, [pc, #20] ; 300061d0 <null_initialize+0x58>
}
return RTEMS_SUCCESSFUL;
}
300061b8: e3a00000 mov r0, #0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
NULL_major = major;
300061bc: e5834000 str r4, [r3]
}
return RTEMS_SUCCESSFUL;
}
300061c0: e8bd8010 pop {r4, pc}
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
300061c4: eb0010cc bl 3000a4fc <rtems_fatal_error_occurred> <== NOT EXECUTED
30007084 <open>:
int open(
const char *pathname,
int flags,
...
)
{
30007084: e92d000e push {r1, r2, r3}
30007088: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
3000708c: e24dd01c sub sp, sp, #28
30007090: e59d503c ldr r5, [sp, #60] ; 0x3c
30007094: e1a06000 mov r6, r0
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
30007098: e2853001 add r3, r5, #1
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
3000709c: e2139001 ands r9, r3, #1 300070a0: 13a09004 movne r9, #4
if ( ( status & _FWRITE ) == _FWRITE )
300070a4: e3130002 tst r3, #2
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
va_start(ap, flags);
mode = va_arg( ap, int );
300070a8: 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;
300070ac: 13899002 orrne r9, r9, #2
va_start(ap, flags);
mode = va_arg( ap, int );
300070b0: e58d3018 str r3, [sp, #24] 300070b4: e59da040 ldr sl, [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();
300070b8: eb001dc2 bl 3000e7c8 <rtems_libio_allocate>
if ( iop == 0 ) {
300070bc: e2504000 subs r4, r0, #0
300070c0: 0a000033 beq 30007194 <open+0x110>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
300070c4: e1a00006 mov r0, r6 300070c8: eb002fd3 bl 3001301c <strlen> 300070cc: e28d7004 add r7, sp, #4 300070d0: e1a01000 mov r1, r0 300070d4: e3a08001 mov r8, #1 300070d8: e1a00006 mov r0, r6 300070dc: e1a02009 mov r2, r9 300070e0: e1a03007 mov r3, r7 300070e4: e58d8000 str r8, [sp] 300070e8: ebfffcab bl 3000639c <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
300070ec: e3700001 cmn r0, #1
300070f0: 0a00005a beq 30007260 <open+0x1dc>
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
300070f4: e2053c0a and r3, r5, #2560 ; 0xa00 300070f8: e3530c0a cmp r3, #2560 ; 0xa00
300070fc: 0a000029 beq 300071a8 <open+0x124>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
30007100: e1a00005 mov r0, r5 30007104: e5948014 ldr r8, [r4, #20] 30007108: eb001d8e bl 3000e748 <rtems_libio_fcntl_flags>
iop->pathinfo = loc;
3000710c: e284c018 add ip, r4, #24 30007110: e1a0e007 mov lr, r7
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
30007114: e1808008 orr r8, r0, r8
iop->pathinfo = loc;
30007118: e8be000f ldm lr!, {r0, r1, r2, r3}
3000711c: e8ac000f stmia ip!, {r0, r1, r2, r3}
30007120: e59e3000 ldr r3, [lr]
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
30007124: 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;
30007128: e58c3000 str r3, [ip]
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
3000712c: e5848014 str r8, [r4, #20]
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
30007130: e594c020 ldr ip, [r4, #32] 30007134: e1a01006 mov r1, r6 30007138: e1a02005 mov r2, r5 3000713c: e1a0300a mov r3, sl 30007140: e1a0e00f mov lr, pc 30007144: e59cf000 ldr pc, [ip]
if ( rc ) {
30007148: e3500000 cmp r0, #0
3000714c: 1a00003e bne 3000724c <open+0x1c8>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
30007150: e3150b01 tst r5, #1024 ; 0x400
30007154: 1a00001c bne 300071cc <open+0x148>
30007158: e59f518c ldr r5, [pc, #396] ; 300072ec <open+0x268>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
3000715c: e5953000 ldr r3, [r5] 30007160: e0634004 rsb r4, r3, r4 30007164: e1a041c4 asr r4, r4, #3 30007168: e0843184 add r3, r4, r4, lsl #3 3000716c: e0833303 add r3, r3, r3, lsl #6 30007170: e0843183 add r3, r4, r3, lsl #3 30007174: e0833783 add r3, r3, r3, lsl #15 30007178: e0844183 add r4, r4, r3, lsl #3 3000717c: e2644000 rsb r4, r4, #0
}
30007180: e1a00004 mov r0, r4
30007184: e28dd01c add sp, sp, #28
30007188: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
3000718c: e28dd00c add sp, sp, #12
30007190: e12fff1e bx lr
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
30007194: e3a06017 mov r6, #23
if ( rc ) {
if ( iop )
rtems_libio_free( iop );
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
30007198: eb002bb5 bl 30012074 <__errno> 3000719c: e3e04000 mvn r4, #0 300071a0: e5806000 str r6, [r0] 300071a4: eafffff5 b 30007180 <open+0xfc>
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;
300071a8: e3a06011 mov r6, #17 <== NOT EXECUTED
*/
done:
va_end(ap);
if ( rc ) {
if ( iop )
300071ac: e3540000 cmp r4, #0
rtems_libio_free( iop );
300071b0: 11a00004 movne r0, r4 300071b4: 1b001dc4 blne 3000e8cc <rtems_libio_free>
if ( loc_to_free )
300071b8: e3570000 cmp r7, #0
300071bc: 0afffff5 beq 30007198 <open+0x114>
rtems_filesystem_freenode( loc_to_free );
300071c0: e1a00007 mov r0, r7 <== NOT EXECUTED 300071c4: ebfffcae bl 30006484 <rtems_filesystem_freenode> <== NOT EXECUTED 300071c8: eafffff2 b 30007198 <open+0x114> <== NOT EXECUTED
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
300071cc: e59f5118 ldr r5, [pc, #280] ; 300072ec <open+0x268> 300071d0: e3a01000 mov r1, #0 300071d4: e5953000 ldr r3, [r5] 300071d8: e3a02000 mov r2, #0 300071dc: e0633004 rsb r3, r3, r4 300071e0: e1a031c3 asr r3, r3, #3 300071e4: e0830183 add r0, r3, r3, lsl #3 300071e8: e0800300 add r0, r0, r0, lsl #6 300071ec: e0830180 add r0, r3, r0, lsl #3 300071f0: e0800780 add r0, r0, r0, lsl #15 300071f4: e0830180 add r0, r3, r0, lsl #3 300071f8: e2600000 rsb r0, r0, #0 300071fc: eb001d10 bl 3000e644 <ftruncate>
if ( rc ) {
30007200: e2506000 subs r6, r0, #0
30007204: 0affffd4 beq 3000715c <open+0xd8>
if(errno) rc = errno;
30007208: eb002b99 bl 30012074 <__errno> <== NOT EXECUTED 3000720c: e5903000 ldr r3, [r0] <== NOT EXECUTED 30007210: e3530000 cmp r3, #0 <== NOT EXECUTED 30007214: 1a000031 bne 300072e0 <open+0x25c> <== NOT EXECUTED
close( iop - rtems_libio_iops );
30007218: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000721c: e0634004 rsb r4, r3, r4 <== NOT EXECUTED 30007220: e1a041c4 asr r4, r4, #3 <== NOT EXECUTED 30007224: e0843184 add r3, r4, r4, lsl #3 <== NOT EXECUTED 30007228: e0833303 add r3, r3, r3, lsl #6 <== NOT EXECUTED 3000722c: e0843183 add r3, r4, r3, lsl #3 <== NOT EXECUTED 30007230: e0833783 add r3, r3, r3, lsl #15 <== NOT EXECUTED 30007234: e0840183 add r0, r4, r3, lsl #3 <== NOT EXECUTED 30007238: e2600000 rsb r0, r0, #0 <== NOT EXECUTED
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
3000723c: 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 );
30007240: eb001cdf bl 3000e5c4 <close> <== NOT EXECUTED
/* those are released by close(): */
iop = 0;
30007244: e1a07004 mov r7, r4 <== NOT EXECUTED 30007248: ea000001 b 30007254 <open+0x1d0> <== 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;
3000724c: eb002b88 bl 30012074 <__errno> <== NOT EXECUTED 30007250: e5906000 ldr r6, [r0] <== NOT EXECUTED
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
30007254: e3560000 cmp r6, #0 <== NOT EXECUTED 30007258: 0affffbe beq 30007158 <open+0xd4> <== NOT EXECUTED 3000725c: eaffffd2 b 300071ac <open+0x128> <== NOT EXECUTED
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
if ( errno != ENOENT ) {
30007260: eb002b83 bl 30012074 <__errno> 30007264: e5903000 ldr r3, [r0] 30007268: e3530002 cmp r3, #2
3000726c: 0a000003 beq 30007280 <open+0x1fc>
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
30007270: eb002b7f bl 30012074 <__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;
30007274: 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;
30007278: e5906000 ldr r6, [r0] <== NOT EXECUTED
goto done;
3000727c: eafffff4 b 30007254 <open+0x1d0> <== NOT EXECUTED
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
30007280: e2159c02 ands r9, 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;
30007284: 01a07009 moveq r7, r9
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
rc = ENOENT;
30007288: 01a06003 moveq r6, r3
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
3000728c: 0affffc6 beq 300071ac <open+0x128>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
30007290: e1a00006 mov r0, r6 30007294: e38a1902 orr r1, sl, #32768 ; 0x8000 30007298: e3a02000 mov r2, #0 3000729c: e3a03000 mov r3, #0 300072a0: ebfffd97 bl 30006904 <mknod>
if ( rc ) {
300072a4: e2509000 subs r9, r0, #0
300072a8: 1afffff0 bne 30007270 <open+0x1ec>
/*
* 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(
300072ac: e1a00006 mov r0, r6 300072b0: eb002f59 bl 3001301c <strlen> 300072b4: e1a03007 mov r3, r7 300072b8: e1a01000 mov r1, r0 300072bc: e1a02009 mov r2, r9 300072c0: e1a00006 mov r0, r6 300072c4: e58d8000 str r8, [sp] 300072c8: ebfffc33 bl 3000639c <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
300072cc: 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;
300072d0: 11a07009 movne r7, r9
* 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;
300072d4: 13a0600d movne r6, #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 */
300072d8: 1affffb3 bne 300071ac <open+0x128>
300072dc: eaffff87 b 30007100 <open+0x7c>
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
300072e0: eb002b63 bl 30012074 <__errno> <== NOT EXECUTED 300072e4: e5906000 ldr r6, [r0] <== NOT EXECUTED 300072e8: eaffffca b 30007218 <open+0x194> <== NOT EXECUTED
30008000 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008000: e92d4010 push {r4, lr}
int i;
if (tty->termios.c_oflag & OPOST) {
30008004: e5913034 ldr r3, [r1, #52] ; 0x34
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008008: e24dd004 sub sp, sp, #4
int i;
if (tty->termios.c_oflag & OPOST) {
3000800c: e3130001 tst r3, #1
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008010: e1a04001 mov r4, r1 30008014: e5cd0000 strb r0, [sp]
int i;
if (tty->termios.c_oflag & OPOST) {
30008018: 0a000014 beq 30008070 <oproc+0x70>
switch (c) {
3000801c: e5dd1000 ldrb r1, [sp] 30008020: e2412008 sub r2, r1, #8 30008024: e3520005 cmp r2, #5 30008028: 979ff102 ldrls pc, [pc, r2, lsl #2] 3000802c: ea000005 b 30008048 <oproc+0x48> 30008030: 300080f8 .word 0x300080f8 30008034: 300080c0 .word 0x300080c0 30008038: 3000810c .word 0x3000810c 3000803c: 30008048 .word 0x30008048 30008040: 30008048 .word 0x30008048 30008044: 30008088 .word 0x30008088
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
30008048: e3130002 tst r3, #2
3000804c: 1a00003a bne 3000813c <oproc+0x13c>
30008050: e59f310c ldr r3, [pc, #268] ; 30008164 <oproc+0x164> 30008054: e5933000 ldr r3, [r3]
c = toupper(c);
if (!iscntrl(c))
30008058: e0831001 add r1, r3, r1 3000805c: e5d13001 ldrb r3, [r1, #1] 30008060: e3130020 tst r3, #32
tty->column++;
30008064: 05943028 ldreq r3, [r4, #40] ; 0x28 30008068: 02833001 addeq r3, r3, #1 3000806c: 05843028 streq r3, [r4, #40] ; 0x28
break;
}
}
rtems_termios_puts (&c, 1, tty);
30008070: e1a0000d mov r0, sp 30008074: e3a01001 mov r1, #1 30008078: e1a02004 mov r2, r4 3000807c: ebffff98 bl 30007ee4 <rtems_termios_puts>
}
30008080: e28dd004 add sp, sp, #4
30008084: e8bd8010 pop {r4, pc}
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
30008088: e3130010 tst r3, #16 <== NOT EXECUTED 3000808c: 0a000002 beq 3000809c <oproc+0x9c> <== NOT EXECUTED 30008090: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED 30008094: e3520000 cmp r2, #0 <== NOT EXECUTED 30008098: 0afffff8 beq 30008080 <oproc+0x80> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
3000809c: e2132008 ands r2, r3, #8 <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
300080a0: 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) {
300080a4: 0afffff1 beq 30008070 <oproc+0x70> <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
300080a8: 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';
300080ac: e3a0300a mov r3, #10 <== NOT EXECUTED 300080b0: e5cd3000 strb r3, [sp] <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
300080b4: 13a03000 movne r3, #0 <== NOT EXECUTED 300080b8: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300080bc: eaffffeb b 30008070 <oproc+0x70> <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
300080c0: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
300080c4: e2033b06 and r3, r3, #6144 ; 0x1800 <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
300080c8: e2021007 and r1, r2, #7 <== NOT EXECUTED
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
300080cc: e3530b06 cmp r3, #6144 ; 0x1800 <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
300080d0: e2611008 rsb r1, r1, #8 <== NOT EXECUTED
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
300080d4: 10811002 addne r1, r1, r2 <== NOT EXECUTED 300080d8: 15841028 strne r1, [r4, #40] ; 0x28 <== NOT EXECUTED
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
300080dc: 1affffe3 bne 30008070 <oproc+0x70> <== NOT EXECUTED
tty->column += i;
300080e0: e0812002 add r2, r1, r2 <== NOT EXECUTED 300080e4: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED
rtems_termios_puts ( " ", i, tty);
300080e8: e59f0078 ldr r0, [pc, #120] ; 30008168 <oproc+0x168> <== NOT EXECUTED 300080ec: e1a02004 mov r2, r4 <== NOT EXECUTED 300080f0: ebffff7b bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
return;
300080f4: eaffffe1 b 30008080 <oproc+0x80> <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
300080f8: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300080fc: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
30008100: c2433001 subgt r3, r3, #1 <== NOT EXECUTED 30008104: c5843028 strgt r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30008108: eaffffd8 b 30008070 <oproc+0x70> <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
3000810c: e3130020 tst r3, #32
tty->column = 0;
30008110: 13a02000 movne r2, #0 30008114: 15842028 strne r2, [r4, #40] ; 0x28
if (tty->termios.c_oflag & ONLCR) {
30008118: e3130004 tst r3, #4
3000811c: 0affffd3 beq 30008070 <oproc+0x70>
rtems_termios_puts ("\r", 1, tty);
30008120: e59f0044 ldr r0, [pc, #68] ; 3000816c <oproc+0x16c> 30008124: e3a01001 mov r1, #1 30008128: e1a02004 mov r2, r4 3000812c: ebffff6c bl 30007ee4 <rtems_termios_puts>
tty->column = 0;
30008130: e3a03000 mov r3, #0 30008134: e5843028 str r3, [r4, #40] ; 0x28 30008138: eaffffcc b 30008070 <oproc+0x70>
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
3000813c: e59f3020 ldr r3, [pc, #32] ; 30008164 <oproc+0x164> <== NOT EXECUTED 30008140: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008144: e0832001 add r2, r3, r1 <== NOT EXECUTED 30008148: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED 3000814c: e2022003 and r2, r2, #3 <== NOT EXECUTED 30008150: e3520002 cmp r2, #2 <== NOT EXECUTED 30008154: 02411020 subeq r1, r1, #32 <== NOT EXECUTED 30008158: e20110ff and r1, r1, #255 ; 0xff <== NOT EXECUTED 3000815c: e5cd1000 strb r1, [sp] <== NOT EXECUTED 30008160: eaffffbc b 30008058 <oproc+0x58> <== NOT EXECUTED
30008578 <pathconf>:
long pathconf(
const char *path,
int name
)
{
30008578: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000857c: e1a05001 mov r5, r1 <== NOT EXECUTED
int status;
int fd;
fd = open( path, O_RDONLY );
30008580: e3a01000 mov r1, #0 <== NOT EXECUTED 30008584: ebffff5c bl 300082fc <open> <== NOT EXECUTED
if ( fd == -1 )
30008588: e3700001 cmn r0, #1 <== NOT EXECUTED
)
{
int status;
int fd;
fd = open( path, O_RDONLY );
3000858c: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( fd == -1 )
30008590: 0a000006 beq 300085b0 <pathconf+0x38> <== NOT EXECUTED
return -1;
status = fpathconf( fd, name );
30008594: e1a01005 mov r1, r5 <== NOT EXECUTED 30008598: ebfffabe bl 30007098 <fpathconf> <== NOT EXECUTED 3000859c: e1a05000 mov r5, r0 <== NOT EXECUTED
(void) close( fd );
300085a0: e1a00004 mov r0, r4 <== NOT EXECUTED 300085a4: ebfff991 bl 30006bf0 <close> <== NOT EXECUTED
return status;
300085a8: e1a00005 mov r0, r5 <== NOT EXECUTED
300085ac: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
300085b0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000bcc0 <pause>:
/*
* 3.4.2 Suspend Process Execution, P1003.1b-1993, p. 81
*/
int pause( void )
{
3000bcc0: e92d4010 push {r4, lr} <== NOT EXECUTED
3000bcc4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
sigset_t all_signals;
int status;
(void) sigfillset( &all_signals );
3000bcc8: e1a0000d mov r0, sp <== NOT EXECUTED 3000bccc: eb000337 bl 3000c9b0 <sigfillset> <== NOT EXECUTED
status = sigtimedwait( &all_signals, NULL, NULL );
3000bcd0: e3a01000 mov r1, #0 <== NOT EXECUTED 3000bcd4: e1a0000d mov r0, sp <== NOT EXECUTED 3000bcd8: e1a02001 mov r2, r1 <== NOT EXECUTED
int pause( void )
{
sigset_t all_signals;
int status;
(void) sigfillset( &all_signals );
3000bcdc: e1a0400d mov r4, sp <== NOT EXECUTED
status = sigtimedwait( &all_signals, NULL, NULL );
3000bce0: eb00039d bl 3000cb5c <sigtimedwait> <== NOT EXECUTED
return status;
}
3000bce4: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000bce8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30008924 <pipe>:
int pipe(
int filsdes[2]
)
{
if (filsdes == NULL)
30008924: e3500000 cmp r0, #0 <== NOT EXECUTED
extern int pipe_create(int filsdes[2]);
int pipe(
int filsdes[2]
)
{
30008928: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if (filsdes == NULL)
3000892c: 0a000001 beq 30008938 <pipe+0x14> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
return pipe_create(filsdes);
}
30008930: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
)
{
if (filsdes == NULL)
rtems_set_errno_and_return_minus_one( EFAULT );
return pipe_create(filsdes);
30008934: ea001c2d b 3000f9f0 <pipe_create> <== NOT EXECUTED
int pipe(
int filsdes[2]
)
{
if (filsdes == NULL)
rtems_set_errno_and_return_minus_one( EFAULT );
30008938: eb002d17 bl 30013d9c <__errno> <== NOT EXECUTED 3000893c: e3a0300e mov r3, #14 <== NOT EXECUTED 30008940: e5803000 str r3, [r0] <== NOT EXECUTED
return pipe_create(filsdes);
}
30008944: e3e00000 mvn r0, #0 <== NOT EXECUTED
30008948: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000f9f0 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
3000f9f0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
3000f9f4: e59f1128 ldr r1, [pc, #296] ; 3000fb24 <pipe_create+0x134> <== NOT EXECUTED
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
3000f9f8: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 3000f9fc: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
3000fa00: e59f0120 ldr r0, [pc, #288] ; 3000fb28 <pipe_create+0x138> <== NOT EXECUTED 3000fa04: eb0005ea bl 300111b4 <rtems_mkdir> <== NOT EXECUTED 3000fa08: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
3000fa0c: 13e03000 mvnne r3, #0 <== NOT EXECUTED
)
{
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
3000fa10: 0a000002 beq 3000fa20 <pipe_create+0x30> <== NOT EXECUTED
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
3000fa14: e1a00003 mov r0, r3 <== NOT EXECUTED
3000fa18: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000fa1c: e8bd8070 pop {r4, r5, r6, pc} <== 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);
3000fa20: e59f2104 ldr r2, [pc, #260] ; 3000fb2c <pipe_create+0x13c> <== NOT EXECUTED
3000fa24: e1a0c00d mov ip, sp <== NOT EXECUTED
3000fa28: e8920007 ldm r2, {r0, r1, r2} <== NOT EXECUTED
3000fa2c: e8ac0003 stmia ip!, {r0, r1} <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
3000fa30: e59f30f8 ldr r3, [pc, #248] ; 3000fb30 <pipe_create+0x140> <== 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);
3000fa34: e1a0100c mov r1, ip <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
3000fa38: e1d3c0b0 ldrh ip, [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);
3000fa3c: e1c120b0 strh r2, [r1] <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
3000fa40: e28ce001 add lr, ip, #1 <== NOT EXECUTED 3000fa44: e59f10e8 ldr r1, [pc, #232] ; 3000fb34 <pipe_create+0x144> <== NOT EXECUTED 3000fa48: e1a0200c mov r2, ip <== NOT EXECUTED 3000fa4c: e1c3e0b0 strh lr, [r3] <== NOT EXECUTED 3000fa50: e28d000a add r0, sp, #10 <== NOT EXECUTED 3000fa54: eb00138f bl 30014898 <sprintf> <== NOT EXECUTED
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
3000fa58: e1a0000d mov r0, sp <== NOT EXECUTED 3000fa5c: e3a01d06 mov r1, #384 ; 0x180 <== NOT EXECUTED 3000fa60: eb000529 bl 30010f0c <mkfifo> <== NOT EXECUTED 3000fa64: e2506000 subs r6, r0, #0 <== 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);
3000fa68: e1a0400d mov r4, sp <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
3000fa6c: 1a000029 bne 3000fb18 <pipe_create+0x128> <== 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);
3000fa70: e1a0000d mov r0, sp <== NOT EXECUTED 3000fa74: e3a01901 mov r1, #16384 ; 0x4000 <== NOT EXECUTED 3000fa78: ebffe30a bl 300086a8 <open> <== NOT EXECUTED
if (filsdes[0] < 0) {
3000fa7c: 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);
3000fa80: e5850000 str r0, [r5] <== NOT EXECUTED
if (filsdes[0] < 0) {
3000fa84: ba000019 blt 3000faf0 <pipe_create+0x100> <== 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]);
3000fa88: e59f30a8 ldr r3, [pc, #168] ; 3000fb38 <pipe_create+0x148> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
3000fa8c: 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]);
3000fa90: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000fa94: e1500003 cmp r0, r3 <== NOT EXECUTED 3000fa98: 359f309c ldrcc r3, [pc, #156] ; 3000fb3c <pipe_create+0x14c><== NOT EXECUTED 3000fa9c: 30600180 rsbcc r0, r0, r0, lsl #3 <== NOT EXECUTED 3000faa0: 35933000 ldrcc r3, [r3] <== NOT EXECUTED 3000faa4: 30836180 addcc r6, r3, r0, lsl #3 <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
3000faa8: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
filsdes[1] = open(fifopath, O_WRONLY);
3000faac: 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;
3000fab0: e3c33001 bic r3, r3, #1 <== NOT EXECUTED 3000fab4: e5863014 str r3, [r6, #20] <== NOT EXECUTED
filsdes[1] = open(fifopath, O_WRONLY);
3000fab8: ebffe2fa bl 300086a8 <open> <== NOT EXECUTED
if (filsdes[1] < 0) {
3000fabc: 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);
3000fac0: e5850004 str r0, [r5, #4] <== NOT EXECUTED
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
3000fac4: 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) {
3000fac8: ba00000d blt 3000fb04 <pipe_create+0x114> <== NOT EXECUTED
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
3000facc: e1a0000d mov r0, sp <== NOT EXECUTED 3000fad0: ebffeb41 bl 3000a7dc <unlink> <== NOT EXECUTED
} if(err != 0)
3000fad4: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(err);
return 0;
3000fad8: 01a03006 moveq r3, r6 <== NOT EXECUTED
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
3000fadc: 0affffcc beq 3000fa14 <pipe_create+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(err);
3000fae0: eb0010ad bl 30013d9c <__errno> <== NOT EXECUTED 3000fae4: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000fae8: e5806000 str r6, [r0] <== NOT EXECUTED 3000faec: eaffffc8 b 3000fa14 <pipe_create+0x24> <== NOT EXECUTED
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
if (filsdes[0] < 0) {
err = errno;
3000faf0: eb0010a9 bl 30013d9c <__errno> <== NOT EXECUTED 3000faf4: e5906000 ldr r6, [r0] <== NOT EXECUTED
/* Delete file at errors, or else if pipe is successfully created
the file node will be deleted after it is closed by all. */
unlink(fifopath);
3000faf8: e1a0000d mov r0, sp <== NOT EXECUTED 3000fafc: ebffeb36 bl 3000a7dc <unlink> <== NOT EXECUTED 3000fb00: eafffff3 b 3000fad4 <pipe_create+0xe4> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
err = errno;
3000fb04: eb0010a4 bl 30013d9c <__errno> <== NOT EXECUTED 3000fb08: e5906000 ldr r6, [r0] <== NOT EXECUTED
close(filsdes[0]);
3000fb0c: e5950000 ldr r0, [r5] <== NOT EXECUTED 3000fb10: ebffde95 bl 3000756c <close> <== NOT EXECUTED 3000fb14: eaffffec b 3000facc <pipe_create+0xdc> <== NOT EXECUTED
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
if (errno != EEXIST){
3000fb18: eb00109f bl 30013d9c <__errno> <== NOT EXECUTED
return -1;
3000fb1c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000fb20: eaffffbb b 3000fa14 <pipe_create+0x24> <== NOT EXECUTED
30011148 <pipe_ioctl>:
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
30011148: e59f3058 ldr r3, [pc, #88] ; 300111a8 <pipe_ioctl+0x60> <== NOT EXECUTED
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
3001114c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if (cmd == FIONREAD) {
30011150: e1510003 cmp r1, r3 <== NOT EXECUTED
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
30011154: e1a05000 mov r5, r0 <== NOT EXECUTED 30011158: e1a04002 mov r4, r2 <== NOT EXECUTED
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
3001115c: 13e00015 mvnne r0, #21 <== NOT EXECUTED
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
30011160: 18bd8070 popne {r4, r5, r6, pc} <== NOT EXECUTED
if (buffer == NULL)
30011164: e3520000 cmp r2, #0 <== NOT EXECUTED
return -EFAULT;
30011168: 03e0000d mvneq r0, #13 <== NOT EXECUTED
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
3001116c: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return -EFAULT;
if (! PIPE_LOCK(pipe))
30011170: e3a01000 mov r1, #0 <== NOT EXECUTED 30011174: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30011178: e1a02001 mov r2, r1 <== NOT EXECUTED 3001117c: ebffeb46 bl 3000be9c <rtems_semaphore_obtain> <== NOT EXECUTED 30011180: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30011184: 0a000001 beq 30011190 <pipe_ioctl+0x48> <== NOT EXECUTED
return -EINTR;
30011188: e3e00003 mvn r0, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
3001118c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
30011190: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30011194: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
30011198: e5843000 str r3, [r4] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
3001119c: ebffeb87 bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
return 0;
300111a0: e1a00006 mov r0, r6 <== NOT EXECUTED
300111a4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300111ac <pipe_lseek>:
rtems_libio_t *iop
)
{
/* Seek on pipe is not supported */
return -ESPIPE;
}
300111ac: e3e0001c mvn r0, #28 <== NOT EXECUTED 300111b0: e12fff1e bx lr <== NOT EXECUTED
30010d7c <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010d7c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
30010d80: e1a09001 mov r9, r1 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
30010d84: e3a01000 mov r1, #0 <== NOT EXECUTED
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010d88: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30010d8c: e1a04000 mov r4, r0 <== NOT EXECUTED 30010d90: e1a05002 mov r5, r2 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
30010d94: e5900028 ldr r0, [r0, #40] ; 0x28 <== NOT EXECUTED 30010d98: e1a02001 mov r2, r1 <== NOT EXECUTED
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010d9c: e1a07003 mov r7, r3 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
30010da0: ebffec3d bl 3000be9c <rtems_semaphore_obtain> <== NOT EXECUTED 30010da4: e250a000 subs sl, r0, #0 <== NOT EXECUTED
return -EINTR;
30010da8: 13e00003 mvnne r0, #3 <== NOT EXECUTED
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
30010dac: 1a000028 bne 30010e54 <pipe_read+0xd8> <== NOT EXECUTED
return -EINTR;
while (read < count) {
30010db0: e3550000 cmp r5, #0 <== NOT EXECUTED 30010db4: 01a08005 moveq r8, r5 <== NOT EXECUTED 30010db8: 01a06008 moveq r6, r8 <== NOT EXECUTED 30010dbc: 0a00001f beq 30010e40 <pipe_read+0xc4> <== NOT EXECUTED 30010dc0: e1a0800a mov r8, sl <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
30010dc4: e28db004 add fp, sp, #4 <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
30010dc8: e594200c ldr r2, [r4, #12] <== NOT EXECUTED 30010dcc: e3520000 cmp r2, #0 <== NOT EXECUTED 30010dd0: 1a000021 bne 30010e5c <pipe_read+0xe0> <== NOT EXECUTED
/* Not an error */
if (pipe->Writers == 0)
30010dd4: e5946014 ldr r6, [r4, #20] <== NOT EXECUTED 30010dd8: e3560000 cmp r6, #0 <== NOT EXECUTED 30010ddc: 0a000017 beq 30010e40 <pipe_read+0xc4> <== NOT EXECUTED
goto out_locked;
if (LIBIO_NODELAY(iop)) {
30010de0: e5976014 ldr r6, [r7, #20] <== NOT EXECUTED 30010de4: e2166001 ands r6, r6, #1 <== NOT EXECUTED 30010de8: 1a00003b bne 30010edc <pipe_read+0x160> <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
30010dec: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010df0: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
30010df4: e2833001 add r3, r3, #1 <== NOT EXECUTED 30010df8: e5843018 str r3, [r4, #24] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010dfc: ebffec6f bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
30010e00: e1a01006 mov r1, r6 <== NOT EXECUTED 30010e04: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED 30010e08: eb00062d bl 300126c4 <rtems_barrier_wait> <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010e0c: e1a01006 mov r1, r6 <== NOT EXECUTED 30010e10: e1a02001 mov r2, r1 <== NOT EXECUTED
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
30010e14: e2506000 subs r6, r0, #0 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010e18: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
30010e1c: 13e06003 mvnne r6, #3 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010e20: ebffec1d bl 3000be9c <rtems_semaphore_obtain> <== NOT EXECUTED 30010e24: e3500000 cmp r0, #0 <== NOT EXECUTED 30010e28: 1a00002d bne 30010ee4 <pipe_read+0x168> <== NOT EXECUTED
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
30010e2c: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
if (ret != 0)
30010e30: e3560000 cmp r6, #0 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
30010e34: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30010e38: e5843018 str r3, [r4, #24] <== NOT EXECUTED
if (ret != 0)
30010e3c: 0affffe1 beq 30010dc8 <pipe_read+0x4c> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
30010e40: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 30010e44: ebffec5d bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
out_nolock:
if (read > 0)
30010e48: e3580000 cmp r8, #0 <== NOT EXECUTED 30010e4c: c1a00008 movgt r0, r8 <== NOT EXECUTED 30010e50: d1a00006 movle r0, r6 <== NOT EXECUTED
return read;
return ret;
}
30010e54: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30010e58: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
30010e5c: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 30010e60: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
30010e64: e06a6005 rsb r6, sl, r5 <== NOT EXECUTED 30010e68: e1520006 cmp r2, r6 <== NOT EXECUTED 30010e6c: 31a06002 movcc r6, r2 <== NOT EXECUTED
chunk1 = pipe->Size - pipe->Start;
30010e70: e0613003 rsb r3, r1, r3 <== NOT EXECUTED
if (chunk > chunk1) {
30010e74: e1560003 cmp r6, r3 <== NOT EXECUTED 30010e78: ca00001b bgt 30010eec <pipe_read+0x170> <== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
30010e7c: e5943000 ldr r3, [r4] <== NOT EXECUTED 30010e80: e089000a add r0, r9, sl <== NOT EXECUTED 30010e84: e0831001 add r1, r3, r1 <== NOT EXECUTED 30010e88: e1a02006 mov r2, r6 <== NOT EXECUTED 30010e8c: eb0011fe bl 3001568c <memcpy> <== NOT EXECUTED
pipe->Start += chunk;
30010e90: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
pipe->Start %= pipe->Size;
30010e94: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED 30010e98: e0860000 add r0, r6, r0 <== NOT EXECUTED 30010e9c: eb004109 bl 300212c8 <__umodsi3> <== NOT EXECUTED
pipe->Length -= chunk;
30010ea0: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
30010ea4: e5840008 str r0, [r4, #8] <== NOT EXECUTED
pipe->Length -= chunk;
30010ea8: e0663003 rsb r3, r6, r3 <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
30010eac: e3530000 cmp r3, #0 <== NOT EXECUTED
pipe->Start = 0;
30010eb0: 05843008 streq r3, [r4, #8] <== NOT EXECUTED
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
pipe->Length -= chunk;
30010eb4: e584300c str r3, [r4, #12] <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
30010eb8: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 30010ebc: e3530000 cmp r3, #0 <== NOT EXECUTED 30010ec0: 1a000016 bne 30010f20 <pipe_read+0x1a4> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
30010ec4: e0888006 add r8, r8, r6 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
30010ec8: e1580005 cmp r8, r5 <== NOT EXECUTED 30010ecc: e1a0a008 mov sl, r8 <== NOT EXECUTED 30010ed0: 3affffbc bcc 30010dc8 <pipe_read+0x4c> <== NOT EXECUTED 30010ed4: e3a06000 mov r6, #0 <== NOT EXECUTED 30010ed8: eaffffd8 b 30010e40 <pipe_read+0xc4> <== NOT EXECUTED
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
30010edc: e3e0600a mvn r6, #10 <== NOT EXECUTED 30010ee0: eaffffd6 b 30010e40 <pipe_read+0xc4> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
30010ee4: e3e06003 mvn r6, #3 <== NOT EXECUTED 30010ee8: eaffffd6 b 30010e48 <pipe_read+0xcc> <== NOT EXECUTED
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
30010eec: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010ef0: e1a02003 mov r2, r3 <== NOT EXECUTED 30010ef4: e0801001 add r1, r0, r1 <== NOT EXECUTED 30010ef8: e089000a add r0, r9, sl <== NOT EXECUTED 30010efc: e58d3000 str r3, [sp] <== NOT EXECUTED 30010f00: eb0011e1 bl 3001568c <memcpy> <== NOT EXECUTED
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
30010f04: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30010f08: e5941000 ldr r1, [r4] <== NOT EXECUTED 30010f0c: e08a0003 add r0, sl, r3 <== NOT EXECUTED 30010f10: e0890000 add r0, r9, r0 <== NOT EXECUTED 30010f14: e0632006 rsb r2, r3, r6 <== NOT EXECUTED 30010f18: eb0011db bl 3001568c <memcpy> <== NOT EXECUTED 30010f1c: eaffffdb b 30010e90 <pipe_read+0x114> <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
30010f20: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 30010f24: e1a0100b mov r1, fp <== NOT EXECUTED 30010f28: eb0005cd bl 30012664 <rtems_barrier_release> <== NOT EXECUTED 30010f2c: eaffffe4 b 30010ec4 <pipe_read+0x148> <== NOT EXECUTED
30010818 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
30010818: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
3001081c: e5915014 ldr r5, [r1, #20] <== NOT EXECUTED
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
30010820: e5904000 ldr r4, [r0] <== NOT EXECUTED
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
30010824: e3150002 tst r5, #2 <== NOT EXECUTED
pipe->Readers --;
30010828: 15943010 ldrne r3, [r4, #16] <== NOT EXECUTED
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
3001082c: e2055006 and r5, r5, #6 <== NOT EXECUTED
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
30010830: 12433001 subne r3, r3, #1 <== NOT EXECUTED 30010834: 15843010 strne r3, [r4, #16] <== NOT EXECUTED
if (mode & LIBIO_FLAGS_WRITE)
30010838: e3150004 tst r5, #4 <== NOT EXECUTED
pipe->Writers --;
3001083c: 15943014 ldrne r3, [r4, #20] <== NOT EXECUTED
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
30010840: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
30010844: 12433001 subne r3, r3, #1 <== NOT EXECUTED 30010848: 15843014 strne r3, [r4, #20] <== NOT EXECUTED
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3001084c: e1a06000 mov r6, r0 <== NOT EXECUTED
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
PIPE_UNLOCK(pipe);
30010850: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 30010854: ebffedd9 bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
if (pipe->Readers == 0 && pipe->Writers == 0) {
30010858: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 3001085c: e3530000 cmp r3, #0 <== NOT EXECUTED 30010860: 1a000007 bne 30010884 <pipe_release+0x6c> <== NOT EXECUTED 30010864: e5947014 ldr r7, [r4, #20] <== NOT EXECUTED 30010868: e3570000 cmp r7, #0 <== NOT EXECUTED 3001086c: 0a000013 beq 300108c0 <pipe_release+0xa8> <== NOT EXECUTED
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
30010870: e3550004 cmp r5, #4 <== NOT EXECUTED 30010874: 1a00000d bne 300108b0 <pipe_release+0x98> <== NOT EXECUTED
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
PIPE_WAKEUPREADERS(pipe);
pipe_unlock();
30010878: ebffffe2 bl 30010808 <pipe_unlock> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
3001087c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30010880: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
30010884: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 30010888: e2733001 rsbs r3, r3, #1 <== NOT EXECUTED 3001088c: 33a03000 movcc r3, #0 <== NOT EXECUTED 30010890: e3550002 cmp r5, #2 <== NOT EXECUTED 30010894: 03a03000 moveq r3, #0 <== NOT EXECUTED 30010898: e3530000 cmp r3, #0 <== NOT EXECUTED 3001089c: 0afffff5 beq 30010878 <pipe_release+0x60> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
300108a0: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED 300108a4: e1a0100d mov r1, sp <== NOT EXECUTED 300108a8: eb00076d bl 30012664 <rtems_barrier_release> <== NOT EXECUTED 300108ac: eafffff1 b 30010878 <pipe_release+0x60> <== NOT EXECUTED
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
300108b0: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 300108b4: e1a0100d mov r1, sp <== NOT EXECUTED 300108b8: eb000769 bl 30012664 <rtems_barrier_release> <== NOT EXECUTED 300108bc: eaffffed b 30010878 <pipe_release+0x60> <== NOT EXECUTED
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
300108c0: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED 300108c4: eb00073a bl 300125b4 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
300108c8: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 300108cc: eb000738 bl 300125b4 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
300108d0: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 300108d4: ebffed47 bl 3000bdf8 <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
300108d8: e5940000 ldr r0, [r4] <== NOT EXECUTED 300108dc: ebffde43 bl 300081f0 <free> <== NOT EXECUTED
free(pipe);
300108e0: e1a00004 mov r0, r4 <== NOT EXECUTED 300108e4: ebffde41 bl 300081f0 <free> <== NOT EXECUTED
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
300108e8: e5867000 str r7, [r6] <== NOT EXECUTED 300108ec: eaffffe1 b 30010878 <pipe_release+0x60> <== NOT EXECUTED
30010808 <pipe_unlock>:
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
30010808: e59f3004 ldr r3, [pc, #4] ; 30010814 <pipe_unlock+0xc> <== NOT EXECUTED 3001080c: e5930000 ldr r0, [r3] <== NOT EXECUTED 30010810: eaffedea b 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
30010f30 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010f30: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
30010f34: e2524000 subs r4, r2, #0 <== NOT EXECUTED
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010f38: e1a05000 mov r5, r0 <== NOT EXECUTED 30010f3c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30010f40: e1a06001 mov r6, r1 <== NOT EXECUTED
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
30010f44: 01a00004 moveq r0, r4 <== NOT EXECUTED
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
30010f48: 1a000001 bne 30010f54 <pipe_write+0x24> <== NOT EXECUTED
#endif
if (written > 0)
return written;
return ret;
}
30010f4c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30010f50: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
30010f54: e3a01000 mov r1, #0 <== NOT EXECUTED 30010f58: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010f5c: e1a02001 mov r2, r1 <== NOT EXECUTED 30010f60: e58d3000 str r3, [sp] <== NOT EXECUTED 30010f64: ebffebcc bl 3000be9c <rtems_semaphore_obtain> <== NOT EXECUTED 30010f68: e2509000 subs r9, r0, #0 <== NOT EXECUTED 30010f6c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return -EINTR;
30010f70: 13e00003 mvnne r0, #3 <== NOT EXECUTED
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
30010f74: 1afffff4 bne 30010f4c <pipe_write+0x1c> <== NOT EXECUTED
return -EINTR;
if (pipe->Readers == 0) {
30010f78: e595a010 ldr sl, [r5, #16] <== NOT EXECUTED 30010f7c: e35a0000 cmp sl, #0 <== NOT EXECUTED 30010f80: 0a000058 beq 300110e8 <pipe_write+0x1b8> <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
30010f84: e5957004 ldr r7, [r5, #4] <== NOT EXECUTED 30010f88: e1a0a009 mov sl, r9 <== NOT EXECUTED 30010f8c: e1540007 cmp r4, r7 <== NOT EXECUTED 30010f90: 91a08004 movls r8, r4 <== NOT EXECUTED 30010f94: 83a08001 movhi r8, #1 <== NOT EXECUTED
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
30010f98: e28db004 add fp, sp, #4 <== NOT EXECUTED
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
30010f9c: e595100c ldr r1, [r5, #12] <== NOT EXECUTED 30010fa0: e0612007 rsb r2, r1, r7 <== NOT EXECUTED 30010fa4: e1520008 cmp r2, r8 <== NOT EXECUTED 30010fa8: 2a000021 bcs 30011034 <pipe_write+0x104> <== NOT EXECUTED
if (LIBIO_NODELAY(iop)) {
30010fac: e5937014 ldr r7, [r3, #20] <== NOT EXECUTED 30010fb0: e2177001 ands r7, r7, #1 <== NOT EXECUTED 30010fb4: 1a000053 bne 30011108 <pipe_write+0x1d8> <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
30010fb8: e595201c ldr r2, [r5, #28] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010fbc: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
30010fc0: e2822001 add r2, r2, #1 <== NOT EXECUTED 30010fc4: e585201c str r2, [r5, #28] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010fc8: e58d3000 str r3, [sp] <== NOT EXECUTED 30010fcc: ebffebfb bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
30010fd0: e1a01007 mov r1, r7 <== NOT EXECUTED 30010fd4: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010fd8: eb0005b9 bl 300126c4 <rtems_barrier_wait> <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010fdc: e1a01007 mov r1, r7 <== NOT EXECUTED 30010fe0: e1a02001 mov r2, r1 <== NOT EXECUTED
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
30010fe4: e2507000 subs r7, r0, #0 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010fe8: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
30010fec: 13e07003 mvnne r7, #3 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010ff0: ebffeba9 bl 3000be9c <rtems_semaphore_obtain> <== NOT EXECUTED 30010ff4: e3500000 cmp r0, #0 <== NOT EXECUTED 30010ff8: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30010ffc: 1a00003f bne 30011100 <pipe_write+0x1d0> <== NOT EXECUTED
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
30011000: e595201c ldr r2, [r5, #28] <== NOT EXECUTED
if (ret != 0)
30011004: e3570000 cmp r7, #0 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
30011008: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3001100c: e585201c str r2, [r5, #28] <== NOT EXECUTED
if (ret != 0)
30011010: 1a00002c bne 300110c8 <pipe_write+0x198> <== NOT EXECUTED
goto out_locked;
if (pipe->Readers == 0) {
30011014: e5952010 ldr r2, [r5, #16] <== NOT EXECUTED 30011018: e3520000 cmp r2, #0 <== NOT EXECUTED 3001101c: 0a000031 beq 300110e8 <pipe_write+0x1b8> <== NOT EXECUTED 30011020: e5957004 ldr r7, [r5, #4] <== NOT EXECUTED
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
30011024: e595100c ldr r1, [r5, #12] <== NOT EXECUTED 30011028: e0612007 rsb r2, r1, r7 <== NOT EXECUTED 3001102c: e1520008 cmp r2, r8 <== NOT EXECUTED 30011030: 3affffdd bcc 30010fac <pipe_write+0x7c> <== NOT EXECUTED
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
30011034: e5950008 ldr r0, [r5, #8] <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
30011038: e0698004 rsb r8, r9, r4 <== NOT EXECUTED
chunk1 = pipe->Size - PIPE_WSTART(pipe);
3001103c: e0810000 add r0, r1, r0 <== NOT EXECUTED 30011040: e1a01007 mov r1, r7 <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
30011044: e1520008 cmp r2, r8 <== NOT EXECUTED 30011048: 31a08002 movcc r8, r2 <== NOT EXECUTED
chunk1 = pipe->Size - PIPE_WSTART(pipe);
3001104c: e58d3000 str r3, [sp] <== NOT EXECUTED 30011050: eb00409c bl 300212c8 <__umodsi3> <== NOT EXECUTED 30011054: e0607007 rsb r7, r0, r7 <== NOT EXECUTED
if (chunk > chunk1) {
30011058: e1580007 cmp r8, r7 <== NOT EXECUTED
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
3001105c: e1a0c000 mov ip, r0 <== NOT EXECUTED
if (chunk > chunk1) {
30011060: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30011064: da000029 ble 30011110 <pipe_write+0x1e0> <== NOT EXECUTED
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
30011068: e5950000 ldr r0, [r5] <== NOT EXECUTED 3001106c: e0861009 add r1, r6, r9 <== NOT EXECUTED 30011070: e1a02007 mov r2, r7 <== NOT EXECUTED 30011074: e080000c add r0, r0, ip <== NOT EXECUTED 30011078: eb001183 bl 3001568c <memcpy> <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
3001107c: e0871009 add r1, r7, r9 <== NOT EXECUTED 30011080: e5950000 ldr r0, [r5] <== NOT EXECUTED 30011084: e0861001 add r1, r6, r1 <== NOT EXECUTED 30011088: e0672008 rsb r2, r7, r8 <== NOT EXECUTED 3001108c: eb00117e bl 3001568c <memcpy> <== NOT EXECUTED 30011090: e59d3000 ldr r3, [sp] <== NOT EXECUTED
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
30011094: e595200c ldr r2, [r5, #12] <== NOT EXECUTED
if (pipe->waitingReaders > 0)
30011098: e5951018 ldr r1, [r5, #24] <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
3001109c: e0822008 add r2, r2, r8 <== NOT EXECUTED
if (pipe->waitingReaders > 0)
300110a0: e3510000 cmp r1, #0 <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
300110a4: e585200c str r2, [r5, #12] <== NOT EXECUTED
if (pipe->waitingReaders > 0)
300110a8: 1a000020 bne 30011130 <pipe_write+0x200> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
written += chunk;
300110ac: e08aa008 add sl, sl, r8 <== NOT EXECUTED
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
300110b0: e154000a cmp r4, sl <== NOT EXECUTED 300110b4: e1a0900a mov r9, sl <== NOT EXECUTED 300110b8: 85957004 ldrhi r7, [r5, #4] <== NOT EXECUTED
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
written += chunk;
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
300110bc: 83a08001 movhi r8, #1 <== NOT EXECUTED 300110c0: 8affffb5 bhi 30010f9c <pipe_write+0x6c> <== NOT EXECUTED
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
300110c4: e3a07000 mov r7, #0 <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
300110c8: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 300110cc: ebffebbb bl 3000bfc0 <rtems_semaphore_release> <== NOT EXECUTED
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
300110d0: e3770020 cmn r7, #32 <== NOT EXECUTED 300110d4: 0a000005 beq 300110f0 <pipe_write+0x1c0> <== NOT EXECUTED
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
300110d8: e35a0000 cmp sl, #0 <== NOT EXECUTED 300110dc: c1a0000a movgt r0, sl <== NOT EXECUTED 300110e0: d1a00007 movle r0, r7 <== NOT EXECUTED 300110e4: eaffff98 b 30010f4c <pipe_write+0x1c> <== NOT EXECUTED
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
300110e8: e3e0701f mvn r7, #31 <== NOT EXECUTED 300110ec: eafffff5 b 300110c8 <pipe_write+0x198> <== NOT EXECUTED
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
300110f0: eb000221 bl 3001197c <getpid> <== NOT EXECUTED 300110f4: e3a0100d mov r1, #13 <== NOT EXECUTED 300110f8: eb0002ed bl 30011cb4 <kill> <== NOT EXECUTED 300110fc: eafffff5 b 300110d8 <pipe_write+0x1a8> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
30011100: e3e07003 mvn r7, #3 <== NOT EXECUTED 30011104: eafffff3 b 300110d8 <pipe_write+0x1a8> <== NOT EXECUTED
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
30011108: e3e0700a mvn r7, #10 <== NOT EXECUTED 3001110c: eaffffed b 300110c8 <pipe_write+0x198> <== NOT EXECUTED
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
30011110: e5950000 ldr r0, [r5] <== NOT EXECUTED 30011114: e0861009 add r1, r6, r9 <== NOT EXECUTED 30011118: e080000c add r0, r0, ip <== NOT EXECUTED 3001111c: e1a02008 mov r2, r8 <== NOT EXECUTED 30011120: e58d3000 str r3, [sp] <== NOT EXECUTED 30011124: eb001158 bl 3001568c <memcpy> <== NOT EXECUTED 30011128: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3001112c: eaffffd8 b 30011094 <pipe_write+0x164> <== NOT EXECUTED
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
30011130: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 30011134: e1a0100b mov r1, fp <== NOT EXECUTED 30011138: e58d3000 str r3, [sp] <== NOT EXECUTED 3001113c: eb000548 bl 30012664 <rtems_barrier_release> <== NOT EXECUTED 30011140: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30011144: eaffffd8 b 300110ac <pipe_write+0x17c> <== NOT EXECUTED
3000b618 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
3000b618: e92d0030 push {r4, r5} <== NOT EXECUTED
/* * Update call statistics */ MSBUMP(memalign_calls, 1);
3000b61c: e59fc040 ldr ip, [pc, #64] ; 3000b664 <posix_memalign+0x4c><== NOT EXECUTED
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
3000b620: e2414001 sub r4, r1, #1 <== NOT EXECUTED 3000b624: e1140001 tst r4, r1 <== NOT EXECUTED 3000b628: 03a05000 moveq r5, #0 <== NOT EXECUTED 3000b62c: 13a05001 movne r5, #1 <== NOT EXECUTED
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
3000b630: e59c4008 ldr r4, [ip, #8] <== NOT EXECUTED
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
3000b634: e3510003 cmp r1, #3 <== NOT EXECUTED 3000b638: 81a03005 movhi r3, r5 <== NOT EXECUTED 3000b63c: 93853001 orrls r3, r5, #1 <== NOT EXECUTED
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
3000b640: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
3000b644: e3530000 cmp r3, #0 <== NOT EXECUTED
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
3000b648: e58c4008 str r4, [ip, #8] <== NOT EXECUTED
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
3000b64c: 0a000002 beq 3000b65c <posix_memalign+0x44> <== NOT EXECUTED
/* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); }
3000b650: e3a00016 mov r0, #22 <== NOT EXECUTED
3000b654: e8bd0030 pop {r4, r5} <== NOT EXECUTED
3000b658: e12fff1e bx lr <== NOT EXECUTED
3000b65c: e8bd0030 pop {r4, r5} <== NOT EXECUTED
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
3000b660: ea000080 b 3000b868 <rtems_memalign> <== NOT EXECUTED
30008744 <printk_plugin>:
int printk_plugin(
void *ignored __attribute__((unused)),
const char *format,
...
)
{
30008744: e92d000e push {r1, r2, r3} <== NOT EXECUTED
30008748: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000874c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
va_list arg_pointer;
va_start (arg_pointer, format);
30008750: e28d300c add r3, sp, #12 <== NOT EXECUTED
vprintk( format, arg_pointer );
30008754: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 30008758: e1a01003 mov r1, r3 <== NOT EXECUTED
...
)
{
va_list arg_pointer;
va_start (arg_pointer, format);
3000875c: e58d3000 str r3, [sp] <== NOT EXECUTED
vprintk( format, arg_pointer );
30008760: eb000789 bl 3000a58c <vprintk> <== NOT EXECUTED
va_end(arg_pointer); /* clean up when done */
return 0;
}
30008764: e3a00000 mov r0, #0 <== NOT EXECUTED
30008768: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000876c: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
30008770: e28dd00c add sp, sp, #12 <== NOT EXECUTED
30008774: e12fff1e bx lr <== NOT EXECUTED
300099b0 <pthread_atfork>:
int pthread_atfork(
void (*prepare)(void) __attribute__((unused)),
void (*parent)(void) __attribute__((unused)),
void (*child)(void) __attribute__((unused))
)
{
300099b0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
300099b4: eb002407 bl 300129d8 <__errno> <== NOT EXECUTED 300099b8: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300099bc: e5803000 str r3, [r0] <== NOT EXECUTED
}
300099c0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300099c4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ea98 <pthread_attr_destroy>:
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000ea98: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000ea9c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000eaa0: 012fff1e bxeq lr <== NOT EXECUTED 3000eaa4: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000eaa8: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000eaac: 13a00000 movne r0, #0 <== NOT EXECUTED 3000eab0: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000eab4: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000eab8: e12fff1e bx lr <== NOT EXECUTED
3000f234 <pthread_attr_getcputime>:
int pthread_attr_getcputime(
pthread_attr_t *attr,
int *clock_allowed
)
{
if ( !attr || !attr->is_initialized || !clock_allowed )
3000f234: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000f238: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getcputime(
pthread_attr_t *attr,
int *clock_allowed
)
{
if ( !attr || !attr->is_initialized || !clock_allowed )
3000f23c: 012fff1e bxeq lr <== NOT EXECUTED 3000f240: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000f244: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f248: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*clock_allowed = attr->cputime_clock_allowed;
3000f24c: 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 )
3000f250: 13a00000 movne r0, #0 <== NOT EXECUTED 3000f254: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*clock_allowed = attr->cputime_clock_allowed;
3000f258: 15813000 strne r3, [r1] <== NOT EXECUTED
pthread_attr_t *attr,
int *clock_allowed
)
{
if ( !attr || !attr->is_initialized || !clock_allowed )
return EINVAL;
3000f25c: 03a00016 moveq r0, #22 <== NOT EXECUTED
*clock_allowed = attr->cputime_clock_allowed;
return 0;
}
3000f260: e12fff1e bx lr <== NOT EXECUTED
3000eabc <pthread_attr_getdetachstate>:
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000eabc: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000eac0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getdetachstate(
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
3000eac4: 012fff1e bxeq lr <== NOT EXECUTED 3000eac8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000eacc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ead0: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*detachstate = attr->detachstate;
3000ead4: 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 )
3000ead8: 13a00000 movne r0, #0 <== NOT EXECUTED 3000eadc: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*detachstate = attr->detachstate;
3000eae0: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *detachstate
)
{
if ( !attr || !attr->is_initialized || !detachstate )
return EINVAL;
3000eae4: 03a00016 moveq r0, #22 <== NOT EXECUTED
*detachstate = attr->detachstate;
return 0;
}
3000eae8: e12fff1e bx lr <== NOT EXECUTED
3000eaec <pthread_attr_getguardsize>:
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000eaec: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000eaf0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getguardsize(
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
3000eaf4: 012fff1e bxeq lr <== NOT EXECUTED 3000eaf8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000eafc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000eb00: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*guardsize = attr->guardsize;
3000eb04: 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 )
3000eb08: 13a00000 movne r0, #0 <== NOT EXECUTED 3000eb0c: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*guardsize = attr->guardsize;
3000eb10: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
size_t *guardsize
)
{
if ( !attr || !attr->is_initialized || !guardsize )
return EINVAL;
3000eb14: 03a00016 moveq r0, #22 <== NOT EXECUTED
*guardsize = attr->guardsize;
return 0;
}
3000eb18: e12fff1e bx lr <== NOT EXECUTED
3000eb1c <pthread_attr_getinheritsched>:
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000eb1c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000eb20: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000eb24: 012fff1e bxeq lr <== NOT EXECUTED 3000eb28: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000eb2c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000eb30: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*inheritsched = attr->inheritsched;
3000eb34: 15933010 ldrne r3, [r3, #16] <== NOT EXECUTED
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
3000eb38: 13a00000 movne r0, #0 <== NOT EXECUTED 3000eb3c: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*inheritsched = attr->inheritsched;
3000eb40: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
3000eb44: 03a00016 moveq r0, #22 <== NOT EXECUTED
*inheritsched = attr->inheritsched;
return 0;
}
3000eb48: e12fff1e bx lr <== NOT EXECUTED
3000eb4c <pthread_attr_getschedparam>:
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000eb4c: e3500000 cmp r0, #0 <== NOT EXECUTED
int pthread_attr_getschedparam(
const pthread_attr_t *attr,
struct sched_param *param
)
{
3000eb50: e92d0030 push {r4, r5} <== NOT EXECUTED
3000eb54: e1a0c001 mov ip, r1 <== NOT EXECUTED
if ( !attr || !attr->is_initialized || !param )
3000eb58: 0a00000d beq 3000eb94 <pthread_attr_getschedparam+0x48> <== NOT EXECUTED 3000eb5c: e5905000 ldr r5, [r0] <== NOT EXECUTED 3000eb60: e3550000 cmp r5, #0 <== NOT EXECUTED 3000eb64: 13510000 cmpne r1, #0 <== NOT EXECUTED 3000eb68: 13a05000 movne r5, #0 <== NOT EXECUTED 3000eb6c: 03a05001 moveq r5, #1 <== NOT EXECUTED 3000eb70: 0a000007 beq 3000eb94 <pthread_attr_getschedparam+0x48> <== NOT EXECUTED
return EINVAL;
*param = attr->schedparam;
3000eb74: e2804018 add r4, r0, #24 <== NOT EXECUTED
3000eb78: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3000eb7c: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000eb80: e8940007 ldm r4, {r0, r1, r2} <== NOT EXECUTED
3000eb84: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
return 0; }
3000eb88: e1a00005 mov r0, r5 <== NOT EXECUTED
3000eb8c: e8bd0030 pop {r4, r5} <== NOT EXECUTED
3000eb90: e12fff1e bx lr <== NOT EXECUTED
const pthread_attr_t *attr,
struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
3000eb94: e3a05016 mov r5, #22 <== NOT EXECUTED 3000eb98: eafffffa b 3000eb88 <pthread_attr_getschedparam+0x3c> <== NOT EXECUTED
3000eb9c <pthread_attr_getschedpolicy>:
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000eb9c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000eba0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000eba4: 012fff1e bxeq lr <== NOT EXECUTED 3000eba8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000ebac: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ebb0: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*policy = attr->schedpolicy;
3000ebb4: 15933014 ldrne r3, [r3, #20] <== NOT EXECUTED
int pthread_attr_getschedpolicy(
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
3000ebb8: 13a00000 movne r0, #0 <== NOT EXECUTED 3000ebbc: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*policy = attr->schedpolicy;
3000ebc0: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *policy
)
{
if ( !attr || !attr->is_initialized || !policy )
return EINVAL;
3000ebc4: 03a00016 moveq r0, #22 <== NOT EXECUTED
*policy = attr->schedpolicy;
return 0;
}
3000ebc8: e12fff1e bx lr <== NOT EXECUTED
3000ebcc <pthread_attr_getscope>:
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000ebcc: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000ebd0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000ebd4: 012fff1e bxeq lr <== NOT EXECUTED 3000ebd8: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000ebdc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ebe0: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*contentionscope = attr->contentionscope;
3000ebe4: 1593300c ldrne r3, [r3, #12] <== NOT EXECUTED
int pthread_attr_getscope(
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
3000ebe8: 13a00000 movne r0, #0 <== NOT EXECUTED 3000ebec: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*contentionscope = attr->contentionscope;
3000ebf0: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
int *contentionscope
)
{
if ( !attr || !attr->is_initialized || !contentionscope )
return EINVAL;
3000ebf4: 03a00016 moveq r0, #22 <== NOT EXECUTED
*contentionscope = attr->contentionscope;
return 0;
}
3000ebf8: e12fff1e bx lr <== NOT EXECUTED
3000ec2c <pthread_attr_getstack>:
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
3000ec2c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000ec30: 0a00000c beq 3000ec68 <pthread_attr_getstack+0x3c> <== NOT EXECUTED 3000ec34: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000ec38: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ec3c: 13510000 cmpne r1, #0 <== NOT EXECUTED 3000ec40: 13a00000 movne r0, #0 <== NOT EXECUTED 3000ec44: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000ec48: 0a000006 beq 3000ec68 <pthread_attr_getstack+0x3c> <== NOT EXECUTED 3000ec4c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ec50: 0a000006 beq 3000ec70 <pthread_attr_getstack+0x44> <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
3000ec54: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED
*stacksize = attr->stacksize;
3000ec58: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
*stackaddr = attr->stackaddr;
3000ec5c: e581c000 str ip, [r1] <== NOT EXECUTED
*stacksize = attr->stacksize;
3000ec60: e5823000 str r3, [r2] <== NOT EXECUTED
return 0;
3000ec64: e12fff1e bx lr <== NOT EXECUTED
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
3000ec68: e3a00016 mov r0, #22 <== NOT EXECUTED 3000ec6c: e12fff1e bx lr <== NOT EXECUTED 3000ec70: e3a00016 mov r0, #22 <== NOT EXECUTED
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
return 0;
}
3000ec74: e12fff1e bx lr <== NOT EXECUTED
3000ebfc <pthread_attr_getstackaddr>:
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000ebfc: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000ec00: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000ec04: 012fff1e bxeq lr <== NOT EXECUTED 3000ec08: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000ec0c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ec10: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
3000ec14: 15933004 ldrne r3, [r3, #4] <== NOT EXECUTED
int pthread_attr_getstackaddr(
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
3000ec18: 13a00000 movne r0, #0 <== NOT EXECUTED 3000ec1c: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*stackaddr = attr->stackaddr;
3000ec20: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
void **stackaddr
)
{
if ( !attr || !attr->is_initialized || !stackaddr )
return EINVAL;
3000ec24: 03a00016 moveq r0, #22 <== NOT EXECUTED
*stackaddr = attr->stackaddr;
return 0;
}
3000ec28: e12fff1e bx lr <== NOT EXECUTED
3000ec78 <pthread_attr_getstacksize>:
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000ec78: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000ec7c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_getstacksize(
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
3000ec80: 012fff1e bxeq lr <== NOT EXECUTED 3000ec84: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000ec88: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ec8c: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*stacksize = attr->stacksize;
3000ec90: 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 )
3000ec94: 13a00000 movne r0, #0 <== NOT EXECUTED 3000ec98: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*stacksize = attr->stacksize;
3000ec9c: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_attr_t *attr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stacksize )
return EINVAL;
3000eca0: 03a00016 moveq r0, #22 <== NOT EXECUTED
*stacksize = attr->stacksize;
return 0;
}
3000eca4: e12fff1e bx lr <== NOT EXECUTED
3000f718 <pthread_attr_setcputime>:
int pthread_attr_setcputime(
pthread_attr_t *attr,
int clock_allowed
)
{
if ( !attr || !attr->is_initialized )
3000f718: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f71c: 0a000008 beq 3000f744 <pthread_attr_setcputime+0x2c> <== NOT EXECUTED 3000f720: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000f724: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f728: 0a000005 beq 3000f744 <pthread_attr_setcputime+0x2c> <== NOT EXECUTED
return EINVAL;
switch ( clock_allowed ) {
3000f72c: e3510001 cmp r1, #1 <== NOT EXECUTED
case CLOCK_ENABLED:
case CLOCK_DISABLED:
attr->cputime_clock_allowed = clock_allowed;
3000f730: 95801038 strls r1, [r0, #56] ; 0x38 <== NOT EXECUTED
return 0;
3000f734: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( clock_allowed ) {
3000f738: 912fff1e bxls lr <== NOT EXECUTED
case CLOCK_DISABLED:
attr->cputime_clock_allowed = clock_allowed;
return 0;
default:
return EINVAL;
3000f73c: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000f740: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int clock_allowed
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000f744: e3a00016 mov r0, #22 <== NOT EXECUTED 3000f748: e12fff1e bx lr <== NOT EXECUTED
3000ecf4 <pthread_attr_setdetachstate>:
int pthread_attr_setdetachstate(
pthread_attr_t *attr,
int detachstate
)
{
if ( !attr || !attr->is_initialized )
3000ecf4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ecf8: 0a000008 beq 3000ed20 <pthread_attr_setdetachstate+0x2c> <== NOT EXECUTED 3000ecfc: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ed00: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ed04: 0a000005 beq 3000ed20 <pthread_attr_setdetachstate+0x2c> <== NOT EXECUTED
return EINVAL;
switch ( detachstate ) {
3000ed08: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_CREATE_DETACHED:
case PTHREAD_CREATE_JOINABLE:
attr->detachstate = detachstate;
3000ed0c: 9580103c strls r1, [r0, #60] ; 0x3c <== NOT EXECUTED
return 0;
3000ed10: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( detachstate ) {
3000ed14: 912fff1e bxls lr <== NOT EXECUTED
case PTHREAD_CREATE_JOINABLE:
attr->detachstate = detachstate;
return 0;
default:
return EINVAL;
3000ed18: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000ed1c: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int detachstate
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000ed20: e3a00016 mov r0, #22 <== NOT EXECUTED 3000ed24: e12fff1e bx lr <== NOT EXECUTED
3000ed28 <pthread_attr_setguardsize>:
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
3000ed28: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000ed2c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
3000ed30: 012fff1e bxeq lr <== NOT EXECUTED 3000ed34: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ed38: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
attr->guardsize = guardsize;
3000ed3c: 15801034 strne r1, [r0, #52] ; 0x34 <== NOT EXECUTED
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000ed40: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->guardsize = guardsize;
return 0;
3000ed44: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000ed48: e12fff1e bx lr <== NOT EXECUTED
300107a8 <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
300107a8: e3500000 cmp r0, #0
300107ac: 0a000009 beq 300107d8 <pthread_attr_setinheritsched+0x30>
300107b0: e5903000 ldr r3, [r0] 300107b4: e3530000 cmp r3, #0
300107b8: 0a000006 beq 300107d8 <pthread_attr_setinheritsched+0x30>
return EINVAL;
switch ( inheritsched ) {
300107bc: e2413001 sub r3, r1, #1 300107c0: e3530001 cmp r3, #1
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
300107c4: 95801010 strls r1, [r0, #16]
return 0;
300107c8: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( inheritsched ) {
300107cc: 912fff1e bxls lr
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
return 0;
default:
return ENOTSUP;
300107d0: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
300107d4: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
300107d8: e3a00016 mov r0, #22 <== NOT EXECUTED 300107dc: e12fff1e bx lr <== NOT EXECUTED
3000ed84 <pthread_attr_setschedparam>:
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
3000ed84: e3500000 cmp r0, #0 <== NOT EXECUTED
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
3000ed88: e92d0030 push {r4, r5} <== NOT EXECUTED
if ( !attr || !attr->is_initialized || !param )
3000ed8c: 0a00000e beq 3000edcc <pthread_attr_setschedparam+0x48> <== NOT EXECUTED 3000ed90: e5905000 ldr r5, [r0] <== NOT EXECUTED 3000ed94: e3550000 cmp r5, #0 <== NOT EXECUTED 3000ed98: 13510000 cmpne r1, #0 <== NOT EXECUTED 3000ed9c: 13a05000 movne r5, #0 <== NOT EXECUTED 3000eda0: 03a05001 moveq r5, #1 <== NOT EXECUTED 3000eda4: 0a000008 beq 3000edcc <pthread_attr_setschedparam+0x48> <== NOT EXECUTED
return EINVAL;
attr->schedparam = *param;
3000eda8: e280c018 add ip, r0, #24 <== NOT EXECUTED
3000edac: e1a04001 mov r4, r1 <== NOT EXECUTED
3000edb0: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3000edb4: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000edb8: e8940007 ldm r4, {r0, r1, r2} <== NOT EXECUTED
3000edbc: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
return 0; }
3000edc0: e1a00005 mov r0, r5 <== NOT EXECUTED
3000edc4: e8bd0030 pop {r4, r5} <== NOT EXECUTED
3000edc8: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
3000edcc: e3a05016 mov r5, #22 <== NOT EXECUTED 3000edd0: eafffffa b 3000edc0 <pthread_attr_setschedparam+0x3c> <== NOT EXECUTED
3000edd4 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
3000edd4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000edd8: 0a00000e beq 3000ee18 <pthread_attr_setschedpolicy+0x44> <== NOT EXECUTED 3000eddc: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ede0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ede4: 0a00000b beq 3000ee18 <pthread_attr_setschedpolicy+0x44> <== NOT EXECUTED
return EINVAL;
switch ( policy ) {
3000ede8: e3510004 cmp r1, #4 <== NOT EXECUTED 3000edec: 9a000001 bls 3000edf8 <pthread_attr_setschedpolicy+0x24> <== NOT EXECUTED
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
3000edf0: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
3000edf4: e12fff1e bx lr <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
3000edf8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000edfc: e1a03113 lsl r3, r3, r1 <== NOT EXECUTED 3000ee00: e3130017 tst r3, #23 <== NOT EXECUTED
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
3000ee04: 15801014 strne r1, [r0, #20] <== NOT EXECUTED
return 0;
3000ee08: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
3000ee0c: 112fff1e bxne lr <== NOT EXECUTED
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
3000ee10: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
3000ee14: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000ee18: e3a00016 mov r0, #22 <== NOT EXECUTED 3000ee1c: e12fff1e bx lr <== NOT EXECUTED
3000ee20 <pthread_attr_setscope>:
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
3000ee20: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000ee24: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
3000ee28: 012fff1e bxeq lr <== NOT EXECUTED 3000ee2c: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ee30: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ee34: 0a000007 beq 3000ee58 <pthread_attr_setscope+0x38> <== NOT EXECUTED
return EINVAL;
switch ( contentionscope ) {
3000ee38: e3510000 cmp r1, #0 <== NOT EXECUTED
case PTHREAD_SCOPE_PROCESS:
attr->contentionscope = contentionscope;
3000ee3c: 0580100c streq r1, [r0, #12] <== NOT EXECUTED
return 0;
3000ee40: 01a00001 moveq r0, r1 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( contentionscope ) {
3000ee44: 012fff1e bxeq lr <== NOT EXECUTED
case PTHREAD_SCOPE_SYSTEM:
return ENOTSUP;
default:
return EINVAL;
3000ee48: e3510001 cmp r1, #1 <== NOT EXECUTED 3000ee4c: 03a00086 moveq r0, #134 ; 0x86 <== NOT EXECUTED 3000ee50: 13a00016 movne r0, #22 <== NOT EXECUTED 3000ee54: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int contentionscope
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000ee58: e3a00016 mov r0, #22 <== NOT EXECUTED
return ENOTSUP;
default:
return EINVAL;
}
}
3000ee5c: e12fff1e bx lr <== NOT EXECUTED
3000ee84 <pthread_attr_setstack>:
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
3000ee84: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000ee88: 03a00016 moveq r0, #22 <== NOT EXECUTED
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
3000ee8c: 012fff1e bxeq lr <== NOT EXECUTED 3000ee90: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000ee94: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ee98: 0a000008 beq 3000eec0 <pthread_attr_setstack+0x3c> <== NOT EXECUTED
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
3000ee9c: e5831004 str r1, [r3, #4] <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
3000eea0: e59f1020 ldr r1, [pc, #32] ; 3000eec8 <pthread_attr_setstack+0x44><== NOT EXECUTED
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
3000eea4: e3a00000 mov r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
3000eea8: e5911000 ldr r1, [r1] <== NOT EXECUTED 3000eeac: e1a01081 lsl r1, r1, #1 <== NOT EXECUTED
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
3000eeb0: e1510002 cmp r1, r2 <== NOT EXECUTED 3000eeb4: 25831008 strcs r1, [r3, #8] <== NOT EXECUTED 3000eeb8: 35832008 strcc r2, [r3, #8] <== NOT EXECUTED
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
3000eebc: e12fff1e bx lr <== NOT EXECUTED
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000eec0: e3a00016 mov r0, #22 <== NOT EXECUTED
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
}
3000eec4: e12fff1e bx lr <== NOT EXECUTED
3000ee60 <pthread_attr_setstackaddr>:
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
3000ee60: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000ee64: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
3000ee68: 012fff1e bxeq lr <== NOT EXECUTED 3000ee6c: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000ee70: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
attr->stackaddr = stackaddr;
3000ee74: 15801004 strne r1, [r0, #4] <== NOT EXECUTED
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000ee78: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->stackaddr = stackaddr;
return 0;
3000ee7c: 13a00000 movne r0, #0 <== NOT EXECUTED
}
3000ee80: e12fff1e bx lr <== NOT EXECUTED
300107e0 <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
300107e0: e3500000 cmp r0, #0
return EINVAL;
300107e4: 03a00016 moveq r0, #22
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
300107e8: 012fff1e bxeq lr 300107ec: e5903000 ldr r3, [r0] 300107f0: e3530000 cmp r3, #0
300107f4: 0a000008 beq 3001081c <pthread_attr_setstacksize+0x3c>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
300107f8: e59f3024 ldr r3, [pc, #36] ; 30010824 <pthread_attr_setstacksize+0x44> 300107fc: e5933000 ldr r3, [r3] 30010800: e1a03083 lsl r3, r3, #1 30010804: e1530001 cmp r3, r1
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
30010808: 85803008 strhi r3, [r0, #8]
else
attr->stacksize = stacksize;
3001080c: 95801008 strls r1, [r0, #8]
return 0;
30010810: 83a00000 movhi r0, #0 30010814: 93a00000 movls r0, #0 30010818: e12fff1e bx lr
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3001081c: e3a00016 mov r0, #22 <== NOT EXECUTED
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
return 0;
}
30010820: e12fff1e bx lr <== NOT EXECUTED
3000a1b4 <pthread_barrier_destroy>:
*/
int pthread_barrier_destroy(
pthread_barrier_t *barrier
)
{
3000a1b4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000a1b8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_barrier_destroy(
pthread_barrier_t *barrier
)
{
3000a1bc: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000a1c0: 0a000007 beq 3000a1e4 <pthread_barrier_destroy+0x30> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
pthread_barrier_t *barrier,
Objects_Locations *location
)
{
return (POSIX_Barrier_Control *) _Objects_Get(
3000a1c4: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a1c8: e59f005c ldr r0, [pc, #92] ; 3000a22c <pthread_barrier_destroy+0x78><== NOT EXECUTED 3000a1cc: e1a0200d mov r2, sp <== NOT EXECUTED 3000a1d0: eb000993 bl 3000c824 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
3000a1d4: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a1d8: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a1dc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a1e0: 0a000002 beq 3000a1f0 <pthread_barrier_destroy+0x3c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a1e4: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a1e8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a1ec: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) {
3000a1f0: e5905058 ldr r5, [r0, #88] ; 0x58 <== NOT EXECUTED 3000a1f4: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a1f8: 0a000002 beq 3000a208 <pthread_barrier_destroy+0x54> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a1fc: eb000cc1 bl 3000d508 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000a200: e3a00010 mov r0, #16 <== NOT EXECUTED 3000a204: eafffff7 b 3000a1e8 <pthread_barrier_destroy+0x34> <== NOT EXECUTED
}
_Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object );
3000a208: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a20c: e59f0018 ldr r0, [pc, #24] ; 3000a22c <pthread_barrier_destroy+0x78><== NOT EXECUTED 3000a210: eb000877 bl 3000c3f4 <_Objects_Close> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _POSIX_Barrier_Free (
POSIX_Barrier_Control *the_barrier
)
{
_Objects_Free( &_POSIX_Barrier_Information, &the_barrier->Object );
3000a214: e59f0010 ldr r0, [pc, #16] ; 3000a22c <pthread_barrier_destroy+0x78><== NOT EXECUTED 3000a218: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a21c: eb000929 bl 3000c6c8 <_Objects_Free> <== NOT EXECUTED
_POSIX_Barrier_Free( the_barrier );
_Thread_Enable_dispatch();
3000a220: eb000cb8 bl 3000d508 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a224: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a228: eaffffee b 3000a1e8 <pthread_barrier_destroy+0x34> <== NOT EXECUTED
3000a230 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
3000a230: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
3000a234: e2504000 subs r4, r0, #0 <== NOT EXECUTED
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
3000a238: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
3000a23c: 0a000020 beq 3000a2c4 <pthread_barrier_init+0x94> <== NOT EXECUTED
return EINVAL;
if ( count == 0 )
3000a240: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a244: 0a00001e beq 3000a2c4 <pthread_barrier_init+0x94> <== NOT EXECUTED
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
3000a248: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a24c: 0a000022 beq 3000a2dc <pthread_barrier_init+0xac> <== NOT EXECUTED
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
3000a250: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000a254: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a258: 0a000019 beq 3000a2c4 <pthread_barrier_init+0x94> <== NOT EXECUTED
return EINVAL;
switch ( the_attr->process_shared ) {
3000a25c: e5915004 ldr r5, [r1, #4] <== NOT EXECUTED 3000a260: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a264: 1a000016 bne 3000a2c4 <pthread_barrier_init+0x94> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000a268: e59f3088 ldr r3, [pc, #136] ; 3000a2f8 <pthread_barrier_init+0xc8><== NOT EXECUTED
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
the_attributes.maximum_count = count;
3000a26c: e58d2010 str r2, [sp, #16] <== NOT EXECUTED 3000a270: e5931000 ldr r1, [r3] <== NOT EXECUTED
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
3000a274: e58d500c str r5, [sp, #12] <== NOT EXECUTED 3000a278: e2812001 add r2, r1, #1 <== NOT EXECUTED 3000a27c: 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 );
3000a280: e59f7074 ldr r7, [pc, #116] ; 3000a2fc <pthread_barrier_init+0xcc><== NOT EXECUTED 3000a284: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a288: eb000834 bl 3000c360 <_Objects_Allocate> <== NOT EXECUTED
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
3000a28c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000a290: 0a00000e beq 3000a2d0 <pthread_barrier_init+0xa0> <== NOT EXECUTED
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
3000a294: e2860010 add r0, r6, #16 <== NOT EXECUTED 3000a298: e28d100c add r1, sp, #12 <== NOT EXECUTED 3000a29c: eb0005b6 bl 3000b97c <_CORE_barrier_Initialize> <== NOT EXECUTED
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000a2a0: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a2a4: e597201c ldr r2, [r7, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000a2a8: e1a01803 lsl r1, r3, #16 <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a2ac: e7826721 str r6, [r2, r1, lsr #14] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000a2b0: e586500c str r5, [r6, #12] <== NOT EXECUTED
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
3000a2b4: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a2b8: eb000c92 bl 3000d508 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a2bc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a2c0: ea000000 b 3000a2c8 <pthread_barrier_init+0x98> <== NOT EXECUTED
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
3000a2c4: 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; }
3000a2c8: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000a2cc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
3000a2d0: eb000c8c bl 3000d508 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000a2d4: e3a0000b mov r0, #11 <== NOT EXECUTED 3000a2d8: eafffffa b 3000a2c8 <pthread_barrier_init+0x98> <== NOT EXECUTED
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
3000a2dc: e28d5004 add r5, sp, #4 <== NOT EXECUTED 3000a2e0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a2e4: e58d2000 str r2, [sp] <== NOT EXECUTED 3000a2e8: ebffff9d bl 3000a164 <pthread_barrierattr_init> <== NOT EXECUTED
the_attr = &my_attr;
3000a2ec: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a2f0: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000a2f4: eaffffd5 b 3000a250 <pthread_barrier_init+0x20> <== NOT EXECUTED
3000a300 <pthread_barrier_wait>:
*/
int pthread_barrier_wait(
pthread_barrier_t *barrier
)
{
3000a300: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000a304: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_barrier_wait(
pthread_barrier_t *barrier
)
{
3000a308: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
3000a30c: 0a000006 beq 3000a32c <pthread_barrier_wait+0x2c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
pthread_barrier_t *barrier,
Objects_Locations *location
)
{
return (POSIX_Barrier_Control *) _Objects_Get(
3000a310: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a314: e59f0048 ldr r0, [pc, #72] ; 3000a364 <pthread_barrier_wait+0x64><== NOT EXECUTED 3000a318: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000a31c: eb000940 bl 3000c824 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
3000a320: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3000a324: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a328: 0a000002 beq 3000a338 <pthread_barrier_wait+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a32c: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a330: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000a334: e8bd8000 pop {pc} <== NOT EXECUTED
the_barrier = _POSIX_Barrier_Get( barrier, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_barrier_Wait(
3000a338: e5901008 ldr r1, [r0, #8] <== NOT EXECUTED 3000a33c: e3a02001 mov r2, #1 <== NOT EXECUTED 3000a340: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000a344: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a348: eb000596 bl 3000b9a8 <_CORE_barrier_Wait> <== NOT EXECUTED
the_barrier->Object.id,
true,
0,
NULL
);
_Thread_Enable_dispatch();
3000a34c: eb000c6d bl 3000d508 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Barrier_Translate_core_barrier_return_code(
_Thread_Executing->Wait.return_code );
3000a350: e59f3010 ldr r3, [pc, #16] ; 3000a368 <pthread_barrier_wait+0x68><== NOT EXECUTED 3000a354: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
true,
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_Barrier_Translate_core_barrier_return_code(
3000a358: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000a35c: eb00184c bl 30010494 <_POSIX_Barrier_Translate_core_barrier_return_code><== NOT EXECUTED 3000a360: eafffff2 b 3000a330 <pthread_barrier_wait+0x30> <== NOT EXECUTED
3000a118 <pthread_barrierattr_destroy>:
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000a118: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000a11c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000a120: 012fff1e bxeq lr <== NOT EXECUTED 3000a124: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000a128: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000a12c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a130: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000a134: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000a138: e12fff1e bx lr <== NOT EXECUTED
3000a13c <pthread_barrierattr_getpshared>:
int pthread_barrierattr_getpshared(
const pthread_barrierattr_t *attr,
int *pshared
)
{
if ( !attr )
3000a13c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000a140: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_barrierattr_getpshared(
const pthread_barrierattr_t *attr,
int *pshared
)
{
if ( !attr )
3000a144: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000a148: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000a14c: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000a150: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000a154: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
return 0;
3000a158: 13a00000 movne r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
*pshared = attr->process_shared;
3000a15c: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0; }
3000a160: e12fff1e bx lr <== NOT EXECUTED
3000a164 <pthread_barrierattr_init>:
int pthread_barrierattr_init(
pthread_barrierattr_t *attr
)
{
if ( !attr )
3000a164: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = true;
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
3000a168: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr )
return EINVAL;
attr->is_initialized = true;
3000a16c: 13a02001 movne r2, #1 <== NOT EXECUTED 3000a170: 15832000 strne r2, [r3] <== NOT EXECUTED
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
3000a174: 15830004 strne r0, [r3, #4] <== NOT EXECUTED
int pthread_barrierattr_init(
pthread_barrierattr_t *attr
)
{
if ( !attr )
return EINVAL;
3000a178: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = true;
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
return 0;
}
3000a17c: e12fff1e bx lr <== NOT EXECUTED
3000a180 <pthread_barrierattr_setpshared>:
int pthread_barrierattr_setpshared(
pthread_barrierattr_t *attr,
int pshared
)
{
if ( !attr )
3000a180: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a184: 0a000008 beq 3000a1ac <pthread_barrierattr_setpshared+0x2c><== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000a188: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000a18c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a190: 0a000005 beq 3000a1ac <pthread_barrierattr_setpshared+0x2c><== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000a194: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000a198: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000a19c: 93a00000 movls r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000a1a0: 912fff1e bxls lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000a1a4: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000a1a8: e12fff1e bx lr <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000a1ac: e3a00016 mov r0, #22 <== NOT EXECUTED 3000a1b0: e12fff1e bx lr <== NOT EXECUTED
300096b8 <pthread_cancel>:
*/
int pthread_cancel(
pthread_t thread
)
{
300096b8: e92d4010 push {r4, lr} <== NOT EXECUTED
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
300096bc: e59f304c ldr r3, [pc, #76] ; 30009710 <pthread_cancel+0x58><== NOT EXECUTED
*/
int pthread_cancel(
pthread_t thread
)
{
300096c0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
300096c4: e5933000 ldr r3, [r3] <== NOT EXECUTED 300096c8: e3530000 cmp r3, #0 <== NOT EXECUTED
return EPROTO;
300096cc: 13a00047 movne r0, #71 ; 0x47 <== NOT EXECUTED
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
300096d0: 0a000001 beq 300096dc <pthread_cancel+0x24> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
300096d4: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300096d8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
300096dc: e1a0100d mov r1, sp <== NOT EXECUTED 300096e0: eb000b86 bl 3000c500 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
300096e4: e59d4000 ldr r4, [sp] <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
300096e8: e1a03000 mov r3, r0 <== NOT EXECUTED
switch ( location ) {
300096ec: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
300096f0: 13a00016 movne r0, #22 <== NOT EXECUTED
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
300096f4: 1afffff6 bne 300096d4 <pthread_cancel+0x1c> <== NOT EXECUTED
case OBJECTS_LOCAL:
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
thread_support->cancelation_requested = 1;
300096f8: e59330fc ldr r3, [r3, #252] ; 0xfc <== NOT EXECUTED 300096fc: e3a02001 mov r2, #1 <== NOT EXECUTED 30009700: e58320e0 str r2, [r3, #224] ; 0xe0 <== NOT EXECUTED
/* This enables dispatch implicitly */
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( the_thread );
30009704: eb001684 bl 3000f11c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
return 0;
30009708: e1a00004 mov r0, r4 <== NOT EXECUTED 3000970c: eafffff0 b 300096d4 <pthread_cancel+0x1c> <== NOT EXECUTED
300094b0 <pthread_cleanup_pop>:
*/
void pthread_cleanup_pop(
int execute
)
{
300094b0: e92d4070 push {r4, r5, r6, lr}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
300094b4: e59f2080 ldr r2, [pc, #128] ; 3000953c <pthread_cleanup_pop+0x8c>
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 ];
300094b8: e59f3080 ldr r3, [pc, #128] ; 30009540 <pthread_cleanup_pop+0x90> 300094bc: e5921000 ldr r1, [r2] 300094c0: e5933004 ldr r3, [r3, #4] 300094c4: e2811001 add r1, r1, #1 300094c8: e59330fc ldr r3, [r3, #252] ; 0xfc 300094cc: e5821000 str r1, [r2]
*/
void pthread_cleanup_pop(
int execute
)
{
300094d0: e1a04000 mov r4, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300094d4: e10f5000 mrs r5, CPSR 300094d8: e3852080 orr r2, r5, #128 ; 0x80 300094dc: e129f002 msr CPSR_fc, r2
*/
_Thread_Disable_dispatch();
_ISR_Disable( level );
if ( _Chain_Is_empty( handler_stack ) ) {
300094e0: 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 );
300094e4: e28320e8 add r2, r3, #232 ; 0xe8 300094e8: e1510002 cmp r1, r2
300094ec: 0a00000f beq 30009530 <pthread_cleanup_pop+0x80>
_Thread_Enable_dispatch();
_ISR_Enable( level );
return;
}
handler = (POSIX_Cancel_Handler_control *)
300094f0: e59330ec ldr r3, [r3, #236] ; 0xec
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
300094f4: e8930006 ldm r3, {r1, r2}
previous = the_node->previous; next->previous = previous;
300094f8: e5812004 str r2, [r1, #4]
previous->next = next;
300094fc: e5821000 str r1, [r2]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009500: e129f005 msr CPSR_fc, r5
_ISR_Enable( level );
tmp_handler = *handler;
_Workspace_Free( handler );
30009504: e1a00003 mov r0, r3 30009508: e5935008 ldr r5, [r3, #8] 3000950c: e593600c ldr r6, [r3, #12] 30009510: eb000f79 bl 3000d2fc <_Workspace_Free>
_Thread_Enable_dispatch();
30009514: eb000afd bl 3000c110 <_Thread_Enable_dispatch>
if ( execute )
30009518: e3540000 cmp r4, #0
3000951c: 08bd8070 popeq {r4, r5, r6, pc}
(*tmp_handler.routine)( tmp_handler.arg );
30009520: e1a00006 mov r0, r6 <== NOT EXECUTED
30009524: e1a0e00f mov lr, pc <== NOT EXECUTED
30009528: e12fff15 bx r5 <== NOT EXECUTED
3000952c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
_Thread_Disable_dispatch();
_ISR_Disable( level );
if ( _Chain_Is_empty( handler_stack ) ) {
_Thread_Enable_dispatch();
30009530: eb000af6 bl 3000c110 <_Thread_Enable_dispatch> <== NOT EXECUTED
30009534: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
30009538: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000aa7c <pthread_cond_destroy>:
*/
int pthread_cond_destroy(
pthread_cond_t *cond
)
{
3000aa7c: e92d4030 push {r4, r5, lr}
3000aa80: e24dd004 sub sp, sp, #4
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000aa84: e1a0100d mov r1, sp 3000aa88: eb000016 bl 3000aae8 <_POSIX_Condition_variables_Get>
switch ( location ) {
3000aa8c: e59d3000 ldr r3, [sp]
)
{
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
3000aa90: e1a04000 mov r4, r0
switch ( location ) {
3000aa94: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000aa98: 13a00016 movne r0, #22
{
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
switch ( location ) {
3000aa9c: 1a000005 bne 3000aab8 <pthread_cond_destroy+0x3c>
case OBJECTS_LOCAL:
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
3000aaa0: e2840018 add r0, r4, #24 3000aaa4: eb001007 bl 3000eac8 <_Thread_queue_First> 3000aaa8: e2505000 subs r5, r0, #0
3000aaac: 0a000003 beq 3000aac0 <pthread_cond_destroy+0x44>
_Thread_Enable_dispatch();
3000aab0: eb000e34 bl 3000e388 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000aab4: e3a00010 mov r0, #16 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000aab8: e28dd004 add sp, sp, #4
3000aabc: e8bd8030 pop {r4, r5, pc}
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
_Thread_Enable_dispatch();
return EBUSY;
}
_Objects_Close(
3000aac0: e1a01004 mov r1, r4 3000aac4: e59f0018 ldr r0, [pc, #24] ; 3000aae4 <pthread_cond_destroy+0x68> 3000aac8: eb0009e9 bl 3000d274 <_Objects_Close>
RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free (
POSIX_Condition_variables_Control *the_condition_variable
)
{
_Objects_Free(
3000aacc: e59f0010 ldr r0, [pc, #16] ; 3000aae4 <pthread_cond_destroy+0x68> 3000aad0: e1a01004 mov r1, r4 3000aad4: eb000a9b bl 3000d548 <_Objects_Free>
&_POSIX_Condition_variables_Information,
&the_cond->Object
);
_POSIX_Condition_variables_Free( the_cond );
_Thread_Enable_dispatch();
3000aad8: eb000e2a bl 3000e388 <_Thread_Enable_dispatch>
return 0;
3000aadc: e1a00005 mov r0, r5 3000aae0: eafffff4 b 3000aab8 <pthread_cond_destroy+0x3c>
3000ab48 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
3000ab48: 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;
3000ab4c: e3510000 cmp r1, #0 3000ab50: e59f60a0 ldr r6, [pc, #160] ; 3000abf8 <pthread_cond_init+0xb0> 3000ab54: 11a06001 movne r6, r1
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000ab58: e5963004 ldr r3, [r6, #4]
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
3000ab5c: e1a05000 mov r5, r0
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000ab60: e3530001 cmp r3, #1
return EINVAL;
3000ab64: 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 )
3000ab68: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return EINVAL;
if ( !the_attr->is_initialized )
3000ab6c: e5963000 ldr r3, [r6] 3000ab70: e3530000 cmp r3, #0
3000ab74: 1a000001 bne 3000ab80 <pthread_cond_init+0x38>
return EINVAL;
3000ab78: e3a00016 mov r0, #22 <== NOT EXECUTED
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000ab7c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000ab80: e59f3074 ldr r3, [pc, #116] ; 3000abfc <pthread_cond_init+0xb4> 3000ab84: e5932000 ldr r2, [r3] 3000ab88: e2822001 add r2, r2, #1 3000ab8c: 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 );
3000ab90: e59f7068 ldr r7, [pc, #104] ; 3000ac00 <pthread_cond_init+0xb8> 3000ab94: e1a00007 mov r0, r7 3000ab98: eb000990 bl 3000d1e0 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
3000ab9c: e2504000 subs r4, r0, #0
3000aba0: 0a000011 beq 3000abec <pthread_cond_init+0xa4>
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
3000aba4: e5963004 ldr r3, [r6, #4]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
3000aba8: e3a06000 mov r6, #0
_Thread_queue_Initialize(
3000abac: e2840018 add r0, r4, #24
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
3000abb0: e5843010 str r3, [r4, #16]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
3000abb4: e1a01006 mov r1, r6 3000abb8: e59f2044 ldr r2, [pc, #68] ; 3000ac04 <pthread_cond_init+0xbc> 3000abbc: e3a03074 mov r3, #116 ; 0x74
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
3000abc0: e5846014 str r6, [r4, #20]
_Thread_queue_Initialize(
3000abc4: eb000fe4 bl 3000eb5c <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000abc8: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000abcc: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000abd0: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000abd4: e7824721 str r4, [r2, r1, lsr #14]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000abd8: e584600c str r6, [r4, #12]
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
3000abdc: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
3000abe0: eb000de8 bl 3000e388 <_Thread_Enable_dispatch>
return 0;
3000abe4: e1a00006 mov r0, r6
3000abe8: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
3000abec: eb000de5 bl 3000e388 <_Thread_Enable_dispatch>
return ENOMEM;
3000abf0: e3a0000c mov r0, #12
3000abf4: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000ac08 <pthread_cond_signal>:
int pthread_cond_signal(
pthread_cond_t *cond
)
{
return _POSIX_Condition_variables_Signal_support( cond, false );
3000ac08: e3a01000 mov r1, #0 <== NOT EXECUTED 3000ac0c: eaffffff b 3000ac10 <_POSIX_Condition_variables_Signal_support><== NOT EXECUTED
3000ac70 <pthread_cond_timedwait>:
int pthread_cond_timedwait(
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
3000ac70: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000ac74: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000ac78: e1a05000 mov r5, r0 <== NOT EXECUTED
3000ac7c: 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);
3000ac80: e1a00002 mov r0, r2 <== NOT EXECUTED 3000ac84: e1a0100d mov r1, sp <== NOT EXECUTED 3000ac88: eb00012a bl 3000b138 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000ac8c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000ac90: 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 )
3000ac94: 0a000007 beq 3000acb8 <pthread_cond_timedwait+0x48> <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000ac98: e2403001 sub r3, r0, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
already_timedout = true;
return _POSIX_Condition_variables_Wait_support(
3000ac9c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000aca0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000aca4: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000aca8: e3530001 cmp r3, #1 <== NOT EXECUTED 3000acac: 83a03000 movhi r3, #0 <== NOT EXECUTED 3000acb0: 93a03001 movls r3, #1 <== NOT EXECUTED 3000acb4: eb000004 bl 3000accc <_POSIX_Condition_variables_Wait_support><== NOT EXECUTED
cond,
mutex,
ticks,
already_timedout
);
}
3000acb8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000acbc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000acc0 <pthread_cond_wait>:
int pthread_cond_wait(
pthread_cond_t *cond,
pthread_mutex_t *mutex
)
{
return _POSIX_Condition_variables_Wait_support(
3000acc0: e3a02000 mov r2, #0 <== NOT EXECUTED 3000acc4: e1a03002 mov r3, r2 <== NOT EXECUTED 3000acc8: eaffffff b 3000accc <_POSIX_Condition_variables_Wait_support><== NOT EXECUTED
3000a9f0 <pthread_condattr_destroy>:
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000a9f0: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000a9f4: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000a9f8: 012fff1e bxeq lr <== NOT EXECUTED 3000a9fc: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000aa00: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000aa04: 13a00000 movne r0, #0 <== NOT EXECUTED 3000aa08: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000aa0c: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000aa10: e12fff1e bx lr <== NOT EXECUTED
3000aa14 <pthread_condattr_getpshared>:
int pthread_condattr_getpshared(
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
3000aa14: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000aa18: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
return EINVAL;
3000aa1c: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
return 0;
3000aa20: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr )
return EINVAL;
*pshared = attr->process_shared;
3000aa24: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0; }
3000aa28: e12fff1e bx lr <== NOT EXECUTED
3000aa2c <pthread_condattr_init>:
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
if ( !attr )
3000aa2c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000aa30: 0a000004 beq 3000aa48 <pthread_condattr_init+0x1c> <== NOT EXECUTED
return EINVAL;
*attr = _POSIX_Condition_variables_Default_attributes;
3000aa34: e59f2014 ldr r2, [pc, #20] ; 3000aa50 <pthread_condattr_init+0x24><== NOT EXECUTED
return 0;
3000aa38: e3a00000 mov r0, #0 <== NOT EXECUTED
)
{
if ( !attr )
return EINVAL;
*attr = _POSIX_Condition_variables_Default_attributes;
3000aa3c: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
3000aa40: e8830006 stm r3, {r1, r2} <== NOT EXECUTED
return 0;
3000aa44: e12fff1e bx lr <== NOT EXECUTED
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
if ( !attr )
return EINVAL;
3000aa48: e3a00016 mov r0, #22 <== NOT EXECUTED
*attr = _POSIX_Condition_variables_Default_attributes;
return 0;
}
3000aa4c: e12fff1e bx lr <== NOT EXECUTED
3000aa54 <pthread_condattr_setpshared>:
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
if ( !attr )
3000aa54: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000aa58: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
if ( !attr )
3000aa5c: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000aa60: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000aa64: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
default:
return EINVAL;
3000aa68: 83a00016 movhi r0, #22 <== NOT EXECUTED
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
3000aa6c: 93a00000 movls r0, #0 <== NOT EXECUTED
default:
return EINVAL;
}
}
3000aa70: e12fff1e bx lr <== NOT EXECUTED
30009e64 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
30009e64: 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 )
30009e68: e2527000 subs r7, r2, #0
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
30009e6c: e24dd048 sub sp, sp, #72 ; 0x48 30009e70: e1a08000 mov r8, r0 30009e74: e1a06003 mov r6, r3
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
30009e78: 03a0500e moveq r5, #14
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
30009e7c: 0a000013 beq 30009ed0 <pthread_create+0x6c>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
30009e80: e59f4260 ldr r4, [pc, #608] ; 3000a0e8 <pthread_create+0x284> 30009e84: e3510000 cmp r1, #0 30009e88: 11a04001 movne r4, r1
if ( !the_attr->is_initialized )
30009e8c: e5943000 ldr r3, [r4] 30009e90: e3530000 cmp r3, #0
30009e94: 0a00000c beq 30009ecc <pthread_create+0x68> * 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) )
30009e98: e5943004 ldr r3, [r4, #4] 30009e9c: e3530000 cmp r3, #0
30009ea0: 0a000004 beq 30009eb8 <pthread_create+0x54>
30009ea4: e59f3240 ldr r3, [pc, #576] ; 3000a0ec <pthread_create+0x288><== NOT EXECUTED 30009ea8: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 30009eac: e5933000 ldr r3, [r3] <== NOT EXECUTED 30009eb0: e1520003 cmp r2, r3 <== NOT EXECUTED 30009eb4: 3a000004 bcc 30009ecc <pthread_create+0x68> <== 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 ) {
30009eb8: e5943010 ldr r3, [r4, #16] 30009ebc: e3530001 cmp r3, #1
30009ec0: 0a000048 beq 30009fe8 <pthread_create+0x184>
30009ec4: e3530002 cmp r3, #2
30009ec8: 0a000003 beq 30009edc <pthread_create+0x78>
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
30009ecc: e3a05016 mov r5, #22 <== NOT EXECUTED
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
30009ed0: e1a00005 mov r0, r5
30009ed4: e28dd048 add sp, sp, #72 ; 0x48
30009ed8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
30009edc: e28da024 add sl, sp, #36 ; 0x24
30009ee0: e284c018 add ip, r4, #24
30009ee4: e1a0500a mov r5, sl
30009ee8: e8bc000f ldm ip!, {r0, r1, r2, r3}
30009eec: e8a5000f stmia r5!, {r0, r1, r2, r3}
30009ef0: e89c0007 ldm ip, {r0, r1, r2}
30009ef4: e8850007 stm r5, {r0, r1, r2}
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
30009ef8: e5949014 ldr r9, [r4, #20]
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
30009efc: e594300c ldr r3, [r4, #12] 30009f00: e3530000 cmp r3, #0
return ENOTSUP;
30009f04: 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 )
30009f08: 1afffff0 bne 30009ed0 <pthread_create+0x6c>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
30009f0c: e59d0024 ldr r0, [sp, #36] ; 0x24 30009f10: eb0019cc bl 30010648 <_POSIX_Priority_Is_valid> 30009f14: e3500000 cmp r0, #0
30009f18: 0affffeb beq 30009ecc <pthread_create+0x68>
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
30009f1c: e59dc024 ldr ip, [sp, #36] ; 0x24
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
30009f20: e1a00009 mov r0, r9
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
30009f24: e58dc01c str ip, [sp, #28]
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
30009f28: e59fc1c0 ldr ip, [pc, #448] ; 3000a0f0 <pthread_create+0x28c>
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
30009f2c: e1a0100a mov r1, sl 30009f30: e28d2044 add r2, sp, #68 ; 0x44 30009f34: e28d3040 add r3, sp, #64 ; 0x40 30009f38: e5dcb000 ldrb fp, [ip] 30009f3c: eb0019cc bl 30010674 <_POSIX_Thread_Translate_sched_param>
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
30009f40: e2505000 subs r5, r0, #0
30009f44: 1affffe1 bne 30009ed0 <pthread_create+0x6c>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
30009f48: e59f21a4 ldr r2, [pc, #420] ; 3000a0f4 <pthread_create+0x290> 30009f4c: e5920000 ldr r0, [r2] 30009f50: eb0005f0 bl 3000b718 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
30009f54: e59f019c ldr r0, [pc, #412] ; 3000a0f8 <pthread_create+0x294> 30009f58: eb000883 bl 3000c16c <_Objects_Allocate>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
30009f5c: e3500000 cmp r0, #0 30009f60: e58d0020 str r0, [sp, #32]
30009f64: 0a000052 beq 3000a0b4 <pthread_create+0x250>
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
30009f68: e59f317c ldr r3, [pc, #380] ; 3000a0ec <pthread_create+0x288> 30009f6c: e59dc01c ldr ip, [sp, #28] 30009f70: e5931000 ldr r1, [r3]
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
30009f74: e5943008 ldr r3, [r4, #8]
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
30009f78: e1a01081 lsl r1, r1, #1
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
30009f7c: e1510003 cmp r1, r3 30009f80: 21a03001 movcs r3, r1 30009f84: e59d1044 ldr r1, [sp, #68] ; 0x44 30009f88: e5942004 ldr r2, [r4, #4] 30009f8c: e58d100c str r1, [sp, #12] 30009f90: e59d1040 ldr r1, [sp, #64] ; 0x40 30009f94: e06cb00b rsb fp, ip, fp 30009f98: e58db004 str fp, [sp, #4] 30009f9c: e58d1010 str r1, [sp, #16] 30009fa0: e3a0b001 mov fp, #1 30009fa4: e59f014c ldr r0, [pc, #332] ; 3000a0f8 <pthread_create+0x294> 30009fa8: e59d1020 ldr r1, [sp, #32] 30009fac: e58d5000 str r5, [sp] 30009fb0: e58db008 str fp, [sp, #8] 30009fb4: e58d5014 str r5, [sp, #20] 30009fb8: e58d5018 str r5, [sp, #24] 30009fbc: eb000d02 bl 3000d3cc <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
30009fc0: e3500000 cmp r0, #0
30009fc4: 1a000014 bne 3000a01c <pthread_create+0x1b8>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
30009fc8: e59f0128 ldr r0, [pc, #296] ; 3000a0f8 <pthread_create+0x294> 30009fcc: e59d1020 ldr r1, [sp, #32] 30009fd0: eb00093f bl 3000c4d4 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
30009fd4: e59f2118 ldr r2, [pc, #280] ; 3000a0f4 <pthread_create+0x290>
return EAGAIN;
30009fd8: e3a0500b mov r5, #11
name /* posix threads don't have a name */
);
if ( !status ) {
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
30009fdc: e5920000 ldr r0, [r2] 30009fe0: eb0005e8 bl 3000b788 <_API_Mutex_Unlock>
return EAGAIN;
30009fe4: eaffffb9 b 30009ed0 <pthread_create+0x6c>
* 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 ];
30009fe8: e59f310c ldr r3, [pc, #268] ; 3000a0fc <pthread_create+0x298>
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
30009fec: e28da024 add sl, sp, #36 ; 0x24
* 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 ];
30009ff0: e5933004 ldr r3, [r3, #4]
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
30009ff4: e1a0900a mov r9, sl
* 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 ];
30009ff8: e59350fc ldr r5, [r3, #252] ; 0xfc
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
30009ffc: e285c088 add ip, r5, #136 ; 0x88
3000a000: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000a004: e8a9000f stmia r9!, {r0, r1, r2, r3}
3000a008: e89c0007 ldm ip, {r0, r1, r2}
3000a00c: e1a03009 mov r3, r9
3000a010: e8830007 stm r3, {r0, r1, r2}
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
schedpolicy = api->schedpolicy;
3000a014: e5959084 ldr r9, [r5, #132] ; 0x84
schedparam = api->schedparam;
break;
3000a018: eaffffb7 b 30009efc <pthread_create+0x98>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000a01c: e59d3020 ldr r3, [sp, #32]
api->Attributes = *the_attr;
3000a020: e1a0e004 mov lr, r4
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000a024: e59330fc ldr r3, [r3, #252] ; 0xfc 3000a028: e58d301c str r3, [sp, #28]
api->Attributes = *the_attr;
3000a02c: e59dc01c ldr ip, [sp, #28]
3000a030: e8be000f ldm lr!, {r0, r1, r2, r3}
3000a034: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000a038: e8be000f ldm lr!, {r0, r1, r2, r3}
3000a03c: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000a040: e8be000f ldm lr!, {r0, r1, r2, r3}
3000a044: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000a048: e89e000f ldm lr, {r0, r1, r2, r3}
3000a04c: e88c000f stm ip, {r0, r1, r2, r3}
api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam;
3000a050: e59d001c ldr r0, [sp, #28]
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
3000a054: e594303c ldr r3, [r4, #60] ; 0x3c
api->schedpolicy = schedpolicy; api->schedparam = schedparam;
3000a058: e280c088 add ip, r0, #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;
3000a05c: e5803040 str r3, [r0, #64] ; 0x40
api->schedpolicy = schedpolicy; api->schedparam = schedparam;
3000a060: e8ba000f ldm sl!, {r0, r1, r2, r3}
3000a064: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000a068: e89a0007 ldm sl, {r0, r1, r2}
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
3000a06c: e59d301c ldr r3, [sp, #28]
api->schedparam = schedparam;
3000a070: e88c0007 stm ip, {r0, r1, r2}
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
3000a074: e5839084 str r9, [r3, #132] ; 0x84
api->schedparam = schedparam;
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
3000a078: e59d0020 ldr r0, [sp, #32] 3000a07c: e1a0100b mov r1, fp 3000a080: e1a02007 mov r2, r7 3000a084: e1a03006 mov r3, r6 3000a088: e58d5000 str r5, [sp] 3000a08c: eb000f24 bl 3000dd24 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
3000a090: e3590004 cmp r9, #4
3000a094: 0a00000b beq 3000a0c8 <pthread_create+0x264>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
3000a098: e59dc020 ldr ip, [sp, #32]
_RTEMS_Unlock_allocator();
3000a09c: e59f2050 ldr r2, [pc, #80] ; 3000a0f4 <pthread_create+0x290>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
3000a0a0: e59c3008 ldr r3, [ip, #8]
_RTEMS_Unlock_allocator();
3000a0a4: e5920000 ldr r0, [r2]
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
3000a0a8: e5883000 str r3, [r8]
_RTEMS_Unlock_allocator();
3000a0ac: eb0005b5 bl 3000b788 <_API_Mutex_Unlock>
return 0;
3000a0b0: eaffff86 b 30009ed0 <pthread_create+0x6c>
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
3000a0b4: e59f3038 ldr r3, [pc, #56] ; 3000a0f4 <pthread_create+0x290><== NOT EXECUTED
return EAGAIN;
3000a0b8: e3a0500b mov r5, #11 <== NOT EXECUTED
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
3000a0bc: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000a0c0: eb0005b0 bl 3000b788 <_API_Mutex_Unlock> <== NOT EXECUTED
return EAGAIN;
3000a0c4: eaffff81 b 30009ed0 <pthread_create+0x6c> <== NOT EXECUTED
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
3000a0c8: e59d901c ldr r9, [sp, #28] <== NOT EXECUTED 3000a0cc: e2890090 add r0, r9, #144 ; 0x90 <== NOT EXECUTED 3000a0d0: eb000f8c bl 3000df08 <_Timespec_To_ticks> <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a0d4: e28910a8 add r1, r9, #168 ; 0xa8 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a0d8: e58900b4 str r0, [r9, #180] ; 0xb4 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a0dc: e59f001c ldr r0, [pc, #28] ; 3000a100 <pthread_create+0x29c><== NOT EXECUTED 3000a0e0: eb00105a bl 3000e250 <_Watchdog_Insert> <== NOT EXECUTED 3000a0e4: eaffffeb b 3000a098 <pthread_create+0x234> <== NOT EXECUTED
30009e5c <pthread_detach>:
#include <rtems/posix/pthread.h>
int pthread_detach(
pthread_t thread
)
{
30009e5c: e92d4010 push {r4, lr} <== NOT EXECUTED
30009e60: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
the_thread = _Thread_Get( thread, &location );
30009e64: e1a0100d mov r1, sp <== NOT EXECUTED 30009e68: eb000c12 bl 3000ceb8 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30009e6c: e59d4000 ldr r4, [sp] <== NOT EXECUTED 30009e70: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
30009e74: 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 ) {
30009e78: 1a000003 bne 30009e8c <pthread_detach+0x30> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->detachstate = PTHREAD_CREATE_DETACHED;
30009e7c: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED 30009e80: e5834040 str r4, [r3, #64] ; 0x40 <== NOT EXECUTED
_Thread_Enable_dispatch();
30009e84: eb000c02 bl 3000ce94 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009e88: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
30009e8c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30009e90: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a104 <pthread_equal>:
break;
}
return status;
#endif
}
3000a104: e1500001 cmp r0, r1 <== NOT EXECUTED 3000a108: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a10c: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000a110: e12fff1e bx lr <== NOT EXECUTED
300099c8 <pthread_getcpuclockid>:
int pthread_getcpuclockid(
pthread_t pid,
clockid_t *clock_id
)
{
300099c8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
300099cc: eb002401 bl 300129d8 <__errno> <== NOT EXECUTED 300099d0: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300099d4: e5803000 str r3, [r0] <== NOT EXECUTED
}
300099d8: e3e00000 mvn r0, #0 <== NOT EXECUTED
300099dc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c878 <pthread_getschedparam>:
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
3000c878: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000c87c: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c880: 13520000 cmpne r2, #0 <== NOT EXECUTED
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
3000c884: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000c888: e1a04002 mov r4, r2 <== NOT EXECUTED 3000c88c: e1a06001 mov r6, r1 <== NOT EXECUTED
return EINVAL;
3000c890: 03a00016 moveq r0, #22 <== NOT EXECUTED
{
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
3000c894: 1a000001 bne 3000c8a0 <pthread_getschedparam+0x28> <== NOT EXECUTED
break;
}
return ESRCH;
}
3000c898: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c89c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
register Thread_Control *the_thread;
if ( !policy || !param )
return EINVAL;
the_thread = _Thread_Get( thread, &location );
3000c8a0: e1a0100d mov r1, sp <== NOT EXECUTED 3000c8a4: eb000c30 bl 3000f96c <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000c8a8: e59d5000 ldr r5, [sp] <== NOT EXECUTED
register Thread_Control *the_thread;
if ( !policy || !param )
return EINVAL;
the_thread = _Thread_Get( thread, &location );
3000c8ac: e1a0c000 mov ip, r0 <== NOT EXECUTED
switch ( location ) {
3000c8b0: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000c8b4: 13a00003 movne r0, #3 <== NOT EXECUTED
if ( !policy || !param )
return EINVAL;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000c8b8: 1afffff6 bne 3000c898 <pthread_getschedparam+0x20> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000c8bc: e59ce0fc ldr lr, [ip, #252] ; 0xfc <== NOT EXECUTED
if ( policy )
*policy = api->schedpolicy;
3000c8c0: e59e3084 ldr r3, [lr, #132] ; 0x84 <== NOT EXECUTED
if ( param ) {
*param = api->schedparam;
3000c8c4: 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;
3000c8c8: e5863000 str r3, [r6] <== NOT EXECUTED
if ( param ) {
*param = api->schedparam;
3000c8cc: e1a06004 mov r6, r4 <== NOT EXECUTED
3000c8d0: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
3000c8d4: e8a6000f stmia r6!, {r0, r1, r2, r3} <== NOT EXECUTED
3000c8d8: e89e0007 ldm lr, {r0, r1, r2} <== NOT EXECUTED
3000c8dc: 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);
3000c8e0: e59f3018 ldr r3, [pc, #24] ; 3000c900 <pthread_getschedparam+0x88><== NOT EXECUTED 3000c8e4: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 3000c8e8: e59c3014 ldr r3, [ip, #20] <== NOT EXECUTED 3000c8ec: e0633002 rsb r3, r3, r2 <== NOT EXECUTED
param->sched_priority =
3000c8f0: e5843000 str r3, [r4] <== NOT EXECUTED
_POSIX_Priority_From_core( the_thread->current_priority );
}
_Thread_Enable_dispatch();
3000c8f4: eb000c13 bl 3000f948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000c8f8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c8fc: eaffffe5 b 3000c898 <pthread_getschedparam+0x20> <== NOT EXECUTED
30009d3c <pthread_getspecific>:
*/
void *pthread_getspecific(
pthread_key_t key
)
{
30009d3c: e92d4010 push {r4, lr} <== NOT EXECUTED
30009d40: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
30009d44: 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 );
30009d48: e1a0200d mov r2, sp <== NOT EXECUTED 30009d4c: e59f0044 ldr r0, [pc, #68] ; 30009d98 <pthread_getspecific+0x5c><== NOT EXECUTED 30009d50: eb000974 bl 3000c328 <_Objects_Get> <== NOT EXECUTED
uint32_t index;
Objects_Locations location;
void *key_data;
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
30009d54: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30009d58: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return NULL;
30009d5c: 13a04000 movne r4, #0 <== NOT EXECUTED
uint32_t index;
Objects_Locations location;
void *key_data;
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
30009d60: 1a000009 bne 30009d8c <pthread_getspecific+0x50> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = _Objects_Get_API( _Thread_Executing->Object.id );
30009d64: e59f3030 ldr r3, [pc, #48] ; 30009d9c <pthread_getspecific+0x60><== NOT EXECUTED 30009d68: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30009d6c: 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);
30009d70: e1a02c23 lsr r2, r3, #24 <== NOT EXECUTED 30009d74: e2022007 and r2, r2, #7 <== NOT EXECUTED
index = _Objects_Get_index( _Thread_Executing->Object.id );
key_data = (void *) the_key->Values[ api ][ index ];
30009d78: e2822005 add r2, r2, #5 <== NOT EXECUTED 30009d7c: 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 );
30009d80: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED
key_data = (void *) the_key->Values[ api ][ index ];
30009d84: e7924723 ldr r4, [r2, r3, lsr #14] <== NOT EXECUTED
_Thread_Enable_dispatch();
30009d88: eb000c9f bl 3000d00c <_Thread_Enable_dispatch> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return NULL;
}
30009d8c: e1a00004 mov r0, r4 <== NOT EXECUTED
30009d90: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30009d94: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000f384 <pthread_join>:
int pthread_join(
pthread_t thread,
void **value_ptr
)
{
3000f384: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000f388: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
3000f38c: e1a05001 mov r5, r1 <== NOT EXECUTED
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
void *return_pointer;
the_thread = _Thread_Get( thread, &location );
3000f390: e28d1004 add r1, sp, #4 <== NOT EXECUTED 3000f394: eb000c32 bl 30012464 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000f398: e59d4004 ldr r4, [sp, #4] <== NOT EXECUTED 3000f39c: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000f3a0: 13a00003 movne r0, #3 <== NOT EXECUTED
POSIX_API_Control *api;
Objects_Locations location;
void *return_pointer;
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000f3a4: 1a000014 bne 3000f3fc <pthread_join+0x78> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000f3a8: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
3000f3ac: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED 3000f3b0: e3520000 cmp r2, #0 <== NOT EXECUTED 3000f3b4: 0a000012 beq 3000f404 <pthread_join+0x80> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000f3b8: e59f205c ldr r2, [pc, #92] ; 3000f41c <pthread_join+0x98> <== NOT EXECUTED 3000f3bc: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
return EINVAL;
}
if ( _Thread_Is_executing( the_thread ) ) {
3000f3c0: e1500002 cmp r0, r2 <== NOT EXECUTED 3000f3c4: 0a000011 beq 3000f410 <pthread_join+0x8c> <== NOT EXECUTED
/*
* Put ourself on the threads join list
*/
_Thread_Executing->Wait.return_argument = &return_pointer;
3000f3c8: 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;
3000f3cc: e3a02001 mov r2, #1 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &api->Join_List );
_Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT );
3000f3d0: e2830044 add r0, r3, #68 ; 0x44 <== NOT EXECUTED 3000f3d4: e5832074 str r2, [r3, #116] ; 0x74 <== NOT EXECUTED 3000f3d8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000f3dc: e59f203c ldr r2, [pc, #60] ; 3000f420 <pthread_join+0x9c> <== NOT EXECUTED 3000f3e0: eb000d42 bl 300128f0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000f3e4: eb000c15 bl 30012440 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( value_ptr )
3000f3e8: e3550000 cmp r5, #0 <== NOT EXECUTED
*value_ptr = return_pointer;
3000f3ec: 159d3000 ldrne r3, [sp] <== NOT EXECUTED
return 0;
3000f3f0: 11a00004 movne r0, r4 <== NOT EXECUTED
_Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT );
_Thread_Enable_dispatch();
if ( value_ptr )
*value_ptr = return_pointer;
3000f3f4: 15853000 strne r3, [r5] <== NOT EXECUTED
return 0;
3000f3f8: 01a00005 moveq r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
3000f3fc: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000f400: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
_Thread_Enable_dispatch();
3000f404: eb000c0d bl 30012440 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EINVAL;
3000f408: e3a00016 mov r0, #22 <== NOT EXECUTED 3000f40c: eafffffa b 3000f3fc <pthread_join+0x78> <== NOT EXECUTED
}
if ( _Thread_Is_executing( the_thread ) ) {
_Thread_Enable_dispatch();
3000f410: eb000c0a bl 30012440 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EDEADLK;
3000f414: e3a0002d mov r0, #45 ; 0x2d <== NOT EXECUTED 3000f418: eafffff7 b 3000f3fc <pthread_join+0x78> <== NOT EXECUTED
30009bd4 <pthread_key_create>:
30009bd4: e59f30d0 ldr r3, [pc, #208] ; 30009cac <pthread_key_create+0xd8>
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
30009bd8: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
30009bdc: e5932000 ldr r2, [r3]
30009be0: e1a0a000 mov sl, r0
30009be4: e2822001 add r2, r2, #1
30009be8: e5832000 str r2, [r3]
30009bec: e1a04001 mov r4, 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 );
30009bf0: e59f00b8 ldr r0, [pc, #184] ; 30009cb0 <pthread_key_create+0xdc> 30009bf4: eb00089a bl 3000be64 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
30009bf8: e2508000 subs r8, r0, #0
30009bfc: 0a00001f beq 30009c80 <pthread_key_create+0xac>
_Thread_Enable_dispatch();
return EAGAIN;
}
the_key->destructor = destructor;
30009c00: e59f70ac ldr r7, [pc, #172] ; 30009cb4 <pthread_key_create+0xe0> 30009c04: e5884010 str r4, [r8, #16] 30009c08: e3a05003 mov r5, #3 30009c0c: e1a04008 mov r4, r8
* 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;
30009c10: e3a06000 mov r6, #0
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
30009c14: e5b73004 ldr r3, [r7, #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;
30009c18: e5846018 str r6, [r4, #24]
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
30009c1c: e5933004 ldr r3, [r3, #4] 30009c20: e1d391b0 ldrh r9, [r3, #16] 30009c24: e2899001 add r9, r9, #1
true,
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
30009c28: e1a09109 lsl r9, r9, #2
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
30009c2c: e1a00009 mov r0, r9 30009c30: eb0011bf bl 3000e334 <_Workspace_Allocate>
if ( !table ) {
30009c34: e2503000 subs r3, r0, #0
_Thread_Enable_dispatch();
return ENOMEM;
}
the_key->Values[ the_api ] = table;
memset( table, '\0', bytes_to_allocate );
30009c38: e1a01006 mov r1, r6 30009c3c: e1a02009 mov r2, r9
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
if ( !table ) {
30009c40: 0a000011 beq 30009c8c <pthread_key_create+0xb8>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
return ENOMEM;
}
the_key->Values[ the_api ] = table;
30009c44: e5843018 str r3, [r4, #24]
memset( table, '\0', bytes_to_allocate );
30009c48: eb002702 bl 30013858 <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++ ) {
30009c4c: e2555001 subs r5, r5, #1
_Thread_Enable_dispatch();
return ENOMEM;
}
the_key->Values[ the_api ] = table;
memset( table, '\0', bytes_to_allocate );
30009c50: e2844004 add r4, r4, #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++ ) {
30009c54: 1affffee bne 30009c14 <pthread_key_create+0x40>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009c58: e59f2050 ldr r2, [pc, #80] ; 30009cb0 <pthread_key_create+0xdc>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30009c5c: e5983008 ldr r3, [r8, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009c60: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
30009c64: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009c68: e7828721 str r8, [r2, r1, lsr #14]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
30009c6c: e588500c str r5, [r8, #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;
30009c70: e58a3000 str r3, [sl]
_Thread_Enable_dispatch();
30009c74: eb000ce4 bl 3000d00c <_Thread_Enable_dispatch>
return 0;
30009c78: e1a00005 mov r0, r5
}
30009c7c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
_Thread_Enable_dispatch();
30009c80: eb000ce1 bl 3000d00c <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
30009c84: e3a0000b mov r0, #11 <== NOT EXECUTED
30009c88: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
if ( !table ) {
_POSIX_Keys_Free_memory( the_key );
30009c8c: e1a00008 mov r0, r8 30009c90: eb000020 bl 30009d18 <_POSIX_Keys_Free_memory>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
30009c94: e59f0014 ldr r0, [pc, #20] ; 30009cb0 <pthread_key_create+0xdc> 30009c98: e1a01008 mov r1, r8 30009c9c: eb00094a bl 3000c1cc <_Objects_Free>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
30009ca0: eb000cd9 bl 3000d00c <_Thread_Enable_dispatch>
return ENOMEM;
30009ca4: e3a0000c mov r0, #12
30009ca8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
300270e4 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
300270e4: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
300270e8: e2516000 subs r6, r1, #0 <== NOT EXECUTED
int pthread_kill(
pthread_t thread,
int sig
)
{
300270ec: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
300270f0: 0a000025 beq 3002718c <pthread_kill+0xa8> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
300270f4: e2467001 sub r7, r6, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
300270f8: e357001f cmp r7, #31 <== NOT EXECUTED 300270fc: 8a000022 bhi 3002718c <pthread_kill+0xa8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
30027100: e28d1004 add r1, sp, #4 <== NOT EXECUTED 30027104: ebffa98a bl 30011734 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30027108: e59d2004 ldr r2, [sp, #4] <== 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 );
3002710c: e1a04000 mov r4, r0 <== NOT EXECUTED
switch ( location ) {
30027110: e3520000 cmp r2, #0 <== NOT EXECUTED 30027114: 1a000021 bne 300271a0 <pthread_kill+0xbc> <== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
30027118: e59f3094 ldr r3, [pc, #148] ; 300271b4 <pthread_kill+0xd0> <== NOT EXECUTED 3002711c: e0861086 add r1, r6, r6, lsl #1 <== NOT EXECUTED 30027120: e0833101 add r3, r3, r1, lsl #2 <== NOT EXECUTED 30027124: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
30027128: e59030fc ldr r3, [r0, #252] ; 0xfc <== NOT EXECUTED
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
3002712c: e3510001 cmp r1, #1 <== NOT EXECUTED 30027130: 0a000010 beq 30027178 <pthread_kill+0x94> <== NOT EXECUTED
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
30027134: e59310d4 ldr r1, [r3, #212] ; 0xd4 <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
30027138: e3a05001 mov r5, #1 <== NOT EXECUTED 3002713c: e1817715 orr r7, r1, r5, lsl r7 <== NOT EXECUTED
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
30027140: e1a01006 mov r1, r6 <== NOT EXECUTED
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
30027144: e58370d4 str r7, [r3, #212] ; 0xd4 <== NOT EXECUTED
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
30027148: ebffff9a bl 30026fb8 <_POSIX_signals_Unblock_thread> <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
3002714c: e59f3064 ldr r3, [pc, #100] ; 300271b8 <pthread_kill+0xd4> <== NOT EXECUTED 30027150: e5932000 ldr r2, [r3] <== NOT EXECUTED 30027154: e3520000 cmp r2, #0 <== NOT EXECUTED 30027158: 0a000002 beq 30027168 <pthread_kill+0x84> <== NOT EXECUTED 3002715c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 30027160: e1540002 cmp r4, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
30027164: 05c35010 strbeq r5, [r3, #16] <== NOT EXECUTED
}
_Thread_Enable_dispatch();
30027168: ebffa968 bl 30011710 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3002716c: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
30027170: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30027174: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
_Thread_Enable_dispatch();
30027178: e58d2000 str r2, [sp] <== NOT EXECUTED 3002717c: ebffa963 bl 30011710 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30027180: e59d2000 ldr r2, [sp] <== NOT EXECUTED 30027184: e1a00002 mov r0, r2 <== NOT EXECUTED 30027188: eafffff8 b 30027170 <pthread_kill+0x8c> <== NOT EXECUTED
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
3002718c: ebffc17f bl 30017790 <__errno> <== NOT EXECUTED 30027190: e3a03016 mov r3, #22 <== NOT EXECUTED 30027194: e5803000 str r3, [r0] <== NOT EXECUTED 30027198: e3e00000 mvn r0, #0 <== NOT EXECUTED 3002719c: eafffff3 b 30027170 <pthread_kill+0x8c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
300271a0: ebffc17a bl 30017790 <__errno> <== NOT EXECUTED 300271a4: e3a03003 mov r3, #3 <== NOT EXECUTED 300271a8: e5803000 str r3, [r0] <== NOT EXECUTED 300271ac: e3e00000 mvn r0, #0 <== NOT EXECUTED 300271b0: eaffffee b 30027170 <pthread_kill+0x8c> <== NOT EXECUTED
3000bfe4 <pthread_mutex_destroy>:
*/
int pthread_mutex_destroy(
pthread_mutex_t *mutex
)
{
3000bfe4: e92d4030 push {r4, r5, lr}
3000bfe8: e24dd004 sub sp, sp, #4
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000bfec: e1a0100d mov r1, sp 3000bff0: eb000019 bl 3000c05c <_POSIX_Mutex_Get>
switch ( location ) {
3000bff4: e59d4000 ldr r4, [sp]
)
{
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
3000bff8: e1a05000 mov r5, r0
switch ( location ) {
3000bffc: e3540000 cmp r4, #0
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000c000: 13a00016 movne r0, #22
{
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
switch ( location ) {
3000c004: 1a000004 bne 3000c01c <pthread_mutex_destroy+0x38>
/*
* 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 ) ) {
3000c008: e5953064 ldr r3, [r5, #100] ; 0x64 3000c00c: e3530000 cmp r3, #0
3000c010: 1a000003 bne 3000c024 <pthread_mutex_destroy+0x40>
_Thread_Enable_dispatch();
3000c014: eb000e4b bl 3000f948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000c018: e3a00010 mov r0, #16 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000c01c: e28dd004 add sp, sp, #4
3000c020: e8bd8030 pop {r4, r5, pc}
if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) {
_Thread_Enable_dispatch();
return EBUSY;
}
_Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object );
3000c024: e1a01005 mov r1, r5 3000c028: e59f0028 ldr r0, [pc, #40] ; 3000c058 <pthread_mutex_destroy+0x74> 3000c02c: eb000a00 bl 3000e834 <_Objects_Close>
_CORE_mutex_Flush( &the_mutex->Mutex, NULL, EINVAL );
3000c030: e3a02016 mov r2, #22 3000c034: e2850014 add r0, r5, #20 3000c038: e1a01004 mov r1, r4 3000c03c: eb00076b bl 3000ddf0 <_CORE_mutex_Flush>
RTEMS_INLINE_ROUTINE void _POSIX_Mutex_Free (
POSIX_Mutex_Control *the_mutex
)
{
_Objects_Free( &_POSIX_Mutex_Information, &the_mutex->Object );
3000c040: e59f0010 ldr r0, [pc, #16] ; 3000c058 <pthread_mutex_destroy+0x74> 3000c044: e1a01005 mov r1, r5 3000c048: eb000aae bl 3000eb08 <_Objects_Free>
_POSIX_Mutex_Free( the_mutex );
_Thread_Enable_dispatch();
3000c04c: eb000e3d bl 3000f948 <_Thread_Enable_dispatch>
return 0;
3000c050: e1a00004 mov r0, r4 3000c054: eafffff0 b 3000c01c <pthread_mutex_destroy+0x38>
3000c178 <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;
3000c178: e59f3134 ldr r3, [pc, #308] ; 3000c2b4 <pthread_mutex_init+0x13c> 3000c17c: e3510000 cmp r1, #0
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
3000c180: 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;
3000c184: 11a06001 movne r6, r1 3000c188: 01a06003 moveq r6, r3
/* Check for NULL mutex */
if ( !mutex )
3000c18c: e2504000 subs r4, r0, #0
3000c190: 0a00003c beq 3000c288 <pthread_mutex_init+0x110>
}
}
}
#endif
if ( !the_attr->is_initialized )
3000c194: e5963000 ldr r3, [r6] 3000c198: e3530000 cmp r3, #0
3000c19c: 0a000039 beq 3000c288 <pthread_mutex_init+0x110>
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000c1a0: e5963004 ldr r3, [r6, #4] 3000c1a4: e3530001 cmp r3, #1
return ENOSYS;
3000c1a8: 03a00058 moveq r0, #88 ; 0x58
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
3000c1ac: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return ENOSYS;
if ( the_attr->process_shared != PTHREAD_PROCESS_PRIVATE )
3000c1b0: e3530000 cmp r3, #0
3000c1b4: 1a000033 bne 3000c288 <pthread_mutex_init+0x110>
return EINVAL;
/*
* Determine the discipline of the mutex
*/
switch ( the_attr->protocol ) {
3000c1b8: e596700c ldr r7, [r6, #12] 3000c1bc: e3570001 cmp r7, #1
3000c1c0: 0a000036 beq 3000c2a0 <pthread_mutex_init+0x128>
3000c1c4: e3570002 cmp r7, #2
3000c1c8: 0a000030 beq 3000c290 <pthread_mutex_init+0x118>
3000c1cc: e3570000 cmp r7, #0
3000c1d0: 1a00002c bne 3000c288 <pthread_mutex_init+0x110>
}
/*
* Validate the priority ceiling field -- should always be valid.
*/
if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )
3000c1d4: e5960008 ldr r0, [r6, #8] 3000c1d8: eb0000d3 bl 3000c52c <_POSIX_Priority_Is_valid> 3000c1dc: e3500000 cmp r0, #0
3000c1e0: 0a000028 beq 3000c288 <pthread_mutex_init+0x110>
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
/*
* Validate the mutex type and set appropriate SuperCore mutex
* attributes.
*/
switch ( the_attr->type ) {
3000c1e4: e5963010 ldr r3, [r6, #16] 3000c1e8: e3530003 cmp r3, #3
3000c1ec: 8a000029 bhi 3000c298 <pthread_mutex_init+0x120>
3000c1f0: e59f30c0 ldr r3, [pc, #192] ; 3000c2b8 <pthread_mutex_init+0x140> 3000c1f4: e5932000 ldr r2, [r3] 3000c1f8: e2822001 add r2, r2, #1 3000c1fc: 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 );
3000c200: e59f00b4 ldr r0, [pc, #180] ; 3000c2bc <pthread_mutex_init+0x144> 3000c204: eb000965 bl 3000e7a0 <_Objects_Allocate>
*/
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
3000c208: e2505000 subs r5, r0, #0
3000c20c: 0a000025 beq 3000c2a8 <pthread_mutex_init+0x130>
the_mutex->process_shared = the_attr->process_shared;
the_mutex_attr = &the_mutex->Mutex.Attributes;
if ( the_attr->recursive )
3000c210: e5962014 ldr r2, [r6, #20]
if ( !the_mutex ) {
_Thread_Enable_dispatch();
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
3000c214: e5963004 ldr r3, [r6, #4]
the_mutex_attr = &the_mutex->Mutex.Attributes;
if ( the_attr->recursive )
3000c218: e3520000 cmp r2, #0
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000c21c: e59f009c ldr r0, [pc, #156] ; 3000c2c0 <pthread_mutex_init+0x148>
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;
3000c220: e3a02001 mov r2, #1
if ( !the_mutex ) {
_Thread_Enable_dispatch();
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
3000c224: e5853010 str r3, [r5, #16]
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;
3000c228: e5c52058 strb r2, [r5, #88] ; 0x58
the_mutex->process_shared = the_attr->process_shared;
the_mutex_attr = &the_mutex->Mutex.Attributes;
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
3000c22c: 13a03000 movne r3, #0
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
3000c230: 03a03001 moveq r3, #1
the_mutex->process_shared = the_attr->process_shared;
the_mutex_attr = &the_mutex->Mutex.Attributes;
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
3000c234: 15853054 strne r3, [r5, #84] ; 0x54
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
3000c238: 05853054 streq r3, [r5, #84] ; 0x54 3000c23c: e5d00000 ldrb r0, [r0] 3000c240: e5963008 ldr r3, [r6, #8]
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
the_mutex_attr = &the_mutex->Mutex.Attributes;
3000c244: e2851054 add r1, r5, #84 ; 0x54 3000c248: 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 =
3000c24c: e5853060 str r3, [r5, #96] ; 0x60
_POSIX_Priority_To_core( the_attr->prio_ceiling );
the_mutex_attr->discipline = the_discipline;
3000c250: e585705c str r7, [r5, #92] ; 0x5c
/*
* Must be initialized to unlocked.
*/
_CORE_mutex_Initialize(
3000c254: e2850014 add r0, r5, #20 3000c258: eb0006e5 bl 3000ddf4 <_CORE_mutex_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000c25c: e59f2058 ldr r2, [pc, #88] ; 3000c2bc <pthread_mutex_init+0x144>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000c260: e5953008 ldr r3, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000c264: e592201c ldr r2, [r2, #28]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000c268: e3a06000 mov r6, #0
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000c26c: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000c270: e7825721 str r5, [r2, r1, lsr #14]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000c274: e585600c str r6, [r5, #12]
CORE_MUTEX_UNLOCKED
);
_Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 );
*mutex = the_mutex->Object.id;
3000c278: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
3000c27c: eb000db1 bl 3000f948 <_Thread_Enable_dispatch>
return 0;
3000c280: e1a00006 mov r0, r6
3000c284: 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;
3000c288: e3a00016 mov r0, #22 <== NOT EXECUTED
3000c28c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
break;
case PTHREAD_PRIO_INHERIT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
break;
case PTHREAD_PRIO_PROTECT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
3000c290: e3a07003 mov r7, #3 <== NOT EXECUTED
break;
3000c294: eaffffce b 3000c1d4 <pthread_mutex_init+0x5c> <== NOT EXECUTED
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
break;
default:
return EINVAL;
3000c298: e3a00016 mov r0, #22 <== NOT EXECUTED
*mutex = the_mutex->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000c29c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== 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;
3000c2a0: e3a07002 mov r7, #2 <== NOT EXECUTED 3000c2a4: eaffffca b 3000c1d4 <pthread_mutex_init+0x5c> <== NOT EXECUTED
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
_Thread_Enable_dispatch();
3000c2a8: eb000da6 bl 3000f948 <_Thread_Enable_dispatch>
return EAGAIN;
3000c2ac: e3a0000b mov r0, #11
3000c2b0: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000c338 <pthread_mutex_setprioceiling>:
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
3000c338: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
Priority_Control the_priority;
if ( !old_ceiling )
3000c33c: e2526000 subs r6, r2, #0 <== NOT EXECUTED
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
3000c340: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000c344: e1a04000 mov r4, r0 <== NOT EXECUTED 3000c348: e1a05001 mov r5, r1 <== NOT EXECUTED
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
Priority_Control the_priority;
if ( !old_ceiling )
3000c34c: 0a000003 beq 3000c360 <pthread_mutex_setprioceiling+0x28> <== NOT EXECUTED
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000c350: e1a00001 mov r0, r1 <== NOT EXECUTED 3000c354: eb000074 bl 3000c52c <_POSIX_Priority_Is_valid> <== NOT EXECUTED 3000c358: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c35c: 1a000002 bne 3000c36c <pthread_mutex_setprioceiling+0x34> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000c360: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000c364: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c368: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c36c: e59f7058 ldr r7, [pc, #88] ; 3000c3cc <pthread_mutex_setprioceiling+0x94><== 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 );
3000c370: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c374: e5d78000 ldrb r8, [r7] <== NOT EXECUTED 3000c378: ebffffd1 bl 3000c2c4 <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 );
3000c37c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c380: e1a0100d mov r1, sp <== NOT EXECUTED 3000c384: ebffff34 bl 3000c05c <_POSIX_Mutex_Get> <== NOT EXECUTED
switch ( location ) {
3000c388: 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 );
3000c38c: e1a03000 mov r3, r0 <== NOT EXECUTED
switch ( location ) {
3000c390: e3540000 cmp r4, #0 <== NOT EXECUTED 3000c394: 1afffff1 bne 3000c360 <pthread_mutex_setprioceiling+0x28> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000c398: e5902060 ldr r2, [r0, #96] ; 0x60 <== NOT EXECUTED 3000c39c: e5d71000 ldrb r1, [r7] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000c3a0: e0655008 rsb r5, r5, r8 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
3000c3a4: e0622001 rsb r2, r2, r1 <== NOT EXECUTED
case OBJECTS_LOCAL:
*old_ceiling = _POSIX_Priority_From_core(
3000c3a8: e5862000 str r2, [r6] <== NOT EXECUTED
);
the_mutex->Mutex.Attributes.priority_ceiling = the_priority;
/*
* We are required to unlock the mutex before we return.
*/
_CORE_mutex_Surrender(
3000c3ac: 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;
3000c3b0: e5835060 str r5, [r3, #96] ; 0x60 <== NOT EXECUTED
/*
* We are required to unlock the mutex before we return.
*/
_CORE_mutex_Surrender(
3000c3b4: e1a02004 mov r2, r4 <== NOT EXECUTED 3000c3b8: e2800014 add r0, r0, #20 <== NOT EXECUTED 3000c3bc: eb000708 bl 3000dfe4 <_CORE_mutex_Surrender> <== NOT EXECUTED
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
3000c3c0: eb000d60 bl 3000f948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000c3c4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c3c8: eaffffe5 b 3000c364 <pthread_mutex_setprioceiling+0x2c> <== NOT EXECUTED
3000c3d0 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
3000c3d0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000c3d4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000c3d8: e1a05000 mov r5, 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 );
3000c3dc: e1a00001 mov r0, r1 <== NOT EXECUTED 3000c3e0: e1a0100d mov r1, sp <== NOT EXECUTED 3000c3e4: eb000030 bl 3000c4ac <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
3000c3e8: e3500003 cmp r0, #3 <== 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 );
3000c3ec: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
3000c3f0: 0a00000f beq 3000c434 <pthread_mutex_timedlock+0x64> <== NOT EXECUTED
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
3000c3f4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c3f8: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c3fc: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000c400: ebffffb2 bl 3000c2d0 <_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) ) {
3000c404: e3500010 cmp r0, #16 <== NOT EXECUTED 3000c408: 0a000001 beq 3000c414 <pthread_mutex_timedlock+0x44> <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
3000c40c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c410: e8bd8030 pop {r4, r5, pc} <== 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 )
3000c414: e3540000 cmp r4, #0 <== NOT EXECUTED
return EINVAL;
3000c418: 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 )
3000c41c: 0afffffa beq 3000c40c <pthread_mutex_timedlock+0x3c> <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000c420: e2444001 sub r4, r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
3000c424: e3540001 cmp r4, #1 <== NOT EXECUTED 3000c428: 83a00010 movhi r0, #16 <== NOT EXECUTED 3000c42c: 93a00074 movls r0, #116 ; 0x74 <== NOT EXECUTED 3000c430: eafffff5 b 3000c40c <pthread_mutex_timedlock+0x3c> <== NOT EXECUTED
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
3000c434: e1a00005 mov r0, r5 <== NOT EXECUTED 3000c438: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c43c: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000c440: ebffffa2 bl 3000c2d0 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED 3000c444: eafffff0 b 3000c40c <pthread_mutex_timedlock+0x3c> <== NOT EXECUTED
3000c458 <pthread_mutex_trylock>:
int pthread_mutex_trylock(
pthread_mutex_t *mutex
)
{
return _POSIX_Mutex_Lock_support( mutex, false, THREAD_QUEUE_WAIT_FOREVER );
3000c458: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c45c: e1a02001 mov r2, r1 <== NOT EXECUTED 3000c460: eaffff9a b 3000c2d0 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED
3000be4c <pthread_mutexattr_destroy>:
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000be4c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000be50: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
3000be54: 012fff1e bxeq lr <== NOT EXECUTED 3000be58: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000be5c: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000be60: 13a00000 movne r0, #0 <== NOT EXECUTED 3000be64: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000be68: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000be6c: e12fff1e bx lr <== NOT EXECUTED
3000be70 <pthread_mutexattr_getprioceiling>:
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000be70: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000be74: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000be78: 012fff1e bxeq lr <== NOT EXECUTED 3000be7c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000be80: e3500000 cmp r0, #0 <== NOT EXECUTED 3000be84: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*prioceiling = attr->prio_ceiling;
3000be88: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
int pthread_mutexattr_getprioceiling(
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
3000be8c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000be90: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*prioceiling = attr->prio_ceiling;
3000be94: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *prioceiling
)
{
if ( !attr || !attr->is_initialized || !prioceiling )
return EINVAL;
3000be98: 03a00016 moveq r0, #22 <== NOT EXECUTED
*prioceiling = attr->prio_ceiling;
return 0;
}
3000be9c: e12fff1e bx lr <== NOT EXECUTED
3000bea0 <pthread_mutexattr_getprotocol>:
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000bea0: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000bea4: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000bea8: 012fff1e bxeq lr <== NOT EXECUTED 3000beac: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000beb0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000beb4: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*protocol = attr->protocol;
3000beb8: 1593300c ldrne r3, [r3, #12] <== NOT EXECUTED
int pthread_mutexattr_getprotocol(
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
3000bebc: 13a00000 movne r0, #0 <== NOT EXECUTED 3000bec0: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*protocol = attr->protocol;
3000bec4: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *protocol
)
{
if ( !attr || !attr->is_initialized || !protocol )
return EINVAL;
3000bec8: 03a00016 moveq r0, #22 <== NOT EXECUTED
*protocol = attr->protocol;
return 0;
}
3000becc: e12fff1e bx lr <== NOT EXECUTED
3000bed0 <pthread_mutexattr_getpshared>:
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000bed0: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000bed4: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000bed8: 012fff1e bxeq lr <== NOT EXECUTED 3000bedc: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000bee0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bee4: 13510000 cmpne r1, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000bee8: 15933004 ldrne r3, [r3, #4] <== NOT EXECUTED
int pthread_mutexattr_getpshared(
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
3000beec: 13a00000 movne r0, #0 <== NOT EXECUTED 3000bef0: 03a00001 moveq r0, #1 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000bef4: 15813000 strne r3, [r1] <== NOT EXECUTED
const pthread_mutexattr_t *attr,
int *pshared
)
{
if ( !attr || !attr->is_initialized || !pshared )
return EINVAL;
3000bef8: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
return 0;
}
3000befc: e12fff1e bx lr <== NOT EXECUTED
3000bf38 <pthread_mutexattr_setprioceiling>:
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
3000bf38: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !attr || !attr->is_initialized )
3000bf3c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
3000bf40: e1a05001 mov r5, r1 <== NOT EXECUTED
if ( !attr || !attr->is_initialized )
3000bf44: 0a000002 beq 3000bf54 <pthread_mutexattr_setprioceiling+0x1c><== NOT EXECUTED 3000bf48: e5943000 ldr r3, [r4] <== NOT EXECUTED 3000bf4c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf50: 1a000001 bne 3000bf5c <pthread_mutexattr_setprioceiling+0x24><== NOT EXECUTED
return EINVAL;
3000bf54: e3a00016 mov r0, #22 <== NOT EXECUTED
3000bf58: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000bf5c: e1a00001 mov r0, r1 <== NOT EXECUTED 3000bf60: eb000171 bl 3000c52c <_POSIX_Priority_Is_valid> <== NOT EXECUTED 3000bf64: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
attr->prio_ceiling = prioceiling;
3000bf68: 15845008 strne r5, [r4, #8] <== NOT EXECUTED
return 0;
3000bf6c: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
3000bf70: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
return EINVAL;
3000bf74: e3a00016 mov r0, #22 <== NOT EXECUTED
attr->prio_ceiling = prioceiling;
return 0;
}
3000bf78: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000bf7c <pthread_mutexattr_setprotocol>:
int pthread_mutexattr_setprotocol(
pthread_mutexattr_t *attr,
int protocol
)
{
if ( !attr || !attr->is_initialized )
3000bf7c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bf80: 0a000008 beq 3000bfa8 <pthread_mutexattr_setprotocol+0x2c> <== NOT EXECUTED 3000bf84: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000bf88: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf8c: 0a000005 beq 3000bfa8 <pthread_mutexattr_setprotocol+0x2c> <== NOT EXECUTED
return EINVAL;
switch ( protocol ) {
3000bf90: e3510002 cmp r1, #2 <== NOT EXECUTED
case PTHREAD_PRIO_NONE:
case PTHREAD_PRIO_INHERIT:
case PTHREAD_PRIO_PROTECT:
attr->protocol = protocol;
3000bf94: 9580100c strls r1, [r0, #12] <== NOT EXECUTED
return 0;
3000bf98: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( protocol ) {
3000bf9c: 912fff1e bxls lr <== NOT EXECUTED
case PTHREAD_PRIO_PROTECT:
attr->protocol = protocol;
return 0;
default:
return EINVAL;
3000bfa0: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000bfa4: e12fff1e bx lr <== NOT EXECUTED
pthread_mutexattr_t *attr,
int protocol
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000bfa8: e3a00016 mov r0, #22 <== NOT EXECUTED 3000bfac: e12fff1e bx lr <== NOT EXECUTED
3000bfb0 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
3000bfb0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bfb4: 0a000008 beq 3000bfdc <pthread_mutexattr_setpshared+0x2c> <== NOT EXECUTED 3000bfb8: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000bfbc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bfc0: 0a000005 beq 3000bfdc <pthread_mutexattr_setpshared+0x2c> <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000bfc4: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000bfc8: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000bfcc: 93a00000 movls r0, #0 <== NOT EXECUTED
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000bfd0: 912fff1e bxls lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000bfd4: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000bfd8: e12fff1e bx lr <== NOT EXECUTED
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
3000bfdc: e3a00016 mov r0, #22 <== NOT EXECUTED 3000bfe0: e12fff1e bx lr <== NOT EXECUTED
3000a508 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
3000a508: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if ( !once_control || !init_routine )
3000a50c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a510: 13510000 cmpne r1, #0 <== NOT EXECUTED 3000a514: e1a04000 mov r4, r0 <== NOT EXECUTED
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
3000a518: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
if ( !once_control || !init_routine )
3000a51c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a520: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000a524: e1a05001 mov r5, r1 <== NOT EXECUTED
return EINVAL;
3000a528: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
3000a52c: 0a000002 beq 3000a53c <pthread_once+0x34> <== NOT EXECUTED
return EINVAL;
if ( !once_control->init_executed ) {
3000a530: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3000a534: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a538: 0a000001 beq 3000a544 <pthread_once+0x3c> <== NOT EXECUTED
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
3000a53c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a540: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
3000a544: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED 3000a548: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a54c: e1a0200d mov r2, sp <== NOT EXECUTED 3000a550: eb0002e6 bl 3000b0f0 <rtems_task_mode> <== NOT EXECUTED
if ( !once_control->init_executed ) {
3000a554: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
3000a558: e1a0600d mov r6, sp <== NOT EXECUTED
if ( !once_control->init_executed ) {
3000a55c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a560: 0a000005 beq 3000a57c <pthread_once+0x74> <== NOT EXECUTED
once_control->is_initialized = true;
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
3000a564: e59d0000 ldr r0, [sp] <== NOT EXECUTED 3000a568: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED 3000a56c: e1a0200d mov r2, sp <== NOT EXECUTED 3000a570: eb0002de bl 3000b0f0 <rtems_task_mode> <== NOT EXECUTED
} return 0;
3000a574: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a578: eaffffef b 3000a53c <pthread_once+0x34> <== NOT EXECUTED
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( !once_control->init_executed ) {
once_control->is_initialized = true;
3000a57c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a580: e5843000 str r3, [r4] <== NOT EXECUTED
once_control->init_executed = true;
3000a584: e5843004 str r3, [r4, #4] <== NOT EXECUTED
(*init_routine)();
3000a588: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a58c: e12fff15 bx r5 <== NOT EXECUTED 3000a590: eafffff3 b 3000a564 <pthread_once+0x5c> <== NOT EXECUTED
3000b104 <pthread_rwlock_destroy>:
*/
int pthread_rwlock_destroy(
pthread_rwlock_t *rwlock
)
{
3000b104: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
3000b108: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_rwlock_destroy(
pthread_rwlock_t *rwlock
)
{
3000b10c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
3000b110: 0a00000e beq 3000b150 <pthread_rwlock_destroy+0x4c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
3000b114: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000b118: e59f0060 ldr r0, [pc, #96] ; 3000b180 <pthread_rwlock_destroy+0x7c><== NOT EXECUTED 3000b11c: e1a0200d mov r2, sp <== NOT EXECUTED 3000b120: eb000b13 bl 3000dd74 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b124: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000b128: e1a04000 mov r4, r0 <== NOT EXECUTED 3000b12c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b130: 1a000006 bne 3000b150 <pthread_rwlock_destroy+0x4c> <== 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 ) {
3000b134: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000b138: eb001057 bl 3000f29c <_Thread_queue_First> <== NOT EXECUTED 3000b13c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000b140: 0a000005 beq 3000b15c <pthread_rwlock_destroy+0x58> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b144: eb000e43 bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
3000b148: e3a00010 mov r0, #16 <== NOT EXECUTED 3000b14c: ea000000 b 3000b154 <pthread_rwlock_destroy+0x50> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b150: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b154: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b158: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* POSIX doesn't require behavior when it is locked.
*/
_Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object );
3000b15c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000b160: e59f0018 ldr r0, [pc, #24] ; 3000b180 <pthread_rwlock_destroy+0x7c><== NOT EXECUTED 3000b164: eb0009f6 bl 3000d944 <_Objects_Close> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free (
POSIX_RWLock_Control *the_RWLock
)
{
_Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object );
3000b168: e59f0010 ldr r0, [pc, #16] ; 3000b180 <pthread_rwlock_destroy+0x7c><== NOT EXECUTED 3000b16c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000b170: eb000aa8 bl 3000dc18 <_Objects_Free> <== NOT EXECUTED
_POSIX_RWLock_Free( the_rwlock );
_Thread_Enable_dispatch();
3000b174: eb000e37 bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000b178: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b17c: eafffff4 b 3000b154 <pthread_rwlock_destroy+0x50> <== NOT EXECUTED
3000b184 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
3000b184: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
3000b188: e2505000 subs r5, r0, #0 <== NOT EXECUTED
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
3000b18c: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
3000b190: 0a000007 beq 3000b1b4 <pthread_rwlock_init+0x30> <== NOT EXECUTED
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
3000b194: e3510000 cmp r1, #0 <== NOT EXECUTED 3000b198: 0a000021 beq 3000b224 <pthread_rwlock_init+0xa0> <== NOT EXECUTED
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
3000b19c: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000b1a0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b1a4: 0a000002 beq 3000b1b4 <pthread_rwlock_init+0x30> <== NOT EXECUTED
return EINVAL;
switch ( the_attr->process_shared ) {
3000b1a8: e5914004 ldr r4, [r1, #4] <== NOT EXECUTED 3000b1ac: e3540000 cmp r4, #0 <== NOT EXECUTED 3000b1b0: 0a000002 beq 3000b1c0 <pthread_rwlock_init+0x3c> <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
3000b1b4: e3a00016 mov r0, #22 <== NOT EXECUTED
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
3000b1b8: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000b1bc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b1c0: e59f3070 ldr r3, [pc, #112] ; 3000b238 <pthread_rwlock_init+0xb4><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
3000b1c4: e58d4008 str r4, [sp, #8] <== NOT EXECUTED 3000b1c8: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b1cc: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000b1d0: 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 );
3000b1d4: e59f7060 ldr r7, [pc, #96] ; 3000b23c <pthread_rwlock_init+0xb8><== NOT EXECUTED 3000b1d8: e1a00007 mov r0, r7 <== NOT EXECUTED 3000b1dc: eb0009b3 bl 3000d8b0 <_Objects_Allocate> <== NOT EXECUTED
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
3000b1e0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000b1e4: 0a00000b beq 3000b218 <pthread_rwlock_init+0x94> <== NOT EXECUTED
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
3000b1e8: e2860010 add r0, r6, #16 <== NOT EXECUTED 3000b1ec: e28d1008 add r1, sp, #8 <== NOT EXECUTED 3000b1f0: eb000775 bl 3000cfcc <_CORE_RWLock_Initialize> <== NOT EXECUTED
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000b1f4: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b1f8: e597201c ldr r2, [r7, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
3000b1fc: e1a01803 lsl r1, r3, #16 <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000b200: e7826721 str r6, [r2, r1, lsr #14] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
3000b204: e586400c str r4, [r6, #12] <== NOT EXECUTED
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
3000b208: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b20c: eb000e11 bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000b210: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b214: eaffffe7 b 3000b1b8 <pthread_rwlock_init+0x34> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
3000b218: eb000e0e bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
3000b21c: e3a0000b mov r0, #11 <== NOT EXECUTED 3000b220: eaffffe4 b 3000b1b8 <pthread_rwlock_init+0x34> <== NOT EXECUTED
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
3000b224: e1a0000d mov r0, sp <== NOT EXECUTED 3000b228: eb000265 bl 3000bbc4 <pthread_rwlockattr_init> <== NOT EXECUTED 3000b22c: e1a0400d mov r4, sp <== NOT EXECUTED
the_attr = &default_attr;
3000b230: e1a0100d mov r1, sp <== NOT EXECUTED 3000b234: eaffffd8 b 3000b19c <pthread_rwlock_init+0x18> <== NOT EXECUTED
3000b240 <pthread_rwlock_rdlock>:
*/
int pthread_rwlock_rdlock(
pthread_rwlock_t *rwlock
)
{
3000b240: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b244: e2504000 subs r4, r0, #0 <== NOT EXECUTED
*/
int pthread_rwlock_rdlock(
pthread_rwlock_t *rwlock
)
{
3000b248: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b24c: 0a000006 beq 3000b26c <pthread_rwlock_rdlock+0x2c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
3000b250: e59f004c ldr r0, [pc, #76] ; 3000b2a4 <pthread_rwlock_rdlock+0x64><== NOT EXECUTED 3000b254: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000b258: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000b25c: eb000ac4 bl 3000dd74 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b260: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3000b264: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b268: 0a000002 beq 3000b278 <pthread_rwlock_rdlock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b26c: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b270: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000b274: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000b278: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000b27c: e3a02001 mov r2, #1 <== NOT EXECUTED 3000b280: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000b284: e58d3000 str r3, [sp] <== NOT EXECUTED 3000b288: eb000757 bl 3000cfec <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED
true, /* we are willing to wait forever */
0,
NULL
);
_Thread_Enable_dispatch();
3000b28c: eb000df1 bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000b290: e59f3010 ldr r3, [pc, #16] ; 3000b2a8 <pthread_rwlock_rdlock+0x68><== NOT EXECUTED 3000b294: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b298: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000b29c: eb00006a bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b2a0: eafffff2 b 3000b270 <pthread_rwlock_rdlock+0x30> <== NOT EXECUTED
3000b2ac <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000b2ac: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000b2b0: e2505000 subs r5, r0, #0 <== NOT EXECUTED
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000b2b4: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000b2b8: 0a00001d beq 3000b334 <pthread_rwlock_timedrdlock+0x88> <== 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 );
3000b2bc: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b2c0: e28d1004 add r1, sp, #4 <== NOT EXECUTED 3000b2c4: eb001a35 bl 30011ba0 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 3000b2c8: e5951000 ldr r1, [r5] <== NOT EXECUTED 3000b2cc: e1a04000 mov r4, r0 <== NOT EXECUTED 3000b2d0: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000b2d4: e59f0098 ldr r0, [pc, #152] ; 3000b374 <pthread_rwlock_timedrdlock+0xc8><== NOT EXECUTED 3000b2d8: eb000aa5 bl 3000dd74 <_Objects_Get> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b2dc: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3000b2e0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b2e4: 1a000012 bne 3000b334 <pthread_rwlock_timedrdlock+0x88> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000b2e8: e5951000 ldr r1, [r5] <== 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,
3000b2ec: e3540003 cmp r4, #3 <== NOT EXECUTED 3000b2f0: 13a05000 movne r5, #0 <== NOT EXECUTED 3000b2f4: 03a05001 moveq r5, #1 <== NOT EXECUTED 3000b2f8: e58d3000 str r3, [sp] <== NOT EXECUTED 3000b2fc: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000b300: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b304: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3000b308: eb000737 bl 3000cfec <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
3000b30c: eb000dd1 bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !do_wait ) {
3000b310: e3550000 cmp r5, #0 <== NOT EXECUTED 3000b314: 1a000011 bne 3000b360 <pthread_rwlock_timedrdlock+0xb4> <== NOT EXECUTED
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
3000b318: e59f3058 ldr r3, [pc, #88] ; 3000b378 <pthread_rwlock_timedrdlock+0xcc><== NOT EXECUTED 3000b31c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000b320: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000b324: e3500002 cmp r0, #2 <== NOT EXECUTED 3000b328: 0a000004 beq 3000b340 <pthread_rwlock_timedrdlock+0x94> <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b32c: eb000046 bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b330: ea000000 b 3000b338 <pthread_rwlock_timedrdlock+0x8c> <== 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;
3000b334: e3a00016 mov r0, #22 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000b338: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000b33c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000b340: e3540000 cmp r4, #0 <== NOT EXECUTED 3000b344: 0afffffa beq 3000b334 <pthread_rwlock_timedrdlock+0x88> <== NOT EXECUTED
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000b348: e2444001 sub r4, r4, #1 <== NOT EXECUTED 3000b34c: e3540001 cmp r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
3000b350: 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 ||
3000b354: 9afffff7 bls 3000b338 <pthread_rwlock_timedrdlock+0x8c> <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b358: eb00003b bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b35c: eafffff5 b 3000b338 <pthread_rwlock_timedrdlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
3000b360: e59f3010 ldr r3, [pc, #16] ; 3000b378 <pthread_rwlock_timedrdlock+0xcc><== NOT EXECUTED 3000b364: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000b368: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b36c: eb000036 bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b370: eafffff0 b 3000b338 <pthread_rwlock_timedrdlock+0x8c> <== NOT EXECUTED
3000b37c <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000b37c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000b380: e2505000 subs r5, r0, #0 <== NOT EXECUTED
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
3000b384: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
3000b388: 0a00001d beq 3000b404 <pthread_rwlock_timedwrlock+0x88> <== 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 );
3000b38c: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b390: e28d1004 add r1, sp, #4 <== NOT EXECUTED 3000b394: eb001a01 bl 30011ba0 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 3000b398: e5951000 ldr r1, [r5] <== NOT EXECUTED 3000b39c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000b3a0: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000b3a4: e59f0098 ldr r0, [pc, #152] ; 3000b444 <pthread_rwlock_timedwrlock+0xc8><== NOT EXECUTED 3000b3a8: eb000a71 bl 3000dd74 <_Objects_Get> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b3ac: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3000b3b0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b3b4: 1a000012 bne 3000b404 <pthread_rwlock_timedwrlock+0x88> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000b3b8: e5951000 ldr r1, [r5] <== 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,
3000b3bc: e3540003 cmp r4, #3 <== NOT EXECUTED 3000b3c0: 13a05000 movne r5, #0 <== NOT EXECUTED 3000b3c4: 03a05001 moveq r5, #1 <== NOT EXECUTED 3000b3c8: e58d3000 str r3, [sp] <== NOT EXECUTED 3000b3cc: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000b3d0: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b3d4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3000b3d8: eb00073a bl 3000d0c8 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
3000b3dc: eb000d9d bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !do_wait &&
3000b3e0: e3550000 cmp r5, #0 <== NOT EXECUTED 3000b3e4: 1a000011 bne 3000b430 <pthread_rwlock_timedwrlock+0xb4> <== NOT EXECUTED
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
3000b3e8: e59f3058 ldr r3, [pc, #88] ; 3000b448 <pthread_rwlock_timedwrlock+0xcc><== NOT EXECUTED 3000b3ec: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000b3f0: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
3000b3f4: e3500002 cmp r0, #2 <== NOT EXECUTED 3000b3f8: 0a000004 beq 3000b410 <pthread_rwlock_timedwrlock+0x94> <== 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(
3000b3fc: eb000012 bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b400: ea000000 b 3000b408 <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
3000b404: e3a00016 mov r0, #22 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
3000b408: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000b40c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
3000b410: e3540000 cmp r4, #0 <== NOT EXECUTED 3000b414: 0afffffa beq 3000b404 <pthread_rwlock_timedwrlock+0x88> <== NOT EXECUTED
return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
3000b418: e2444001 sub r4, r4, #1 <== NOT EXECUTED 3000b41c: e3540001 cmp r4, #1 <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
3000b420: 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 ||
3000b424: 9afffff7 bls 3000b408 <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b428: eb000007 bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b42c: eafffff5 b 3000b408 <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
3000b430: e59f3010 ldr r3, [pc, #16] ; 3000b448 <pthread_rwlock_timedwrlock+0xcc><== NOT EXECUTED 3000b434: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000b438: e5930034 ldr r0, [r3, #52] ; 0x34 <== 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(
3000b43c: eb000002 bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b440: eafffff0 b 3000b408 <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
3000b45c <pthread_rwlock_tryrdlock>:
*/
int pthread_rwlock_tryrdlock(
pthread_rwlock_t *rwlock
)
{
3000b45c: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b460: e2504000 subs r4, r0, #0 <== NOT EXECUTED
*/
int pthread_rwlock_tryrdlock(
pthread_rwlock_t *rwlock
)
{
3000b464: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b468: 0a000006 beq 3000b488 <pthread_rwlock_tryrdlock+0x2c> <== NOT EXECUTED 3000b46c: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000b470: e59f0048 ldr r0, [pc, #72] ; 3000b4c0 <pthread_rwlock_tryrdlock+0x64><== NOT EXECUTED 3000b474: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000b478: eb000a3d bl 3000dd74 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b47c: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 3000b480: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b484: 0a000002 beq 3000b494 <pthread_rwlock_tryrdlock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b488: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b48c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000b490: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
3000b494: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000b498: e1a03002 mov r3, r2 <== NOT EXECUTED 3000b49c: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000b4a0: e58d2000 str r2, [sp] <== NOT EXECUTED 3000b4a4: eb0006d0 bl 3000cfec <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED
0,
NULL
);
_Thread_Enable_dispatch();
3000b4a8: eb000d6a bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000b4ac: e59f3010 ldr r3, [pc, #16] ; 3000b4c4 <pthread_rwlock_tryrdlock+0x68><== NOT EXECUTED 3000b4b0: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b4b4: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000b4b8: ebffffe3 bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b4bc: eafffff2 b 3000b48c <pthread_rwlock_tryrdlock+0x30> <== NOT EXECUTED
3000b4c8 <pthread_rwlock_trywrlock>:
*/
int pthread_rwlock_trywrlock(
pthread_rwlock_t *rwlock
)
{
3000b4c8: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b4cc: e2504000 subs r4, r0, #0 <== NOT EXECUTED
*/
int pthread_rwlock_trywrlock(
pthread_rwlock_t *rwlock
)
{
3000b4d0: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b4d4: 0a000006 beq 3000b4f4 <pthread_rwlock_trywrlock+0x2c> <== NOT EXECUTED 3000b4d8: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000b4dc: e59f0048 ldr r0, [pc, #72] ; 3000b52c <pthread_rwlock_trywrlock+0x64><== NOT EXECUTED 3000b4e0: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000b4e4: eb000a22 bl 3000dd74 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b4e8: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 3000b4ec: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b4f0: 0a000002 beq 3000b500 <pthread_rwlock_trywrlock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b4f4: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b4f8: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000b4fc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000b500: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000b504: e1a03002 mov r3, r2 <== NOT EXECUTED 3000b508: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000b50c: e58d2000 str r2, [sp] <== NOT EXECUTED 3000b510: eb0006ec bl 3000d0c8 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED
false, /* we are not willing to wait */
0,
NULL
);
_Thread_Enable_dispatch();
3000b514: eb000d4f bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000b518: e59f3010 ldr r3, [pc, #16] ; 3000b530 <pthread_rwlock_trywrlock+0x68><== NOT EXECUTED 3000b51c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b520: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000b524: ebffffc8 bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b528: eafffff2 b 3000b4f8 <pthread_rwlock_trywrlock+0x30> <== NOT EXECUTED
3000b534 <pthread_rwlock_unlock>:
*/
int pthread_rwlock_unlock(
pthread_rwlock_t *rwlock
)
{
3000b534: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
CORE_RWLock_Status status;
if ( !rwlock )
3000b538: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_rwlock_unlock(
pthread_rwlock_t *rwlock
)
{
3000b53c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
CORE_RWLock_Status status;
if ( !rwlock )
3000b540: 0a000006 beq 3000b560 <pthread_rwlock_unlock+0x2c> <== NOT EXECUTED 3000b544: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000b548: e59f0038 ldr r0, [pc, #56] ; 3000b588 <pthread_rwlock_unlock+0x54><== NOT EXECUTED 3000b54c: e1a0200d mov r2, sp <== NOT EXECUTED 3000b550: eb000a07 bl 3000dd74 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b554: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000b558: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b55c: 0a000002 beq 3000b56c <pthread_rwlock_unlock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b560: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b564: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b568: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_RWLock_Release( &the_rwlock->RWLock );
3000b56c: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000b570: eb0006f9 bl 3000d15c <_CORE_RWLock_Release> <== NOT EXECUTED 3000b574: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b578: eb000d36 bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_RWLock_Translate_core_RWLock_return_code( status );
3000b57c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b580: ebffffb1 bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b584: eafffff6 b 3000b564 <pthread_rwlock_unlock+0x30> <== NOT EXECUTED
3000b58c <pthread_rwlock_wrlock>:
*/
int pthread_rwlock_wrlock(
pthread_rwlock_t *rwlock
)
{
3000b58c: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b590: e2504000 subs r4, r0, #0 <== NOT EXECUTED
*/
int pthread_rwlock_wrlock(
pthread_rwlock_t *rwlock
)
{
3000b594: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
POSIX_RWLock_Control *the_rwlock;
Objects_Locations location;
if ( !rwlock )
3000b598: 0a000006 beq 3000b5b8 <pthread_rwlock_wrlock+0x2c> <== NOT EXECUTED 3000b59c: e59f004c ldr r0, [pc, #76] ; 3000b5f0 <pthread_rwlock_wrlock+0x64><== NOT EXECUTED 3000b5a0: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000b5a4: e28d2004 add r2, sp, #4 <== NOT EXECUTED 3000b5a8: eb0009f1 bl 3000dd74 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
3000b5ac: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3000b5b0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b5b4: 0a000002 beq 3000b5c4 <pthread_rwlock_wrlock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000b5b8: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000b5bc: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000b5c0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
3000b5c4: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000b5c8: e3a02001 mov r2, #1 <== NOT EXECUTED 3000b5cc: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000b5d0: e58d3000 str r3, [sp] <== NOT EXECUTED 3000b5d4: eb0006bb bl 3000d0c8 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED
true, /* do not timeout -- wait forever */
0,
NULL
);
_Thread_Enable_dispatch();
3000b5d8: eb000d1e bl 3000ea58 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
3000b5dc: e59f3010 ldr r3, [pc, #16] ; 3000b5f4 <pthread_rwlock_wrlock+0x68><== NOT EXECUTED 3000b5e0: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_RWLock_Translate_core_RWLock_return_code(
3000b5e4: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3000b5e8: ebffff97 bl 3000b44c <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED 3000b5ec: eafffff2 b 3000b5bc <pthread_rwlock_wrlock+0x30> <== NOT EXECUTED
3000bb78 <pthread_rwlockattr_destroy>:
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000bb78: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
3000bb7c: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
3000bb80: 012fff1e bxeq lr <== NOT EXECUTED 3000bb84: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000bb88: e3520000 cmp r2, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = false;
3000bb8c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000bb90: 15830000 strne r0, [r3] <== NOT EXECUTED
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
3000bb94: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = false;
return 0;
}
3000bb98: e12fff1e bx lr <== NOT EXECUTED
3000bb9c <pthread_rwlockattr_getpshared>:
int pthread_rwlockattr_getpshared(
const pthread_rwlockattr_t *attr,
int *pshared
)
{
if ( !attr )
3000bb9c: e3500000 cmp r0, #0 <== NOT EXECUTED
return EINVAL;
3000bba0: 03a00016 moveq r0, #22 <== NOT EXECUTED
int pthread_rwlockattr_getpshared(
const pthread_rwlockattr_t *attr,
int *pshared
)
{
if ( !attr )
3000bba4: 012fff1e bxeq lr <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000bba8: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000bbac: e3530000 cmp r3, #0 <== NOT EXECUTED
return EINVAL;
*pshared = attr->process_shared;
3000bbb0: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000bbb4: 03a00016 moveq r0, #22 <== NOT EXECUTED
*pshared = attr->process_shared;
return 0;
3000bbb8: 13a00000 movne r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
*pshared = attr->process_shared;
3000bbbc: 15813000 strne r3, [r1] <== NOT EXECUTED
return 0; }
3000bbc0: e12fff1e bx lr <== NOT EXECUTED
3000bbc4 <pthread_rwlockattr_init>:
int pthread_rwlockattr_init(
pthread_rwlockattr_t *attr
)
{
if ( !attr )
3000bbc4: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return EINVAL;
attr->is_initialized = true;
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
3000bbc8: 13a00000 movne r0, #0 <== NOT EXECUTED
)
{
if ( !attr )
return EINVAL;
attr->is_initialized = true;
3000bbcc: 13a02001 movne r2, #1 <== NOT EXECUTED 3000bbd0: 15832000 strne r2, [r3] <== NOT EXECUTED
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
3000bbd4: 15830004 strne r0, [r3, #4] <== NOT EXECUTED
int pthread_rwlockattr_init(
pthread_rwlockattr_t *attr
)
{
if ( !attr )
return EINVAL;
3000bbd8: 03a00016 moveq r0, #22 <== NOT EXECUTED
attr->is_initialized = true;
attr->process_shared = PTHREAD_PROCESS_PRIVATE;
return 0;
}
3000bbdc: e12fff1e bx lr <== NOT EXECUTED
3000bbe0 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
3000bbe0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bbe4: 0a000008 beq 3000bc0c <pthread_rwlockattr_setpshared+0x2c> <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
3000bbe8: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000bbec: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bbf0: 0a000005 beq 3000bc0c <pthread_rwlockattr_setpshared+0x2c> <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
3000bbf4: e3510001 cmp r1, #1 <== NOT EXECUTED
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
3000bbf8: 95801004 strls r1, [r0, #4] <== NOT EXECUTED
return 0;
3000bbfc: 93a00000 movls r0, #0 <== NOT EXECUTED
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
3000bc00: 912fff1e bxls lr <== NOT EXECUTED
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
3000bc04: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
3000bc08: e12fff1e bx lr <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
3000bc0c: e3a00016 mov r0, #22 <== NOT EXECUTED 3000bc10: e12fff1e bx lr <== NOT EXECUTED
300271bc <pthread_self>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
pthread_t pthread_self( void )
{
return _Thread_Executing->Object.id;
300271bc: e59f3008 ldr r3, [pc, #8] ; 300271cc <pthread_self+0x10> <== NOT EXECUTED 300271c0: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
}
300271c4: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 300271c8: e12fff1e bx lr <== NOT EXECUTED
300097bc <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() )
300097bc: e59f3064 ldr r3, [pc, #100] ; 30009828 <pthread_setcancelstate+0x6c><== NOT EXECUTED
int pthread_setcancelstate(
int state,
int *oldstate
)
{
300097c0: 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() )
300097c4: e5934000 ldr r4, [r3] <== NOT EXECUTED
int pthread_setcancelstate(
int state,
int *oldstate
)
{
300097c8: e1a02000 mov r2, r0 <== 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() )
300097cc: e3540000 cmp r4, #0 <== NOT EXECUTED
return EPROTO;
300097d0: 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() )
300097d4: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return EPROTO;
if ( !oldstate )
300097d8: e3510000 cmp r1, #0 <== NOT EXECUTED
return EINVAL;
300097dc: 03a00016 moveq r0, #22 <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
if ( !oldstate )
300097e0: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
300097e4: e3520001 cmp r2, #1 <== NOT EXECUTED 300097e8: 9a000001 bls 300097f4 <pthread_setcancelstate+0x38> <== NOT EXECUTED
return EINVAL;
300097ec: e3a00016 mov r0, #22 <== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
300097f0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
300097f4: e59f0030 ldr r0, [pc, #48] ; 3000982c <pthread_setcancelstate+0x70><== NOT EXECUTED
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
300097f8: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED 300097fc: e590e000 ldr lr, [r0] <== NOT EXECUTED 30009800: e59cc0fc ldr ip, [ip, #252] ; 0xfc <== NOT EXECUTED 30009804: e28ee001 add lr, lr, #1 <== NOT EXECUTED 30009808: e580e000 str lr, [r0] <== NOT EXECUTED
_Thread_Disable_dispatch();
*oldstate = thread_support->cancelability_state;
3000980c: e59ce0d8 ldr lr, [ip, #216] ; 0xd8 <== NOT EXECUTED
thread_support->cancelability_state = state;
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
30009810: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
_Thread_Disable_dispatch();
*oldstate = thread_support->cancelability_state;
30009814: e581e000 str lr, [r1] <== NOT EXECUTED
thread_support->cancelability_state = state;
30009818: e58c20d8 str r2, [ip, #216] ; 0xd8 <== NOT EXECUTED
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
3000981c: eb00163e bl 3000f11c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
30009820: e1a00004 mov r0, r4 <== NOT EXECUTED
30009824: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30009830 <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() )
30009830: e59f3064 ldr r3, [pc, #100] ; 3000989c <pthread_setcanceltype+0x6c><== NOT EXECUTED
int pthread_setcanceltype(
int type,
int *oldtype
)
{
30009834: 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() )
30009838: e5934000 ldr r4, [r3] <== NOT EXECUTED
int pthread_setcanceltype(
int type,
int *oldtype
)
{
3000983c: e1a02000 mov r2, r0 <== 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() )
30009840: e3540000 cmp r4, #0 <== NOT EXECUTED
return EPROTO;
30009844: 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() )
30009848: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return EPROTO;
if ( !oldtype )
3000984c: e3510000 cmp r1, #0 <== NOT EXECUTED
return EINVAL;
30009850: 03a00016 moveq r0, #22 <== NOT EXECUTED
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
if ( !oldtype )
30009854: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
30009858: e3520001 cmp r2, #1 <== NOT EXECUTED 3000985c: 9a000001 bls 30009868 <pthread_setcanceltype+0x38> <== NOT EXECUTED
return EINVAL;
30009860: e3a00016 mov r0, #22 <== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
30009864: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30009868: e59f0030 ldr r0, [pc, #48] ; 300098a0 <pthread_setcanceltype+0x70><== NOT EXECUTED
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000986c: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED 30009870: e590e000 ldr lr, [r0] <== NOT EXECUTED 30009874: e59cc0fc ldr ip, [ip, #252] ; 0xfc <== NOT EXECUTED 30009878: e28ee001 add lr, lr, #1 <== NOT EXECUTED 3000987c: e580e000 str lr, [r0] <== NOT EXECUTED
_Thread_Disable_dispatch();
*oldtype = thread_support->cancelability_type;
30009880: e59ce0dc ldr lr, [ip, #220] ; 0xdc <== NOT EXECUTED
thread_support->cancelability_type = type;
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
30009884: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
_Thread_Disable_dispatch();
*oldtype = thread_support->cancelability_type;
30009888: e581e000 str lr, [r1] <== NOT EXECUTED
thread_support->cancelability_type = type;
3000988c: e58c20dc str r2, [ip, #220] ; 0xdc <== NOT EXECUTED
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
30009890: eb001621 bl 3000f11c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch><== NOT EXECUTED
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
30009894: e1a00004 mov r0, r4 <== NOT EXECUTED
30009898: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000cc8c <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
3000cc8c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int rc;
/*
* Check all the parameters
*/
if ( !param )
3000cc90: e2524000 subs r4, r2, #0 <== NOT EXECUTED
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
3000cc94: e24dd00c sub sp, sp, #12 <== NOT EXECUTED 3000cc98: e1a07000 mov r7, r0 <== NOT EXECUTED 3000cc9c: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
3000cca0: 03a06016 moveq r6, #22 <== NOT EXECUTED
int rc;
/*
* Check all the parameters
*/
if ( !param )
3000cca4: 0a000006 beq 3000ccc4 <pthread_setschedparam+0x38> <== NOT EXECUTED
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
3000cca8: e1a00001 mov r0, r1 <== NOT EXECUTED 3000ccac: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000ccb0: e1a01004 mov r1, r4 <== NOT EXECUTED 3000ccb4: e28d3004 add r3, sp, #4 <== NOT EXECUTED 3000ccb8: eb00182e bl 30012d78 <_POSIX_Thread_Translate_sched_param> <== NOT EXECUTED
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
3000ccbc: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000ccc0: 0a000002 beq 3000ccd0 <pthread_setschedparam+0x44> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
3000ccc4: e1a00006 mov r0, r6 <== NOT EXECUTED
3000ccc8: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000cccc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
3000ccd0: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ccd4: e1a0100d mov r1, sp <== NOT EXECUTED 3000ccd8: eb000b23 bl 3000f96c <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000ccdc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
3000cce0: e1a08000 mov r8, r0 <== NOT EXECUTED
switch ( location ) {
3000cce4: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
3000cce8: 13a06003 movne r6, #3 <== NOT EXECUTED
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
switch ( location ) {
3000ccec: 1afffff4 bne 3000ccc4 <pthread_setschedparam+0x38> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000ccf0: e59070fc ldr r7, [r0, #252] ; 0xfc <== NOT EXECUTED
if ( api->schedpolicy == SCHED_SPORADIC )
3000ccf4: e5973084 ldr r3, [r7, #132] ; 0x84 <== NOT EXECUTED 3000ccf8: e3530004 cmp r3, #4 <== NOT EXECUTED 3000ccfc: 0a000025 beq 3000cd98 <pthread_setschedparam+0x10c> <== NOT EXECUTED
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
3000cd00: e5875084 str r5, [r7, #132] ; 0x84 <== NOT EXECUTED
api->schedparam = *param;
3000cd04: e287c088 add ip, r7, #136 ; 0x88 <== NOT EXECUTED
3000cd08: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3000cd0c: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
the_thread->budget_algorithm = budget_algorithm;
3000cd10: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
3000cd14: e8940007 ldm r4, {r0, r1, r2} <== NOT EXECUTED
3000cd18: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
the_thread->budget_algorithm = budget_algorithm;
3000cd1c: e588307c str r3, [r8, #124] ; 0x7c <== NOT EXECUTED
the_thread->budget_callout = budget_callout;
3000cd20: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
switch ( api->schedpolicy ) {
3000cd24: e3550000 cmp r5, #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;
3000cd28: e5883080 str r3, [r8, #128] ; 0x80 <== NOT EXECUTED
switch ( api->schedpolicy ) {
3000cd2c: ba00000c blt 3000cd64 <pthread_setschedparam+0xd8> <== NOT EXECUTED 3000cd30: e3550002 cmp r5, #2 <== NOT EXECUTED 3000cd34: ca00000c bgt 3000cd6c <pthread_setschedparam+0xe0> <== NOT EXECUTED 3000cd38: e59f3064 ldr r3, [pc, #100] ; 3000cda4 <pthread_setschedparam+0x118><== NOT EXECUTED 3000cd3c: e5972088 ldr r2, [r7, #136] ; 0x88 <== NOT EXECUTED 3000cd40: e5d31000 ldrb r1, [r3] <== NOT EXECUTED
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000cd44: e59f305c ldr r3, [pc, #92] ; 3000cda8 <pthread_setschedparam+0x11c><== NOT EXECUTED 3000cd48: e0621001 rsb r1, r2, r1 <== NOT EXECUTED 3000cd4c: e5933000 ldr r3, [r3] <== NOT EXECUTED
the_thread->real_priority =
3000cd50: e5881018 str r1, [r8, #24] <== NOT EXECUTED
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000cd54: e5883078 str r3, [r8, #120] ; 0x78 <== NOT EXECUTED
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
3000cd58: e1a00008 mov r0, r8 <== NOT EXECUTED 3000cd5c: e3a02001 mov r2, #1 <== NOT EXECUTED 3000cd60: eb0009db bl 3000f4d4 <_Thread_Change_priority> <== NOT EXECUTED
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
3000cd64: eb000af7 bl 3000f948 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000cd68: eaffffd5 b 3000ccc4 <pthread_setschedparam+0x38> <== NOT EXECUTED
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
3000cd6c: e3550004 cmp r5, #4 <== NOT EXECUTED 3000cd70: 1afffffb bne 3000cd64 <pthread_setschedparam+0xd8> <== NOT EXECUTED
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
3000cd74: e5973088 ldr r3, [r7, #136] ; 0x88 <== NOT EXECUTED
_Watchdog_Remove( &api->Sporadic_timer );
3000cd78: e28700a8 add r0, r7, #168 ; 0xa8 <== NOT EXECUTED
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
3000cd7c: e58730a4 str r3, [r7, #164] ; 0xa4 <== NOT EXECUTED
_Watchdog_Remove( &api->Sporadic_timer );
3000cd80: eb000f6d bl 30010b3c <_Watchdog_Remove> <== NOT EXECUTED
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
3000cd84: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cd88: e1a01008 mov r1, r8 <== NOT EXECUTED 3000cd8c: ebffff72 bl 3000cb5c <_POSIX_Threads_Sporadic_budget_TSR> <== NOT EXECUTED
break;
}
_Thread_Enable_dispatch();
3000cd90: eb000aec bl 3000f948 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000cd94: eaffffca b 3000ccc4 <pthread_setschedparam+0x38> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
3000cd98: e28700a8 add r0, r7, #168 ; 0xa8 <== NOT EXECUTED 3000cd9c: eb000f66 bl 30010b3c <_Watchdog_Remove> <== NOT EXECUTED 3000cda0: eaffffd6 b 3000cd00 <pthread_setschedparam+0x74> <== NOT EXECUTED
30009da0 <pthread_setspecific>:
int pthread_setspecific(
pthread_key_t key,
const void *value
)
{
30009da0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30009da4: e1a03000 mov r3, r0 <== NOT EXECUTED
30009da8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
30009dac: e1a04001 mov r4, r1 <== NOT EXECUTED
30009db0: e59f004c ldr r0, [pc, #76] ; 30009e04 <pthread_setspecific+0x64><== NOT EXECUTED
30009db4: e1a01003 mov r1, r3 <== NOT EXECUTED
30009db8: e1a0200d mov r2, sp <== NOT EXECUTED
30009dbc: eb000959 bl 3000c328 <_Objects_Get> <== NOT EXECUTED
uint32_t api;
uint32_t index;
Objects_Locations location;
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
30009dc0: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30009dc4: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
30009dc8: 13a00016 movne r0, #22 <== NOT EXECUTED
uint32_t api;
uint32_t index;
Objects_Locations location;
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
30009dcc: 1a00000a bne 30009dfc <pthread_setspecific+0x5c> <== NOT EXECUTED
case OBJECTS_LOCAL:
api = _Objects_Get_API( _Thread_Executing->Object.id );
30009dd0: e59f3030 ldr r3, [pc, #48] ; 30009e08 <pthread_setspecific+0x68><== NOT EXECUTED 30009dd4: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30009dd8: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30009ddc: e1a02c23 lsr r2, r3, #24 <== NOT EXECUTED 30009de0: e2022007 and r2, r2, #7 <== NOT EXECUTED
index = _Objects_Get_index( _Thread_Executing->Object.id );
the_key->Values[ api ][ index ] = (void *) value;
30009de4: e2822005 add r2, r2, #5 <== NOT EXECUTED 30009de8: 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 );
30009dec: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED
the_key->Values[ api ][ index ] = (void *) value;
30009df0: e7824723 str r4, [r2, r3, lsr #14] <== NOT EXECUTED
_Thread_Enable_dispatch();
30009df4: eb000c84 bl 3000d00c <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009df8: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
30009dfc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30009e00: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
300109f4 <pthread_sigmask>:
sigset_t *oset
)
{
POSIX_API_Control *api;
if ( !set && !oset )
300109f4: e2713001 rsbs r3, r1, #1 <== NOT EXECUTED 300109f8: 33a03000 movcc r3, #0 <== NOT EXECUTED 300109fc: e3520000 cmp r2, #0 <== NOT EXECUTED 30010a00: 03510000 cmpeq r1, #0 <== NOT EXECUTED
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
30010a04: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set && !oset )
30010a08: 0a00001e beq 30010a88 <pthread_sigmask+0x94> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
30010a0c: e59fc0a4 ldr ip, [pc, #164] ; 30010ab8 <pthread_sigmask+0xc4><== NOT EXECUTED
if ( oset )
30010a10: 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 ];
30010a14: e59cc004 ldr ip, [ip, #4] <== NOT EXECUTED 30010a18: e59cc0fc ldr ip, [ip, #252] ; 0xfc <== NOT EXECUTED
if ( oset )
*oset = api->signals_blocked;
30010a1c: 159c40d0 ldrne r4, [ip, #208] ; 0xd0 <== NOT EXECUTED 30010a20: 15824000 strne r4, [r2] <== NOT EXECUTED
if ( !set )
30010a24: e3530000 cmp r3, #0 <== NOT EXECUTED 30010a28: 1a000020 bne 30010ab0 <pthread_sigmask+0xbc> <== NOT EXECUTED
return 0;
switch ( how ) {
30010a2c: e3500001 cmp r0, #1 <== NOT EXECUTED 30010a30: 0a000019 beq 30010a9c <pthread_sigmask+0xa8> <== NOT EXECUTED 30010a34: e3500002 cmp r0, #2 <== NOT EXECUTED 30010a38: 0a00000d beq 30010a74 <pthread_sigmask+0x80> <== NOT EXECUTED 30010a3c: e3500000 cmp r0, #0 <== NOT EXECUTED 30010a40: 1a000010 bne 30010a88 <pthread_sigmask+0x94> <== NOT EXECUTED
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
break;
case SIG_SETMASK:
api->signals_blocked = *set;
30010a44: e5911000 ldr r1, [r1] <== NOT EXECUTED 30010a48: e58c10d0 str r1, [ip, #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) ) {
30010a4c: e59f2068 ldr r2, [pc, #104] ; 30010abc <pthread_sigmask+0xc8><== NOT EXECUTED 30010a50: e59c30d4 ldr r3, [ip, #212] ; 0xd4 <== NOT EXECUTED 30010a54: e5920000 ldr r0, [r2] <== NOT EXECUTED
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
30010a58: e1800003 orr r0, r0, r3 <== NOT EXECUTED
30010a5c: e1c00001 bic r0, r0, r1 <== NOT EXECUTED
30010a60: e3500000 cmp r0, #0 <== NOT EXECUTED
30010a64: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
30010a68: ebfff17d bl 3000d064 <_Thread_Dispatch> <== NOT EXECUTED
}
return 0;
30010a6c: e3a00000 mov r0, #0 <== NOT EXECUTED
30010a70: e8bd8010 pop {r4, pc} <== NOT EXECUTED
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
30010a74: e5911000 ldr r1, [r1] <== NOT EXECUTED 30010a78: e59c30d0 ldr r3, [ip, #208] ; 0xd0 <== NOT EXECUTED 30010a7c: e1c31001 bic r1, r3, r1 <== NOT EXECUTED 30010a80: e58c10d0 str r1, [ip, #208] ; 0xd0 <== NOT EXECUTED
break;
30010a84: eafffff0 b 30010a4c <pthread_sigmask+0x58> <== NOT EXECUTED
case SIG_SETMASK:
api->signals_blocked = *set;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30010a88: eb000a37 bl 3001336c <__errno> <== NOT EXECUTED
30010a8c: e3a03016 mov r3, #22 <== NOT EXECUTED
30010a90: e5803000 str r3, [r0] <== NOT EXECUTED
30010a94: e3e00000 mvn r0, #0 <== NOT EXECUTED
30010a98: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( !set )
return 0;
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
30010a9c: e5911000 ldr r1, [r1] <== NOT EXECUTED 30010aa0: e59c30d0 ldr r3, [ip, #208] ; 0xd0 <== NOT EXECUTED 30010aa4: e1811003 orr r1, r1, r3 <== NOT EXECUTED 30010aa8: e58c10d0 str r1, [ip, #208] ; 0xd0 <== NOT EXECUTED
break;
30010aac: eaffffe6 b 30010a4c <pthread_sigmask+0x58> <== NOT EXECUTED
if ( oset )
*oset = api->signals_blocked;
if ( !set )
return 0;
30010ab0: e3a00000 mov r0, #0 <== NOT EXECUTED
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
30010ab4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30009e7c <pthread_spin_destroy>:
*/
int pthread_spin_destroy(
pthread_spinlock_t *spinlock
)
{
30009e7c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
if ( !spinlock )
30009e80: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_destroy(
pthread_spinlock_t *spinlock
)
{
30009e84: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
if ( !spinlock )
30009e88: 0a000007 beq 30009eac <pthread_spin_destroy+0x30> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get (
pthread_spinlock_t *spinlock,
Objects_Locations *location
)
{
return (POSIX_Spinlock_Control *) _Objects_Get(
30009e8c: e5931000 ldr r1, [r3] <== NOT EXECUTED 30009e90: e59f005c ldr r0, [pc, #92] ; 30009ef4 <pthread_spin_destroy+0x78><== NOT EXECUTED 30009e94: e1a0200d mov r2, sp <== NOT EXECUTED 30009e98: eb000882 bl 3000c0a8 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
30009e9c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30009ea0: e1a04000 mov r4, r0 <== NOT EXECUTED 30009ea4: e3530000 cmp r3, #0 <== NOT EXECUTED 30009ea8: 0a000002 beq 30009eb8 <pthread_spin_destroy+0x3c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
30009eac: e3a00016 mov r0, #22 <== NOT EXECUTED
}
30009eb0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30009eb4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _CORE_spinlock_Is_busy(
CORE_spinlock_Control *the_spinlock
)
{
return (the_spinlock->users != 0);
30009eb8: e5905018 ldr r5, [r0, #24] <== NOT EXECUTED
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) {
30009ebc: e3550000 cmp r5, #0 <== NOT EXECUTED 30009ec0: 0a000002 beq 30009ed0 <pthread_spin_destroy+0x54> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009ec4: eb000bb0 bl 3000cd8c <_Thread_Enable_dispatch> <== NOT EXECUTED
return EBUSY;
30009ec8: e3a00010 mov r0, #16 <== NOT EXECUTED 30009ecc: eafffff7 b 30009eb0 <pthread_spin_destroy+0x34> <== NOT EXECUTED
}
_Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object );
30009ed0: e1a01000 mov r1, r0 <== NOT EXECUTED 30009ed4: e59f0018 ldr r0, [pc, #24] ; 30009ef4 <pthread_spin_destroy+0x78><== NOT EXECUTED 30009ed8: eb000766 bl 3000bc78 <_Objects_Close> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _POSIX_Spinlock_Free (
POSIX_Spinlock_Control *the_spinlock
)
{
_Objects_Free( &_POSIX_Spinlock_Information, &the_spinlock->Object );
30009edc: e59f0010 ldr r0, [pc, #16] ; 30009ef4 <pthread_spin_destroy+0x78><== NOT EXECUTED 30009ee0: e1a01004 mov r1, r4 <== NOT EXECUTED 30009ee4: eb000818 bl 3000bf4c <_Objects_Free> <== NOT EXECUTED
_POSIX_Spinlock_Free( the_spinlock );
_Thread_Enable_dispatch();
30009ee8: eb000ba7 bl 3000cd8c <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009eec: e1a00005 mov r0, r5 <== NOT EXECUTED 30009ef0: eaffffee b 30009eb0 <pthread_spin_destroy+0x34> <== NOT EXECUTED
30009ef8 <pthread_spin_init>:
int pthread_spin_init(
pthread_spinlock_t *spinlock,
int pshared
)
{
30009ef8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock;
CORE_spinlock_Attributes attributes;
if ( !spinlock )
30009efc: e2506000 subs r6, r0, #0 <== NOT EXECUTED
int pthread_spin_init(
pthread_spinlock_t *spinlock,
int pshared
)
{
30009f00: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30009f04: e1a04001 mov r4, r1 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock;
CORE_spinlock_Attributes attributes;
if ( !spinlock )
30009f08: 0a000018 beq 30009f70 <pthread_spin_init+0x78> <== NOT EXECUTED
return EINVAL;
switch ( pshared ) {
30009f0c: e3510000 cmp r1, #0 <== NOT EXECUTED 30009f10: 1a000016 bne 30009f70 <pthread_spin_init+0x78> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009f14: e59f306c ldr r3, [pc, #108] ; 30009f88 <pthread_spin_init+0x90><== NOT EXECUTED 30009f18: e5932000 ldr r2, [r3] <== NOT EXECUTED 30009f1c: e2822001 add r2, r2, #1 <== NOT EXECUTED 30009f20: 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 );
30009f24: e59f7060 ldr r7, [pc, #96] ; 30009f8c <pthread_spin_init+0x94><== NOT EXECUTED 30009f28: e1a00007 mov r0, r7 <== NOT EXECUTED 30009f2c: eb00072c bl 3000bbe4 <_Objects_Allocate> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_spinlock = _POSIX_Spinlock_Allocate();
if ( !the_spinlock ) {
30009f30: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30009f34: 0a000010 beq 30009f7c <pthread_spin_init+0x84> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _CORE_spinlock_Initialize_attributes(
CORE_spinlock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
30009f38: e28d1004 add r1, sp, #4 <== NOT EXECUTED
return EAGAIN;
}
_CORE_spinlock_Initialize_attributes( &attributes );
_CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes );
30009f3c: e2850010 add r0, r5, #16 <== NOT EXECUTED 30009f40: e5214004 str r4, [r1, #-4]! <== NOT EXECUTED 30009f44: e1a0100d mov r1, sp <== NOT EXECUTED 30009f48: eb000566 bl 3000b4e8 <_CORE_spinlock_Initialize> <== NOT EXECUTED
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30009f4c: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009f50: e597201c ldr r2, [r7, #28] <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
30009f54: e1a01803 lsl r1, r3, #16 <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009f58: e7825721 str r5, [r2, r1, lsr #14] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
30009f5c: e585400c str r4, [r5, #12] <== NOT EXECUTED
_Objects_Open_u32( &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 );
*spinlock = the_spinlock->Object.id;
30009f60: e5863000 str r3, [r6] <== NOT EXECUTED
_Thread_Enable_dispatch();
30009f64: eb000b88 bl 3000cd8c <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009f68: e1a00004 mov r0, r4 <== NOT EXECUTED 30009f6c: ea000000 b 30009f74 <pthread_spin_init+0x7c> <== NOT EXECUTED
switch ( pshared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
30009f70: e3a00016 mov r0, #22 <== NOT EXECUTED
*spinlock = the_spinlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
30009f74: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30009f78: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_spinlock = _POSIX_Spinlock_Allocate();
if ( !the_spinlock ) {
_Thread_Enable_dispatch();
30009f7c: eb000b82 bl 3000cd8c <_Thread_Enable_dispatch> <== NOT EXECUTED
return EAGAIN;
30009f80: e3a0000b mov r0, #11 <== NOT EXECUTED 30009f84: eafffffa b 30009f74 <pthread_spin_init+0x7c> <== NOT EXECUTED
30009f90 <pthread_spin_lock>:
*/
int pthread_spin_lock(
pthread_spinlock_t *spinlock
)
{
30009f90: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
30009f94: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_lock(
pthread_spinlock_t *spinlock
)
{
30009f98: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
30009f9c: 0a000006 beq 30009fbc <pthread_spin_lock+0x2c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get (
pthread_spinlock_t *spinlock,
Objects_Locations *location
)
{
return (POSIX_Spinlock_Control *) _Objects_Get(
30009fa0: e1a0200d mov r2, sp <== NOT EXECUTED 30009fa4: e59f003c ldr r0, [pc, #60] ; 30009fe8 <pthread_spin_lock+0x58><== NOT EXECUTED 30009fa8: e5931000 ldr r1, [r3] <== NOT EXECUTED 30009fac: eb00083d bl 3000c0a8 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
30009fb0: e59d2000 ldr r2, [sp] <== NOT EXECUTED 30009fb4: e3520000 cmp r2, #0 <== NOT EXECUTED 30009fb8: 0a000002 beq 30009fc8 <pthread_spin_lock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
30009fbc: e3a00016 mov r0, #22 <== NOT EXECUTED
}
30009fc0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30009fc4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, true, 0 );
30009fc8: e3a01001 mov r1, #1 <== NOT EXECUTED 30009fcc: e2800010 add r0, r0, #16 <== NOT EXECUTED 30009fd0: eb000567 bl 3000b574 <_CORE_spinlock_Wait> <== NOT EXECUTED 30009fd4: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
30009fd8: eb000b6b bl 3000cd8c <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
30009fdc: e1a00004 mov r0, r4 <== NOT EXECUTED 30009fe0: eb000001 bl 30009fec <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 30009fe4: eafffff5 b 30009fc0 <pthread_spin_lock+0x30> <== NOT EXECUTED
30009ffc <pthread_spin_trylock>:
*/
int pthread_spin_trylock(
pthread_spinlock_t *spinlock
)
{
30009ffc: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000a000: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_trylock(
pthread_spinlock_t *spinlock
)
{
3000a004: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000a008: 0a000006 beq 3000a028 <pthread_spin_trylock+0x2c> <== NOT EXECUTED 3000a00c: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a010: e59f003c ldr r0, [pc, #60] ; 3000a054 <pthread_spin_trylock+0x58><== NOT EXECUTED 3000a014: e1a0200d mov r2, sp <== NOT EXECUTED 3000a018: eb000822 bl 3000c0a8 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000a01c: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000a020: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a024: 0a000002 beq 3000a034 <pthread_spin_trylock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a028: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a02c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a030: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, false, 0 );
3000a034: e1a02001 mov r2, r1 <== NOT EXECUTED 3000a038: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000a03c: eb00054c bl 3000b574 <_CORE_spinlock_Wait> <== NOT EXECUTED 3000a040: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a044: eb000b50 bl 3000cd8c <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
3000a048: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a04c: ebffffe6 bl 30009fec <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 3000a050: eafffff5 b 3000a02c <pthread_spin_trylock+0x30> <== NOT EXECUTED
3000a058 <pthread_spin_unlock>:
*/
int pthread_spin_unlock(
pthread_spinlock_t *spinlock
)
{
3000a058: e92d4010 push {r4, lr} <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000a05c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
*/
int pthread_spin_unlock(
pthread_spinlock_t *spinlock
)
{
3000a060: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
POSIX_Spinlock_Control *the_spinlock = NULL;
Objects_Locations location;
CORE_spinlock_Status status;
if ( !spinlock )
3000a064: 0a000006 beq 3000a084 <pthread_spin_unlock+0x2c> <== NOT EXECUTED 3000a068: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a06c: e59f0038 ldr r0, [pc, #56] ; 3000a0ac <pthread_spin_unlock+0x54><== NOT EXECUTED 3000a070: e1a0200d mov r2, sp <== NOT EXECUTED 3000a074: eb00080b bl 3000c0a8 <_Objects_Get> <== NOT EXECUTED
return EINVAL;
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
3000a078: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a07c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a080: 0a000002 beq 3000a090 <pthread_spin_unlock+0x38> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
3000a084: e3a00016 mov r0, #22 <== NOT EXECUTED
}
3000a088: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a08c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_spinlock = _POSIX_Spinlock_Get( spinlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_spinlock_Release( &the_spinlock->Spinlock );
3000a090: e2800010 add r0, r0, #16 <== NOT EXECUTED 3000a094: eb00051a bl 3000b504 <_CORE_spinlock_Release> <== NOT EXECUTED 3000a098: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000a09c: eb000b3a bl 3000cd8c <_Thread_Enable_dispatch> <== NOT EXECUTED
return _POSIX_Spinlock_Translate_core_spinlock_return_code( status );
3000a0a0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a0a4: ebffffd0 bl 30009fec <_POSIX_Spinlock_Translate_core_spinlock_return_code><== NOT EXECUTED 3000a0a8: eafffff6 b 3000a088 <pthread_spin_unlock+0x30> <== NOT EXECUTED
3000a188 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
3000a188: 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() )
3000a18c: e59f4054 ldr r4, [pc, #84] ; 3000a1e8 <pthread_testcancel+0x60><== NOT EXECUTED
3000a190: e5943000 ldr r3, [r4] <== NOT EXECUTED
3000a194: e3530000 cmp r3, #0 <== NOT EXECUTED
3000a198: 18bd8010 popne {r4, pc} <== NOT EXECUTED
3000a19c: e59f3048 ldr r3, [pc, #72] ; 3000a1ec <pthread_testcancel+0x64><== NOT EXECUTED
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000a1a0: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000a1a4: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000a1a8: e59220fc ldr r2, [r2, #252] ; 0xfc <== NOT EXECUTED 3000a1ac: e2811001 add r1, r1, #1 <== NOT EXECUTED 3000a1b0: e5831000 str r1, [r3] <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
3000a1b4: e59230d8 ldr r3, [r2, #216] ; 0xd8 <== NOT EXECUTED 3000a1b8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a1bc: 1a000007 bne 3000a1e0 <pthread_testcancel+0x58> <== NOT EXECUTED 3000a1c0: e59230e0 ldr r3, [r2, #224] ; 0xe0 <== NOT EXECUTED 3000a1c4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a1c8: 0a000004 beq 3000a1e0 <pthread_testcancel+0x58> <== NOT EXECUTED
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
3000a1cc: eb000abd bl 3000ccc8 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
3000a1d0: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 3000a1d4: e3e01000 mvn r1, #0 <== NOT EXECUTED
}
3000a1d8: e8bd4010 pop {r4, lr} <== NOT EXECUTED
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
3000a1dc: ea0017ff b 300101e0 <_POSIX_Thread_Exit> <== NOT EXECUTED
}
3000a1e0: e8bd4010 pop {r4, lr} <== NOT EXECUTED
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
3000a1e4: ea000ab7 b 3000ccc8 <_Thread_Enable_dispatch> <== NOT EXECUTED
300178f0 <read>:
)
{
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300178f0: e59f30a4 ldr r3, [pc, #164] ; 3001799c <read+0xac>
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
300178f4: e92d4010 push {r4, lr}
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300178f8: e5933000 ldr r3, [r3] 300178fc: e1500003 cmp r0, r3
30017900: 2a00001b bcs 30017974 <read+0x84> iop = rtems_libio_iop( fd );
30017904: e59f4094 ldr r4, [pc, #148] ; 300179a0 <read+0xb0> 30017908: e0600180 rsb r0, r0, r0, lsl #3 3001790c: e5944000 ldr r4, [r4] 30017910: e0844180 add r4, r4, r0, lsl #3
rtems_libio_check_is_open( iop );
30017914: e5940014 ldr r0, [r4, #20] 30017918: e3100c01 tst r0, #256 ; 0x100
3001791c: 0a000014 beq 30017974 <read+0x84> rtems_libio_check_buffer( buffer );
30017920: e3510000 cmp r1, #0
30017924: 0a000017 beq 30017988 <read+0x98> rtems_libio_check_count( count );
30017928: e3520000 cmp r2, #0
3001792c: 0a00000e beq 3001796c <read+0x7c> rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30017930: e3100002 tst r0, #2
30017934: 0a000013 beq 30017988 <read+0x98>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
30017938: e5943020 ldr r3, [r4, #32] 3001793c: e1a00004 mov r0, r4 30017940: e1a0e00f mov lr, pc 30017944: e593f008 ldr pc, [r3, #8]
if ( rc > 0 )
30017948: e3500000 cmp r0, #0
3001794c: d8bd8010 pople {r4, pc}
iop->offset += rc;
30017950: e284300c add r3, r4, #12
30017954: e893000c ldm r3, {r2, r3}
30017958: e0922000 adds r2, r2, r0
3001795c: e0a33fc0 adc r3, r3, r0, asr #31
30017960: e584200c str r2, [r4, #12]
30017964: e5843010 str r3, [r4, #16]
30017968: e8bd8010 pop {r4, pc}
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
3001796c: e1a00002 mov r0, r2 <== NOT EXECUTED
if ( rc > 0 )
iop->offset += rc;
return rc;
}
30017970: e8bd8010 pop {r4, pc} <== NOT EXECUTED
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
30017974: ebffe9be bl 30012074 <__errno> <== NOT EXECUTED
30017978: e3a03009 mov r3, #9 <== NOT EXECUTED
3001797c: e5803000 str r3, [r0] <== NOT EXECUTED
30017980: e3e00000 mvn r0, #0 <== NOT EXECUTED
30017984: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30017988: ebffe9b9 bl 30012074 <__errno> <== NOT EXECUTED
3001798c: e3a03016 mov r3, #22 <== NOT EXECUTED
30017990: e5803000 str r3, [r0] <== NOT EXECUTED
30017994: e3e00000 mvn r0, #0 <== NOT EXECUTED
30017998: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30009ca8 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
30009ca8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
30009cac: e2516000 subs r6, r1, #0 <== NOT EXECUTED
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
30009cb0: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 30009cb4: e1a07000 mov r7, r0 <== NOT EXECUTED 30009cb8: e1a05002 mov r5, r2 <== NOT EXECUTED
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
30009cbc: 0a00001d beq 30009d38 <readlink+0x90> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
30009cc0: eb003507 bl 300170e4 <strlen> <== NOT EXECUTED 30009cc4: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30009cc8: e1a01000 mov r1, r0 <== NOT EXECUTED 30009ccc: e3a02000 mov r2, #0 <== NOT EXECUTED 30009cd0: e1a00007 mov r0, r7 <== NOT EXECUTED 30009cd4: e1a03004 mov r3, r4 <== NOT EXECUTED 30009cd8: e58d2000 str r2, [sp] <== NOT EXECUTED 30009cdc: ebfffb6e bl 30008a9c <rtems_filesystem_evaluate_path> <== NOT EXECUTED
0, &loc, false );
if ( result != 0 )
30009ce0: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30009ce4: 13e00000 mvnne r0, #0 <== NOT EXECUTED
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
30009ce8: 0a000001 beq 30009cf4 <readlink+0x4c> <== NOT EXECUTED
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
rtems_filesystem_freenode( &loc );
return result;
}
30009cec: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30009cf0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
30009cf4: e1a00004 mov r0, r4 <== NOT EXECUTED 30009cf8: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30009cfc: e1a0e00f mov lr, pc <== NOT EXECUTED 30009d00: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED 30009d04: e3500004 cmp r0, #4 <== NOT EXECUTED 30009d08: 1a00000f bne 30009d4c <readlink+0xa4> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( EINVAL );
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
30009d0c: e1a02005 mov r2, r5 <== NOT EXECUTED 30009d10: e1a01006 mov r1, r6 <== NOT EXECUTED 30009d14: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30009d18: e1a00004 mov r0, r4 <== NOT EXECUTED 30009d1c: e1a0e00f mov lr, pc <== NOT EXECUTED 30009d20: e593f03c ldr pc, [r3, #60] ; 0x3c <== NOT EXECUTED 30009d24: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30009d28: e1a00004 mov r0, r4 <== NOT EXECUTED 30009d2c: ebfffb94 bl 30008b84 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
30009d30: e1a00005 mov r0, r5 <== NOT EXECUTED 30009d34: eaffffec b 30009cec <readlink+0x44> <== NOT EXECUTED
{
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
30009d38: eb002d9e bl 300153b8 <__errno> <== NOT EXECUTED 30009d3c: e3a0300e mov r3, #14 <== NOT EXECUTED 30009d40: e5803000 str r3, [r0] <== NOT EXECUTED 30009d44: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009d48: eaffffe7 b 30009cec <readlink+0x44> <== NOT EXECUTED
0, &loc, false );
if ( result != 0 )
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
rtems_filesystem_freenode( &loc );
30009d4c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009d50: ebfffb8b bl 30008b84 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009d54: eb002d97 bl 300153b8 <__errno> <== NOT EXECUTED 30009d58: e3a03016 mov r3, #22 <== NOT EXECUTED 30009d5c: e5803000 str r3, [r0] <== NOT EXECUTED 30009d60: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009d64: eaffffe0 b 30009cec <readlink+0x44> <== NOT EXECUTED
300085c0 <readv>:
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
300085c0: e59f313c ldr r3, [pc, #316] ; 30008704 <readv+0x144> <== NOT EXECUTED
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
300085c4: 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 );
300085c8: e5933000 ldr r3, [r3] <== NOT EXECUTED
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
300085cc: e1a04002 mov r4, r2 <== NOT EXECUTED
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
300085d0: e1500003 cmp r0, r3 <== NOT EXECUTED 300085d4: 2a000045 bcs 300086f0 <readv+0x130> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
300085d8: e59f3128 ldr r3, [pc, #296] ; 30008708 <readv+0x148> <== NOT EXECUTED 300085dc: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 300085e0: e5933000 ldr r3, [r3] <== NOT EXECUTED 300085e4: e0836180 add r6, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
300085e8: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 300085ec: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300085f0: 0a00003e beq 300086f0 <readv+0x130> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
300085f4: e3130002 tst r3, #2 <== NOT EXECUTED 300085f8: 0a000036 beq 300086d8 <readv+0x118> <== NOT EXECUTED
/*
* Argument validation on IO vector
*/
if ( !iov )
300085fc: e3510000 cmp r1, #0 <== NOT EXECUTED 30008600: 0a000034 beq 300086d8 <readv+0x118> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
30008604: e3520000 cmp r2, #0 <== NOT EXECUTED 30008608: da000032 ble 300086d8 <readv+0x118> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
3000860c: e3520b01 cmp r2, #1024 ; 0x400 <== NOT EXECUTED 30008610: ca000030 bgt 300086d8 <readv+0x118> <== NOT EXECUTED 30008614: e3a02000 mov r2, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30008618: 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 )
3000861c: e1a03001 mov r3, r1 <== NOT EXECUTED 30008620: e3a07001 mov r7, #1 <== NOT EXECUTED 30008624: e1a01002 mov r1, r2 <== NOT EXECUTED 30008628: ea000000 b 30008630 <readv+0x70> <== 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;
3000862c: 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 )
30008630: e5930000 ldr r0, [r3] <== 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++ ) {
30008634: e2822001 add r2, r2, #1 <== 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 )
30008638: e3500000 cmp r0, #0 <== NOT EXECUTED 3000863c: 0a000025 beq 300086d8 <readv+0x118> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
30008640: e5930004 ldr r0, [r3, #4] <== 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++ ) {
30008644: e2833008 add r3, r3, #8 <== 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;
30008648: e081c000 add ip, r1, r0 <== NOT EXECUTED
if ( total < old )
3000864c: e151000c cmp r1, ip <== NOT EXECUTED 30008650: ca000020 bgt 300086d8 <readv+0x118> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
30008654: e3500000 cmp r0, #0 <== NOT EXECUTED 30008658: 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++ ) {
3000865c: e1540002 cmp r4, r2 <== NOT EXECUTED 30008660: cafffff1 bgt 3000862c <readv+0x6c> <== 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 ) {
30008664: e3570000 cmp r7, #0 <== NOT EXECUTED
return 0;
30008668: 13a08000 movne r8, #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 ) {
3000866c: 1a00001d bne 300086e8 <readv+0x128> <== NOT EXECUTED 30008670: e1a08007 mov r8, r7 <== NOT EXECUTED 30008674: ea00000d b 300086b0 <readv+0xf0> <== NOT EXECUTED
);
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
30008678: 0a000006 beq 30008698 <readv+0xd8> <== NOT EXECUTED
iop->offset += bytes;
3000867c: e286300c add r3, r6, #12 <== NOT EXECUTED
30008680: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30008684: e0922000 adds r2, r2, r0 <== NOT EXECUTED
30008688: e0a33fc0 adc r3, r3, r0, asr #31 <== NOT EXECUTED
3000868c: e586200c str r2, [r6, #12] <== NOT EXECUTED
30008690: e5863010 str r3, [r6, #16] <== NOT EXECUTED
total += bytes;
30008694: e0888000 add r8, r8, r0 <== NOT EXECUTED
}
if (bytes != iov[ v ].iov_len)
30008698: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3000869c: e2855008 add r5, r5, #8 <== NOT EXECUTED
if ( bytes > 0 ) {
iop->offset += bytes;
total += bytes;
}
if (bytes != iov[ v ].iov_len)
300086a0: e1500003 cmp r0, r3 <== NOT EXECUTED 300086a4: 1a00000f bne 300086e8 <readv+0x128> <== NOT EXECUTED
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
300086a8: e1540007 cmp r4, r7 <== NOT EXECUTED 300086ac: da00000d ble 300086e8 <readv+0x128> <== NOT EXECUTED
bytes = (*iop->pathinfo.handlers->read_h)(
300086b0: e8950006 ldm r5, {r1, r2} <== NOT EXECUTED
300086b4: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED
300086b8: e1a00006 mov r0, r6 <== NOT EXECUTED
300086bc: e1a0e00f mov lr, pc <== NOT EXECUTED
300086c0: e593f008 ldr pc, [r3, #8] <== NOT EXECUTED
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
300086c4: e3500000 cmp r0, #0 <== NOT EXECUTED
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
300086c8: e2877001 add r7, r7, #1 <== NOT EXECUTED
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
300086cc: aaffffe9 bge 30008678 <readv+0xb8> <== NOT EXECUTED
return -1;
300086d0: e3e08000 mvn r8, #0 <== NOT EXECUTED 300086d4: ea000003 b 300086e8 <readv+0x128> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
300086d8: eb002a8f bl 3001311c <__errno> <== NOT EXECUTED 300086dc: e3a03016 mov r3, #22 <== NOT EXECUTED 300086e0: e5803000 str r3, [r0] <== NOT EXECUTED 300086e4: e3e08000 mvn r8, #0 <== NOT EXECUTED
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
300086e8: e1a00008 mov r0, r8 <== NOT EXECUTED
300086ec: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
300086f0: eb002a89 bl 3001311c <__errno> <== NOT EXECUTED 300086f4: e3a03009 mov r3, #9 <== NOT EXECUTED 300086f8: e5803000 str r3, [r0] <== NOT EXECUTED 300086fc: e3e08000 mvn r8, #0 <== NOT EXECUTED 30008700: eafffff8 b 300086e8 <readv+0x128> <== NOT EXECUTED
30017a08 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
30017a08: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30017a0c: e59f2118 ldr r2, [pc, #280] ; 30017b2c <realloc+0x124>
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30017a10: e59f5118 ldr r5, [pc, #280] ; 30017b30 <realloc+0x128>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30017a14: e5922000 ldr r2, [r2]
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30017a18: e5953010 ldr r3, [r5, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30017a1c: e3520003 cmp r2, #3
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30017a20: e2833001 add r3, r3, #1
void *realloc(
void *ptr,
size_t size
)
{
30017a24: e24dd004 sub sp, sp, #4 30017a28: e1a04000 mov r4, r0 30017a2c: e1a06001 mov r6, r1
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30017a30: e5853010 str r3, [r5, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30017a34: 0a000020 beq 30017abc <realloc+0xb4>
}
/*
* Continue with realloc().
*/
if ( !ptr )
30017a38: e3540000 cmp r4, #0
30017a3c: 0a00001a beq 30017aac <realloc+0xa4>
return malloc( size );
if ( !size ) {
30017a40: e3560000 cmp r6, #0
30017a44: 0a00000f beq 30017a88 <realloc+0x80>
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
30017a48: e59f70e4 ldr r7, [pc, #228] ; 30017b34 <realloc+0x12c> 30017a4c: e1a01004 mov r1, r4 30017a50: e5970000 ldr r0, [r7] 30017a54: e1a0200d mov r2, sp 30017a58: eb000065 bl 30017bf4 <_Protected_heap_Get_block_size> 30017a5c: e2508000 subs r8, r0, #0
30017a60: 0a00000c beq 30017a98 <realloc+0x90>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
30017a64: e5970000 ldr r0, [r7] 30017a68: e1a01004 mov r1, r4 30017a6c: e1a02006 mov r2, r6 30017a70: eb000070 bl 30017c38 <_Protected_heap_Resize_block> 30017a74: e3500000 cmp r0, #0
30017a78: 0a00001a beq 30017ae8 <realloc+0xe0>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
30017a7c: e1a00004 mov r0, r4
30017a80: e28dd004 add sp, sp, #4
30017a84: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
30017a88: e1a00004 mov r0, r4 <== NOT EXECUTED 30017a8c: ebffba81 bl 30006498 <free> <== NOT EXECUTED
return (void *) 0;
30017a90: e1a04006 mov r4, r6 <== NOT EXECUTED 30017a94: eafffff8 b 30017a7c <realloc+0x74> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
30017a98: ebffe975 bl 30012074 <__errno> <== NOT EXECUTED 30017a9c: e3a03016 mov r3, #22 <== NOT EXECUTED 30017aa0: e5803000 str r3, [r0] <== NOT EXECUTED
return (void *) 0;
30017aa4: e1a04008 mov r4, r8 <== NOT EXECUTED 30017aa8: eafffff3 b 30017a7c <realloc+0x74> <== NOT EXECUTED
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
30017aac: e1a00006 mov r0, r6 30017ab0: ebffbb52 bl 30006800 <malloc> 30017ab4: e1a04000 mov r4, r0 30017ab8: eaffffef b 30017a7c <realloc+0x74>
/*
* 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)
30017abc: e59f3074 ldr r3, [pc, #116] ; 30017b38 <realloc+0x130> 30017ac0: e5933000 ldr r3, [r3] 30017ac4: e3530000 cmp r3, #0
return (void *) 0;
30017ac8: 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)
30017acc: 1affffea bne 30017a7c <realloc+0x74>
return (void *) 0;
if (_ISR_Nest_level > 0)
30017ad0: e59f2064 ldr r2, [pc, #100] ; 30017b3c <realloc+0x134> 30017ad4: e5922000 ldr r2, [r2] 30017ad8: e3520000 cmp r2, #0
return (void *) 0;
30017adc: 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)
30017ae0: 0affffd4 beq 30017a38 <realloc+0x30>
30017ae4: eaffffe4 b 30017a7c <realloc+0x74> <== NOT EXECUTED
* 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 );
30017ae8: e1a00006 mov r0, r6 30017aec: ebffbb43 bl 30006800 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
30017af0: e5953004 ldr r3, [r5, #4]
if ( !new_area ) {
30017af4: e2507000 subs r7, r0, #0
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
30017af8: e2433001 sub r3, r3, #1 30017afc: e5853004 str r3, [r5, #4]
if ( !new_area ) {
return (void *) 0;
30017b00: 01a04007 moveq r4, r7
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
30017b04: 0affffdc beq 30017a7c <realloc+0x74>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
30017b08: e59d2000 ldr r2, [sp] <== NOT EXECUTED 30017b0c: e1a01004 mov r1, r4 <== NOT EXECUTED 30017b10: e1560002 cmp r6, r2 <== NOT EXECUTED 30017b14: 31a02006 movcc r2, r6 <== NOT EXECUTED 30017b18: ebffeb83 bl 3001292c <memcpy> <== NOT EXECUTED
free( ptr );
30017b1c: e1a00004 mov r0, r4 <== NOT EXECUTED 30017b20: ebffba5c bl 30006498 <free> <== NOT EXECUTED
return new_area;
30017b24: e1a04007 mov r4, r7 <== NOT EXECUTED 30017b28: eaffffd3 b 30017a7c <realloc+0x74> <== NOT EXECUTED
30007820 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
30007820: e92d40f0 push {r4, r5, r6, r7, lr}
30007824: e24dd030 sub sp, sp, #48 ; 0x30
30007828: e1a07000 mov r7, r0
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
3000782c: ebfffc2c bl 300068e4 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
30007830: e2505000 subs r5, r0, #0
30007834: 1a000045 bne 30007950 <rmdir+0x130>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
30007838: e28d4018 add r4, sp, #24 <== NOT EXECUTED 3000783c: e1a00007 mov r0, r7 <== NOT EXECUTED 30007840: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 30007844: e1a02004 mov r2, r4 <== NOT EXECUTED 30007848: eb00004c bl 30007980 <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;
3000784c: e1a06005 mov r6, r5 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30007850: e28dc004 add ip, sp, #4
30007854: e1a0e004 mov lr, r4
30007858: e8be000f ldm lr!, {r0, r1, r2, r3}
3000785c: e8ac000f stmia ip!, {r0, r1, r2, r3}
name = pathname + parentpathlen;
30007860: e0875005 add r5, r7, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30007864: e59e3000 ldr r3, [lr]
name = pathname + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
30007868: e1a00005 mov r0, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
3000786c: e58c3000 str r3, [ip]
name = pathname + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
30007870: eb002fee bl 30013830 <strlen> 30007874: e1a01000 mov r1, r0 30007878: e1a00005 mov r0, r5 3000787c: ebfffc27 bl 30006920 <rtems_filesystem_prefix_separators> 30007880: e0857000 add r7, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
30007884: e1a00007 mov r0, r7 30007888: eb002fe8 bl 30013830 <strlen> 3000788c: e28d5004 add r5, sp, #4 30007890: e1a01000 mov r1, r0 30007894: e3a02000 mov r2, #0 30007898: e1a00007 mov r0, r7 3000789c: e1a03005 mov r3, r5 300078a0: e58d2000 str r2, [sp] 300078a4: ebfffbdc bl 3000681c <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
300078a8: e3500000 cmp r0, #0
300078ac: 1a000015 bne 30007908 <rmdir+0xe8>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
300078b0: e1a00005 mov r0, r5 300078b4: e59d3010 ldr r3, [sp, #16] 300078b8: e1a0e00f mov lr, pc 300078bc: e593f010 ldr pc, [r3, #16] 300078c0: e3500001 cmp r0, #1
300078c4: 1a000013 bne 30007918 <rmdir+0xf8>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
300078c8: e1a01005 mov r1, r5 300078cc: e59d300c ldr r3, [sp, #12] 300078d0: e1a00004 mov r0, r4 300078d4: e1a0e00f mov lr, pc 300078d8: e593f034 ldr pc, [r3, #52] ; 0x34 300078dc: e1a07000 mov r7, r0
rtems_filesystem_freenode( &loc );
300078e0: e1a00005 mov r0, r5 300078e4: ebfffc22 bl 30006974 <rtems_filesystem_freenode>
if ( free_parentloc )
300078e8: e3560000 cmp r6, #0
300078ec: 1a000002 bne 300078fc <rmdir+0xdc>
rtems_filesystem_freenode( &parentloc );
return result;
}
300078f0: e1a00007 mov r0, r7
300078f4: e28dd030 add sp, sp, #48 ; 0x30
300078f8: e8bd80f0 pop {r4, r5, r6, r7, pc}
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
300078fc: e1a00004 mov r0, r4 30007900: ebfffc1b bl 30006974 <rtems_filesystem_freenode> 30007904: eafffff9 b 300078f0 <rmdir+0xd0>
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
30007908: e3560000 cmp r6, #0 <== NOT EXECUTED 3000790c: 1a00000b bne 30007940 <rmdir+0x120> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
return -1;
30007910: e3e07000 mvn r7, #0 <== NOT EXECUTED 30007914: eafffff5 b 300078f0 <rmdir+0xd0> <== NOT EXECUTED
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
30007918: e1a00005 mov r0, r5 <== NOT EXECUTED 3000791c: ebfffc14 bl 30006974 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_parentloc )
30007920: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
30007924: 11a00004 movne r0, r4 <== NOT EXECUTED 30007928: 1bfffc11 blne 30006974 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000792c: eb002c00 bl 30012934 <__errno> <== NOT EXECUTED 30007930: e3a03014 mov r3, #20 <== NOT EXECUTED 30007934: e5803000 str r3, [r0] <== NOT EXECUTED 30007938: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000793c: eaffffeb b 300078f0 <rmdir+0xd0> <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
30007940: e1a00004 mov r0, r4 <== NOT EXECUTED 30007944: ebfffc0a bl 30006974 <rtems_filesystem_freenode> <== NOT EXECUTED
return -1;
30007948: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000794c: eaffffe7 b 300078f0 <rmdir+0xd0> <== 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,
30007950: e3a03000 mov r3, #0 30007954: e28d4018 add r4, sp, #24 30007958: e58d3000 str r3, [sp] 3000795c: e3a02002 mov r2, #2 30007960: e1a00007 mov r0, r7 30007964: e1a01005 mov r1, r5 30007968: e1a03004 mov r3, r4 3000796c: ebfffbc6 bl 3000688c <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
30007970: e3500000 cmp r0, #0
30007974: 1affffe5 bne 30007910 <rmdir+0xf0>
return -1;
free_parentloc = true;
30007978: e3a06001 mov r6, #1 3000797c: eaffffb3 b 30007850 <rmdir+0x30>
3000ae40 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
3000ae40: e92d41f0 push {r4, r5, r6, r7, r8, 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);
3000ae44: e59f41c4 ldr r4, [pc, #452] ; 3000b010 <rtems_aio_enqueue+0x1d0><== NOT EXECUTED
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
3000ae48: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED 3000ae4c: 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);
3000ae50: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ae54: eb000255 bl 3000b7b0 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0) {
3000ae58: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000ae5c: 1a00002a bne 3000af0c <rtems_aio_enqueue+0xcc> <== NOT EXECUTED
return result;
}
/* _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);
3000ae60: eb000481 bl 3000c06c <pthread_self> <== NOT EXECUTED 3000ae64: e28d101c add r1, sp, #28 <== NOT EXECUTED 3000ae68: e1a0200d mov r2, sp <== NOT EXECUTED 3000ae6c: eb00037e bl 3000bc6c <pthread_getschedparam> <== NOT EXECUTED
req->caller_thread = pthread_self ();
3000ae70: eb00047d bl 3000c06c <pthread_self> <== NOT EXECUTED
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
3000ae74: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 3000ae78: e59dc000 ldr ip, [sp] <== NOT EXECUTED 3000ae7c: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
3000ae80: e5941068 ldr r1, [r4, #104] ; 0x68 <== 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 ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
3000ae84: e062200c rsb r2, r2, ip <== NOT EXECUTED 3000ae88: e586200c str r2, [r6, #12] <== NOT EXECUTED
req->policy = policy;
3000ae8c: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
3000ae90: e3510000 cmp r1, #0 <== NOT EXECUTED
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
3000ae94: e5862008 str r2, [r6, #8] <== NOT EXECUTED
req->aiocbp->error_code = EINPROGRESS;
3000ae98: e3a02077 mov r2, #119 ; 0x77 <== 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 ();
3000ae9c: e5860010 str r0, [r6, #16] <== NOT EXECUTED
req->priority = param.sched_priority - req->aiocbp->aio_reqprio; req->policy = policy; req->aiocbp->error_code = EINPROGRESS;
3000aea0: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = 0;
3000aea4: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
3000aea8: 1a000002 bne 3000aeb8 <rtems_aio_enqueue+0x78> <== NOT EXECUTED 3000aeac: e5942064 ldr r2, [r4, #100] ; 0x64 <== NOT EXECUTED 3000aeb0: e3520004 cmp r2, #4 <== NOT EXECUTED 3000aeb4: da000017 ble 3000af18 <rtems_aio_enqueue+0xd8> <== 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,
3000aeb8: e59f0154 ldr r0, [pc, #340] ; 3000b014 <rtems_aio_enqueue+0x1d4><== NOT EXECUTED 3000aebc: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000aec0: e3a02000 mov r2, #0 <== NOT EXECUTED 3000aec4: ebfffeac bl 3000a97c <rtems_aio_search_fd> <== NOT EXECUTED
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
3000aec8: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000aecc: 0a00002e beq 3000af8c <rtems_aio_enqueue+0x14c> <== NOT EXECUTED
{
pthread_mutex_lock (&r_chain->mutex);
3000aed0: e287401c add r4, r7, #28 <== NOT EXECUTED 3000aed4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aed8: eb000234 bl 3000b7b0 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
3000aedc: e2870008 add r0, r7, #8 <== NOT EXECUTED 3000aee0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000aee4: ebffff8c bl 3000ad1c <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
3000aee8: e2870020 add r0, r7, #32 <== NOT EXECUTED 3000aeec: eb000119 bl 3000b358 <pthread_cond_signal> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
3000aef0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aef4: eb00024e bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
3000aef8: e59f0110 ldr r0, [pc, #272] ; 3000b010 <rtems_aio_enqueue+0x1d0><== NOT EXECUTED 3000aefc: eb00024c bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
return 0; }
3000af00: e1a00005 mov r0, r5 <== NOT EXECUTED
3000af04: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
3000af08: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
if (result != 0) {
free (req);
3000af0c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000af10: ebfff0ac bl 300071c8 <free> <== NOT EXECUTED
return result;
3000af14: eafffff9 b 3000af00 <rtems_aio_enqueue+0xc0> <== 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);
3000af18: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000af1c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000af20: e3a02001 mov r2, #1 <== NOT EXECUTED 3000af24: ebfffe94 bl 3000a97c <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000af28: 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);
3000af2c: e1a07000 mov r7, r0 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000af30: e3530001 cmp r3, #1 <== NOT EXECUTED 3000af34: 1affffe5 bne 3000aed0 <rtems_aio_enqueue+0x90> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
3000af38: e1a01006 mov r1, r6 <== NOT EXECUTED 3000af3c: e2800008 add r0, r0, #8 <== NOT EXECUTED 3000af40: eb000897 bl 3000d1a4 <_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);
3000af44: 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;
3000af48: e5875018 str r5, [r7, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
3000af4c: e287001c add r0, r7, #28 <== NOT EXECUTED 3000af50: eb0001c3 bl 3000b664 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
3000af54: e1a01005 mov r1, r5 <== NOT EXECUTED 3000af58: e2870020 add r0, r7, #32 <== NOT EXECUTED 3000af5c: eb0000cd bl 3000b298 <pthread_cond_init> <== NOT EXECUTED
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
3000af60: e28d0020 add r0, sp, #32 <== NOT EXECUTED 3000af64: e2841008 add r1, r4, #8 <== NOT EXECUTED 3000af68: e59f20a8 ldr r2, [pc, #168] ; 3000b018 <rtems_aio_enqueue+0x1d8><== NOT EXECUTED 3000af6c: e1a03007 mov r3, r7 <== NOT EXECUTED 3000af70: eb000295 bl 3000b9cc <pthread_create> <== NOT EXECUTED
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
3000af74: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000af78: 1a000020 bne 3000b000 <rtems_aio_enqueue+0x1c0> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
3000af7c: e5943064 ldr r3, [r4, #100] ; 0x64 <== NOT EXECUTED 3000af80: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000af84: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED 3000af88: eaffffda b 3000aef8 <rtems_aio_enqueue+0xb8> <== 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);
3000af8c: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 3000af90: e59f0084 ldr r0, [pc, #132] ; 3000b01c <rtems_aio_enqueue+0x1dc><== NOT EXECUTED 3000af94: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000af98: e3a02001 mov r2, #1 <== NOT EXECUTED 3000af9c: ebfffe76 bl 3000a97c <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000afa0: 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);
3000afa4: e1a08000 mov r8, r0 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
3000afa8: e3530001 cmp r3, #1 <== NOT EXECUTED 3000afac: 0a000008 beq 3000afd4 <rtems_aio_enqueue+0x194> <== NOT EXECUTED
r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL); pthread_cond_init (&r_chain->cond, NULL); } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
3000afb0: e2800008 add r0, r0, #8 <== NOT EXECUTED 3000afb4: e1a01006 mov r1, r6 <== NOT EXECUTED 3000afb8: ebffff57 bl 3000ad1c <rtems_aio_insert_prio> <== NOT EXECUTED
if (aio_request_queue.idle_threads > 0)
3000afbc: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED 3000afc0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000afc4: daffffcb ble 3000aef8 <rtems_aio_enqueue+0xb8> <== NOT EXECUTED
pthread_cond_signal (&aio_request_queue.new_req);
3000afc8: e59f0050 ldr r0, [pc, #80] ; 3000b020 <rtems_aio_enqueue+0x1e0><== NOT EXECUTED 3000afcc: eb0000e1 bl 3000b358 <pthread_cond_signal> <== NOT EXECUTED 3000afd0: eaffffc8 b 3000aef8 <rtems_aio_enqueue+0xb8> <== NOT EXECUTED 3000afd4: e1a01006 mov r1, r6 <== NOT EXECUTED 3000afd8: e2800008 add r0, r0, #8 <== NOT EXECUTED 3000afdc: eb000870 bl 3000d1a4 <_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);
3000afe0: e1a01007 mov r1, r7 <== 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;
3000afe4: e5887018 str r7, [r8, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
3000afe8: e288001c add r0, r8, #28 <== NOT EXECUTED 3000afec: eb00019c bl 3000b664 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
3000aff0: e2880020 add r0, r8, #32 <== NOT EXECUTED 3000aff4: e1a01007 mov r1, r7 <== NOT EXECUTED 3000aff8: eb0000a6 bl 3000b298 <pthread_cond_init> <== NOT EXECUTED 3000affc: eaffffee b 3000afbc <rtems_aio_enqueue+0x17c> <== NOT EXECUTED
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
3000b000: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b004: eb00020a bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
3000b008: e1a05006 mov r5, r6 <== NOT EXECUTED 3000b00c: eaffffbb b 3000af00 <rtems_aio_enqueue+0xc0> <== NOT EXECUTED
3000aab0 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
3000aab0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3000aab4: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
3000aab8: e1a05000 mov r5, r0 <== NOT EXECUTED
3000aabc: e280601c add r6, r0, #28 <== 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);
3000aac0: e28d8028 add r8, sp, #40 ; 0x28 <== NOT EXECUTED 3000aac4: e28d7004 add r7, sp, #4 <== NOT EXECUTED
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
req->aiocbp->error_code = 0;
3000aac8: e3a09000 mov r9, #0 <== 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);
3000aacc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000aad0: eb000336 bl 3000b7b0 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
3000aad4: e250a000 subs sl, r0, #0 <== NOT EXECUTED 3000aad8: 1a000022 bne 3000ab68 <rtems_aio_handle+0xb8> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000aadc: e5954008 ldr r4, [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 );
3000aae0: 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)) {
3000aae4: e1540003 cmp r4, r3 <== NOT EXECUTED 3000aae8: 0a000039 beq 3000abd4 <rtems_aio_handle+0x124> <== 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);
3000aaec: eb00055e bl 3000c06c <pthread_self> <== NOT EXECUTED 3000aaf0: e1a01008 mov r1, r8 <== NOT EXECUTED 3000aaf4: e1a02007 mov r2, r7 <== NOT EXECUTED 3000aaf8: eb00045b bl 3000bc6c <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
3000aafc: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3000ab00: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
3000ab04: eb000558 bl 3000c06c <pthread_self> <== NOT EXECUTED 3000ab08: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 3000ab0c: e1a02007 mov r2, r7 <== NOT EXECUTED 3000ab10: eb00055a bl 3000c080 <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000ab14: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ab18: eb00098c bl 3000d150 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
3000ab1c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ab20: eb000343 bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
3000ab24: e594a014 ldr sl, [r4, #20] <== NOT EXECUTED 3000ab28: e59a302c ldr r3, [sl, #44] ; 0x2c <== NOT EXECUTED 3000ab2c: e3530002 cmp r3, #2 <== NOT EXECUTED 3000ab30: 0a00001f beq 3000abb4 <rtems_aio_handle+0x104> <== NOT EXECUTED 3000ab34: e3530003 cmp r3, #3 <== NOT EXECUTED 3000ab38: 0a00001a beq 3000aba8 <rtems_aio_handle+0xf8> <== NOT EXECUTED 3000ab3c: e3530001 cmp r3, #1 <== NOT EXECUTED 3000ab40: 0a00000b beq 3000ab74 <rtems_aio_handle+0xc4> <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
3000ab44: e3e01000 mvn r1, #0 <== NOT EXECUTED 3000ab48: e58a1034 str r1, [sl, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = errno;
3000ab4c: eb00286a bl 30014cfc <__errno> <== NOT EXECUTED 3000ab50: e5903000 ldr r3, [r0] <== 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);
3000ab54: e1a00006 mov r0, r6 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
3000ab58: e58a3030 str r3, [sl, #48] ; 0x30 <== 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);
3000ab5c: eb000313 bl 3000b7b0 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
3000ab60: e250a000 subs sl, r0, #0 <== NOT EXECUTED 3000ab64: 0affffdc beq 3000aadc <rtems_aio_handle+0x2c> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000ab68: e3a00000 mov r0, #0 <== NOT EXECUTED
3000ab6c: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
3000ab70: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
3000ab74: e59ac008 ldr ip, [sl, #8] <== NOT EXECUTED 3000ab78: e59a0000 ldr r0, [sl] <== NOT EXECUTED 3000ab7c: e59a100c ldr r1, [sl, #12] <== NOT EXECUTED 3000ab80: e59a2010 ldr r2, [sl, #16] <== NOT EXECUTED 3000ab84: e59a3004 ldr r3, [sl, #4] <== NOT EXECUTED 3000ab88: e58dc000 str ip, [sp] <== NOT EXECUTED 3000ab8c: eb002b5e bl 3001590c <pread> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
3000ab90: e3700001 cmn r0, #1 <== NOT EXECUTED 3000ab94: 0a000056 beq 3000acf4 <rtems_aio_handle+0x244> <== NOT EXECUTED
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
3000ab98: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000ab9c: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = 0;
3000aba0: e5839030 str r9, [r3, #48] ; 0x30 <== NOT EXECUTED 3000aba4: eaffffc8 b 3000aacc <rtems_aio_handle+0x1c> <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
3000aba8: e59a0000 ldr r0, [sl] <== NOT EXECUTED 3000abac: eb001b02 bl 300117bc <fsync> <== NOT EXECUTED
break;
3000abb0: eafffff6 b 3000ab90 <rtems_aio_handle+0xe0> <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
3000abb4: e59ac008 ldr ip, [sl, #8] <== NOT EXECUTED 3000abb8: e59a0000 ldr r0, [sl] <== NOT EXECUTED 3000abbc: e59a100c ldr r1, [sl, #12] <== NOT EXECUTED 3000abc0: e59a2010 ldr r2, [sl, #16] <== NOT EXECUTED 3000abc4: e59a3004 ldr r3, [sl, #4] <== NOT EXECUTED 3000abc8: e58dc000 str ip, [sp] <== NOT EXECUTED 3000abcc: eb002b98 bl 30015a34 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
3000abd0: eaffffee b 3000ab90 <rtems_aio_handle+0xe0> <== 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);
3000abd4: e59fb138 ldr fp, [pc, #312] ; 3000ad14 <rtems_aio_handle+0x264><== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
3000abd8: e1a00006 mov r0, r6 <== NOT EXECUTED 3000abdc: eb000314 bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
3000abe0: e1a0000b mov r0, fp <== NOT EXECUTED 3000abe4: eb0002f1 bl 3000b7b0 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
3000abe8: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000abec: e1540003 cmp r4, r3 <== NOT EXECUTED 3000abf0: 0a000002 beq 3000ac00 <rtems_aio_handle+0x150> <== 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);
3000abf4: e59f0118 ldr r0, [pc, #280] ; 3000ad14 <rtems_aio_handle+0x264><== NOT EXECUTED 3000abf8: eb00030d bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED 3000abfc: eaffffb2 b 3000aacc <rtems_aio_handle+0x1c> <== 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);
3000ac00: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000ac04: e3a00001 mov r0, #1 <== NOT EXECUTED 3000ac08: eb00014d bl 3000b144 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
3000ac0c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
3000ac10: e2854020 add r4, 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;
3000ac14: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
3000ac18: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac1c: e1a0100b mov r1, fp <== NOT EXECUTED 3000ac20: e28d2020 add r2, sp, #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;
3000ac24: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
3000ac28: e58da024 str sl, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
3000ac2c: eb0001e3 bl 3000b3c0 <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) {
3000ac30: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED 3000ac34: 1affffee bne 3000abf4 <rtems_aio_handle+0x144> <== NOT EXECUTED 3000ac38: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ac3c: eb000943 bl 3000d150 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
3000ac40: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ac44: eb000236 bl 3000b524 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
3000ac48: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac4c: eb00015e bl 3000b1cc <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
3000ac50: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ac54: ebfff15b bl 300071c8 <free> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000ac58: e59b5054 ldr r5, [fp, #84] ; 0x54 <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* 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)) {
3000ac5c: e59f20b4 ldr r2, [pc, #180] ; 3000ad18 <rtems_aio_handle+0x268><== NOT EXECUTED 3000ac60: e1550002 cmp r5, r2 <== NOT EXECUTED 3000ac64: 0a00000d beq 3000aca0 <rtems_aio_handle+0x1f0> <== 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;
3000ac68: e59f30a4 ldr r3, [pc, #164] ; 3000ad14 <rtems_aio_handle+0x264><== NOT EXECUTED 3000ac6c: e59fc0a0 ldr ip, [pc, #160] ; 3000ad14 <rtems_aio_handle+0x264><== NOT EXECUTED 3000ac70: e5932068 ldr r2, [r3, #104] ; 0x68 <== NOT EXECUTED
++aio_request_queue.active_threads;
3000ac74: e5933064 ldr r3, [r3, #100] ; 0x64 <== 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;
3000ac78: e2422001 sub r2, r2, #1 <== NOT EXECUTED
++aio_request_queue.active_threads;
3000ac7c: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000ac80: e1a00005 mov r0, r5 <== 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;
3000ac84: e58c2068 str r2, [ip, #104] ; 0x68 <== NOT EXECUTED
++aio_request_queue.active_threads;
3000ac88: e58c3064 str r3, [ip, #100] ; 0x64 <== NOT EXECUTED 3000ac8c: eb00092f bl 3000d150 <_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);
3000ac90: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ac94: ebffff6b bl 3000aa48 <rtems_aio_move_to_work> <== NOT EXECUTED 3000ac98: e285601c add r6, r5, #28 <== NOT EXECUTED 3000ac9c: eaffffd4 b 3000abf4 <rtems_aio_handle+0x144> <== 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;
3000aca0: e59b2068 ldr r2, [fp, #104] ; 0x68 <== NOT EXECUTED
--aio_request_queue.active_threads;
3000aca4: e59b3064 ldr r3, [fp, #100] ; 0x64 <== 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;
3000aca8: e2822001 add r2, r2, #1 <== NOT EXECUTED
--aio_request_queue.active_threads;
3000acac: e2433001 sub r3, r3, #1 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
3000acb0: e28d1020 add r1, sp, #32 <== 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;
3000acb4: e58b2068 str r2, [fp, #104] ; 0x68 <== NOT EXECUTED
--aio_request_queue.active_threads;
3000acb8: e58b3064 str r3, [fp, #100] ; 0x64 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
3000acbc: e3a00001 mov r0, #1 <== NOT EXECUTED 3000acc0: eb00011f bl 3000b144 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
3000acc4: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000acc8: e28b0004 add r0, fp, #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;
3000accc: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000acd0: e1a0100b mov r1, fp <== NOT EXECUTED 3000acd4: e28d2020 add r2, sp, #32 <== 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;
3000acd8: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
3000acdc: e58da024 str sl, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
3000ace0: eb0001b6 bl 3000b3c0 <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) {
3000ace4: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED 3000ace8: 0a000003 beq 3000acfc <rtems_aio_handle+0x24c> <== NOT EXECUTED 3000acec: e59b5054 ldr r5, [fp, #84] ; 0x54 <== NOT EXECUTED 3000acf0: eaffffdc b 3000ac68 <rtems_aio_handle+0x1b8> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
3000acf4: e594a014 ldr sl, [r4, #20] <== NOT EXECUTED 3000acf8: eaffff91 b 3000ab44 <rtems_aio_handle+0x94> <== 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;
3000acfc: e59b3068 ldr r3, [fp, #104] ; 0x68 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000ad00: e1a0000b mov r0, fp <== 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;
3000ad04: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000ad08: e58b3068 str r3, [fp, #104] ; 0x68 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
3000ad0c: eb0002c8 bl 3000b834 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
3000ad10: eaffff94 b 3000ab68 <rtems_aio_handle+0xb8> <== NOT EXECUTED
3000a878 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
3000a878: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
3000a87c: e59f00e4 ldr r0, [pc, #228] ; 3000a968 <rtems_aio_init+0xf0><== NOT EXECUTED 3000a880: eb000431 bl 3000b94c <pthread_attr_init> <== NOT EXECUTED
if (result != 0)
3000a884: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000a888: 0a000001 beq 3000a894 <rtems_aio_init+0x1c> <== NOT EXECUTED
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
3000a88c: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a890: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
3000a894: e59f00cc ldr r0, [pc, #204] ; 3000a968 <rtems_aio_init+0xf0><== NOT EXECUTED 3000a898: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a89c: eb00043d bl 3000b998 <pthread_attr_setdetachstate> <== NOT EXECUTED
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
3000a8a0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a8a4: 1a00001b bne 3000a918 <rtems_aio_init+0xa0> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
3000a8a8: e59f40bc ldr r4, [pc, #188] ; 3000a96c <rtems_aio_init+0xf4><== NOT EXECUTED 3000a8ac: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a8b0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a8b4: eb00036a bl 3000b664 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
3000a8b8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a8bc: 1a00001d bne 3000a938 <rtems_aio_init+0xc0> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
3000a8c0: e59f00a8 ldr r0, [pc, #168] ; 3000a970 <rtems_aio_init+0xf8><== NOT EXECUTED 3000a8c4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a8c8: eb000272 bl 3000b298 <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
3000a8cc: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000a8d0: 1a00001f bne 3000a954 <rtems_aio_init+0xdc> <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000a8d4: e59f2098 ldr r2, [pc, #152] ; 3000a974 <rtems_aio_init+0xfc><== NOT EXECUTED
head->previous = NULL;
3000a8d8: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a8dc: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED 3000a8e0: e5843058 str r3, [r4, #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;
3000a8e4: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED
aio_request_queue.idle_threads = 0;
3000a8e8: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
3000a8ec: e59f3084 ldr r3, [pc, #132] ; 3000a978 <rtems_aio_init+0x100><== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000a8f0: e282000c add r0, r2, #12 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3000a8f4: e242c004 sub ip, r2, #4 <== NOT EXECUTED 3000a8f8: e2821008 add r1, r2, #8 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000a8fc: e5840054 str r0, [r4, #84] ; 0x54 <== NOT EXECUTED 3000a900: e5842048 str r2, [r4, #72] ; 0x48 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3000a904: e584c050 str ip, [r4, #80] ; 0x50 <== NOT EXECUTED 3000a908: e584105c str r1, [r4, #92] ; 0x5c <== NOT EXECUTED 3000a90c: e5843060 str r3, [r4, #96] ; 0x60 <== NOT EXECUTED
return result;
}
3000a910: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a914: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
3000a918: e59f404c ldr r4, [pc, #76] ; 3000a96c <rtems_aio_init+0xf4><== NOT EXECUTED
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
3000a91c: e59f0044 ldr r0, [pc, #68] ; 3000a968 <rtems_aio_init+0xf0><== NOT EXECUTED 3000a920: eb000400 bl 3000b928 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
3000a924: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a928: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a92c: eb00034c bl 3000b664 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
3000a930: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a934: 0affffe1 beq 3000a8c0 <rtems_aio_init+0x48> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
3000a938: e2840008 add r0, r4, #8 <== NOT EXECUTED 3000a93c: eb0003f9 bl 3000b928 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
3000a940: e59f0028 ldr r0, [pc, #40] ; 3000a970 <rtems_aio_init+0xf8><== NOT EXECUTED 3000a944: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a948: eb000252 bl 3000b298 <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
3000a94c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000a950: 0affffdf beq 3000a8d4 <rtems_aio_init+0x5c> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
3000a954: e59f0010 ldr r0, [pc, #16] ; 3000a96c <rtems_aio_init+0xf4><== NOT EXECUTED 3000a958: eb0002f1 bl 3000b524 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
3000a95c: e59f0004 ldr r0, [pc, #4] ; 3000a968 <rtems_aio_init+0xf0> <== NOT EXECUTED 3000a960: eb0003f0 bl 3000b928 <pthread_attr_destroy> <== NOT EXECUTED 3000a964: eaffffda b 3000a8d4 <rtems_aio_init+0x5c> <== NOT EXECUTED
3000ad1c <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
3000ad1c: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000ad20: e1a03000 mov r3, r0 <== NOT EXECUTED 3000ad24: e4932004 ldr r2, [r3], #4 <== NOT EXECUTED
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
3000ad28: 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)) {
3000ad2c: e1520003 cmp r2, r3 <== NOT EXECUTED 3000ad30: 0a000012 beq 3000ad80 <rtems_aio_insert_prio+0x64> <== 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 &&
3000ad34: e5910014 ldr r0, [r1, #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;
3000ad38: e5921014 ldr r1, [r2, #20] <== NOT EXECUTED
while (req->aiocbp->aio_reqprio > prio &&
3000ad3c: e5904014 ldr r4, [r0, #20] <== NOT EXECUTED 3000ad40: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED 3000ad44: e1510004 cmp r1, r4 <== NOT EXECUTED 3000ad48: a1a03002 movge r3, r2 <== NOT EXECUTED 3000ad4c: ba000002 blt 3000ad5c <rtems_aio_insert_prio+0x40> <== NOT EXECUTED 3000ad50: ea000008 b 3000ad78 <rtems_aio_insert_prio+0x5c> <== NOT EXECUTED 3000ad54: e1510003 cmp r1, r3 <== NOT EXECUTED 3000ad58: 0a000006 beq 3000ad78 <rtems_aio_insert_prio+0x5c> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000ad5c: e5921000 ldr r1, [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;
3000ad60: e5910014 ldr r0, [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 &&
3000ad64: e1a02001 mov r2, r1 <== NOT EXECUTED 3000ad68: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED 3000ad6c: e1500004 cmp r0, r4 <== NOT EXECUTED 3000ad70: bafffff7 blt 3000ad54 <rtems_aio_insert_prio+0x38> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000ad74: e1a03001 mov r3, r1 <== 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 );
3000ad78: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 3000ad7c: e1a0100c mov r1, ip <== NOT EXECUTED
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
3000ad80: e8bd0010 pop {r4} <== NOT EXECUTED
3000ad84: ea000906 b 3000d1a4 <_Chain_Insert> <== NOT EXECUTED
3000aa48 <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
3000aa48: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000aa4c: e59f3058 ldr r3, [pc, #88] ; 3000aaac <rtems_aio_move_to_work+0x64><== NOT EXECUTED
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
3000aa50: e1a01000 mov r1, r0 <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000aa54: e5930048 ldr r0, [r3, #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 &&
3000aa58: e5914014 ldr r4, [r1, #20] <== NOT EXECUTED 3000aa5c: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED 3000aa60: e1520004 cmp r2, r4 <== NOT EXECUTED 3000aa64: aa00000e bge 3000aaa4 <rtems_aio_move_to_work+0x5c> <== NOT EXECUTED 3000aa68: e283304c add r3, r3, #76 ; 0x4c <== NOT EXECUTED 3000aa6c: e1500003 cmp r0, r3 <== NOT EXECUTED 3000aa70: 1a000002 bne 3000aa80 <rtems_aio_move_to_work+0x38> <== NOT EXECUTED 3000aa74: ea00000a b 3000aaa4 <rtems_aio_move_to_work+0x5c> <== NOT EXECUTED 3000aa78: e1520003 cmp r2, r3 <== NOT EXECUTED 3000aa7c: 0a000005 beq 3000aa98 <rtems_aio_move_to_work+0x50> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000aa80: e5902000 ldr r2, [r0] <== 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 &&
3000aa84: e592c014 ldr ip, [r2, #20] <== NOT EXECUTED 3000aa88: e1a00002 mov r0, r2 <== NOT EXECUTED 3000aa8c: e15c0004 cmp ip, r4 <== NOT EXECUTED 3000aa90: bafffff8 blt 3000aa78 <rtems_aio_move_to_work+0x30> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000aa94: e1a03002 mov r3, r2 <== NOT EXECUTED 3000aa98: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
3000aa9c: e8bd0010 pop {r4} <== NOT EXECUTED
3000aaa0: ea0009bf b 3000d1a4 <_Chain_Insert> <== 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 &&
3000aaa4: e1a03000 mov r3, r0 <== NOT EXECUTED 3000aaa8: eafffffa b 3000aa98 <rtems_aio_move_to_work+0x50> <== NOT EXECUTED
3000ad88 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
3000ad88: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000ad8c: e5904008 ldr r4, [r0, #8] <== 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));
3000ad90: e280600c add r6, r0, #12 <== 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))
3000ad94: e1540006 cmp r4, r6 <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
3000ad98: 13a0808c movne r8, #140 ; 0x8c <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000ad9c: 13e07000 mvnne r7, #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))
3000ada0: 1a000001 bne 3000adac <rtems_aio_remove_fd+0x24> <== NOT EXECUTED
3000ada4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
3000ada8: e1a04005 mov r4, r5 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000adac: e1a00004 mov r0, r4 <== NOT EXECUTED 3000adb0: eb0008e6 bl 3000d150 <_Chain_Extract> <== NOT EXECUTED
req->aiocbp->error_code = ECANCELED;
3000adb4: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000adb8: e5945000 ldr r5, [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);
3000adbc: 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;
3000adc0: e5838030 str r8, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
3000adc4: e5837034 str r7, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
3000adc8: ebfff0fe bl 300071c8 <free> <== 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))
3000adcc: e1550006 cmp r5, r6 <== NOT EXECUTED
3000add0: 1afffff4 bne 3000ada8 <rtems_aio_remove_fd+0x20> <== NOT EXECUTED
3000add4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000add8 <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)
{
3000add8: e92d4010 push {r4, lr} <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000addc: e4903004 ldr r3, [r0], #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))
3000ade0: e1530000 cmp r3, r0 <== NOT EXECUTED
return AIO_ALLDONE;
3000ade4: 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))
3000ade8: 1a000003 bne 3000adfc <rtems_aio_remove_req+0x24> <== NOT EXECUTED
3000adec: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000adf0: e5933000 ldr r3, [r3] <== 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) {
3000adf4: e1530000 cmp r3, r0 <== NOT EXECUTED 3000adf8: 0a00000e beq 3000ae38 <rtems_aio_remove_req+0x60> <== NOT EXECUTED 3000adfc: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED
return AIO_ALLDONE;
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
3000ae00: e1a04003 mov r4, r3 <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
3000ae04: e1520001 cmp r2, r1 <== NOT EXECUTED 3000ae08: 1afffff8 bne 3000adf0 <rtems_aio_remove_req+0x18> <== NOT EXECUTED 3000ae0c: e1a00003 mov r0, r3 <== NOT EXECUTED 3000ae10: eb0008ce bl 3000d150 <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
3000ae14: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000ae18: e3a0208c mov r2, #140 ; 0x8c <== NOT EXECUTED 3000ae1c: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
current->aiocbp->return_value = -1;
3000ae20: e3e02000 mvn r2, #0 <== NOT EXECUTED
free (current);
3000ae24: e1a00004 mov r0, r4 <== NOT EXECUTED
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
3000ae28: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
free (current);
3000ae2c: ebfff0e5 bl 300071c8 <free> <== NOT EXECUTED
}
return AIO_CANCELED;
3000ae30: e3a00000 mov r0, #0 <== NOT EXECUTED
3000ae34: 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;
3000ae38: e3a00001 mov r0, #1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
3000ae3c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a97c <rtems_aio_search_fd>:
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
3000a97c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a980: e5904000 ldr r4, [r0] <== NOT EXECUTED
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
3000a984: e1a06000 mov r6, r0 <== 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)) {
3000a988: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
3000a98c: e1a05001 mov r5, r1 <== 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)) {
3000a990: e1510003 cmp r1, r3 <== NOT EXECUTED 3000a994: da000020 ble 3000aa1c <rtems_aio_search_fd+0xa0> <== 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));
3000a998: e2801004 add r1, r0, #4 <== NOT EXECUTED 3000a99c: ea000003 b 3000a9b0 <rtems_aio_search_fd+0x34> <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000a9a0: e5944000 ldr r4, [r4] <== 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)) {
3000a9a4: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000a9a8: e1530005 cmp r3, r5 <== NOT EXECUTED 3000a9ac: aa00001a bge 3000aa1c <rtems_aio_search_fd+0xa0> <== NOT EXECUTED 3000a9b0: e1540001 cmp r4, r1 <== NOT EXECUTED 3000a9b4: 1afffff9 bne 3000a9a0 <rtems_aio_search_fd+0x24> <== NOT EXECUTED 3000a9b8: e1a08004 mov r8, r4 <== NOT EXECUTED
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
3000a9bc: e3520000 cmp r2, #0 <== NOT EXECUTED
r_chain = NULL;
3000a9c0: 01a04002 moveq r4, r2 <== NOT EXECUTED
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
3000a9c4: 0a000019 beq 3000aa30 <rtems_aio_search_fd+0xb4> <== NOT EXECUTED
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
3000a9c8: e3a00024 mov r0, #36 ; 0x24 <== NOT EXECUTED 3000a9cc: ebfff39c bl 30007844 <malloc> <== NOT EXECUTED 3000a9d0: e1a07000 mov r7, r0 <== NOT EXECUTED
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
3000a9d4: e5960000 ldr r0, [r6] <== 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 );
3000a9d8: e287200c add r2, r7, #12 <== 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 );
3000a9dc: e2861004 add r1, r6, #4 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3000a9e0: e2873008 add r3, r7, #8 <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000a9e4: e5872008 str r2, [r7, #8] <== NOT EXECUTED 3000a9e8: e1500001 cmp r0, r1 <== NOT EXECUTED
head->previous = NULL;
3000a9ec: e3a02000 mov r2, #0 <== NOT EXECUTED
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
3000a9f0: e1a04007 mov r4, r7 <== NOT EXECUTED 3000a9f4: e587200c str r2, [r7, #12] <== NOT EXECUTED
tail->previous = head;
3000a9f8: e5873010 str r3, [r7, #16] <== NOT EXECUTED
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
3000a9fc: 0a00000d beq 3000aa38 <rtems_aio_search_fd+0xbc> <== 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 );
3000aa00: e5980004 ldr r0, [r8, #4] <== NOT EXECUTED 3000aa04: e1a01007 mov r1, r7 <== NOT EXECUTED 3000aa08: eb0009e5 bl 3000d1a4 <_Chain_Insert> <== NOT EXECUTED
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;
3000aa0c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000aa10: e5873018 str r3, [r7, #24] <== NOT EXECUTED
r_chain->fildes = fildes;
3000aa14: e5875014 str r5, [r7, #20] <== NOT EXECUTED 3000aa18: ea000004 b 3000aa30 <rtems_aio_search_fd+0xb4> <== 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)
3000aa1c: e1550003 cmp r5, r3 <== NOT EXECUTED
r_chain->new_fd = 0;
3000aa20: 03a03000 moveq r3, #0 <== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
3000aa24: e1a08004 mov r8, r4 <== NOT EXECUTED
node = rtems_chain_next (node);
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
3000aa28: 05843018 streq r3, [r4, #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)
3000aa2c: 1affffe2 bne 3000a9bc <rtems_aio_search_fd+0x40> <== NOT EXECUTED
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
3000aa30: e1a00004 mov r0, r4 <== NOT EXECUTED
3000aa34: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
3000aa38: e1a00006 mov r0, r6 <== NOT EXECUTED 3000aa3c: e1a01007 mov r1, r7 <== NOT EXECUTED 3000aa40: eb0009d7 bl 3000d1a4 <_Chain_Insert> <== NOT EXECUTED 3000aa44: eafffff0 b 3000aa0c <rtems_aio_search_fd+0x90> <== NOT EXECUTED
30006e3c <rtems_assoc_local_by_name>:
uint32_t rtems_assoc_local_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30006e3c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_name(ap, name);
30006e40: eb000091 bl 3000708c <rtems_assoc_ptr_by_name> <== NOT EXECUTED
if (nap)
30006e44: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->local_value;
30006e48: 15900004 ldrne r0, [r0, #4] <== NOT EXECUTED
return 0;
}
30006e4c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30016f94 <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;
}
30016f94: e59f0000 ldr r0, [pc, #0] ; 30016f9c <rtems_assoc_name_bad+0x8><== NOT EXECUTED 30016f98: e12fff1e bx lr <== NOT EXECUTED
30013bd4 <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30013bd4: e92d4010 push {r4, lr} <== NOT EXECUTED
30013bd8: e1a04001 mov r4, r1 <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
30013bdc: eb000006 bl 30013bfc <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if (nap)
30013be0: e3500000 cmp r0, #0 <== NOT EXECUTED 30013be4: 0a000001 beq 30013bf0 <rtems_assoc_name_by_local+0x1c> <== NOT EXECUTED
return nap->name;
return rtems_assoc_name_bad(local_value);
}
30013be8: e5900000 ldr r0, [r0] <== NOT EXECUTED
30013bec: 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);
30013bf0: e1a00004 mov r0, r4 <== NOT EXECUTED
}
30013bf4: 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);
30013bf8: ea000ce5 b 30016f94 <rtems_assoc_name_bad> <== NOT EXECUTED
30006eb8 <rtems_assoc_name_by_local_bitfield>:
char *buffer
)
{
uint32_t b;
*buffer = 0;
30006eb8: e3a03000 mov r3, #0 <== NOT EXECUTED
char *rtems_assoc_name_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t value,
char *buffer
)
{
30006ebc: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006ec0: e1a06002 mov r6, r2 <== NOT EXECUTED
30006ec4: e1a08000 mov r8, r0 <== NOT EXECUTED
30006ec8: e1a07001 mov r7, r1 <== NOT EXECUTED
uint32_t b;
*buffer = 0;
30006ecc: e5c23000 strb r3, [r2] <== NOT EXECUTED 30006ed0: e3a05020 mov r5, #32 <== NOT EXECUTED
for (b = 1; b; b <<= 1) {
30006ed4: e3a04001 mov r4, #1 <== NOT EXECUTED 30006ed8: ea000008 b 30006f00 <rtems_assoc_name_by_local_bitfield+0x48><== NOT EXECUTED
if (b & value) {
if (*buffer)
strcat(buffer, " ");
strcat(buffer, rtems_assoc_name_by_local(ap, b));
30006edc: e1a01004 mov r1, r4 <== NOT EXECUTED 30006ee0: e1a00008 mov r0, r8 <== NOT EXECUTED 30006ee4: eb000014 bl 30006f3c <rtems_assoc_name_by_local> <== NOT EXECUTED 30006ee8: e1a01000 mov r1, r0 <== NOT EXECUTED 30006eec: e1a00006 mov r0, r6 <== NOT EXECUTED 30006ef0: eb0032e7 bl 30013a94 <strcat> <== NOT EXECUTED
{
uint32_t b;
*buffer = 0;
for (b = 1; b; b <<= 1) {
30006ef4: e2555001 subs r5, r5, #1 <== NOT EXECUTED 30006ef8: e1a04084 lsl r4, r4, #1 <== NOT EXECUTED 30006efc: 0a00000b beq 30006f30 <rtems_assoc_name_by_local_bitfield+0x78><== NOT EXECUTED
if (b & value) {
30006f00: e1140007 tst r4, r7 <== NOT EXECUTED 30006f04: 0afffffa beq 30006ef4 <rtems_assoc_name_by_local_bitfield+0x3c><== NOT EXECUTED
if (*buffer)
30006f08: e5d63000 ldrb r3, [r6] <== NOT EXECUTED 30006f0c: e3530000 cmp r3, #0 <== NOT EXECUTED 30006f10: 0afffff1 beq 30006edc <rtems_assoc_name_by_local_bitfield+0x24><== NOT EXECUTED
strcat(buffer, " ");
30006f14: e1a00006 mov r0, r6 <== NOT EXECUTED 30006f18: eb0033e4 bl 30013eb0 <strlen> <== NOT EXECUTED 30006f1c: e3a02002 mov r2, #2 <== NOT EXECUTED 30006f20: e0860000 add r0, r6, r0 <== NOT EXECUTED 30006f24: e59f100c ldr r1, [pc, #12] ; 30006f38 <rtems_assoc_name_by_local_bitfield+0x80><== NOT EXECUTED 30006f28: eb003224 bl 300137c0 <memcpy> <== NOT EXECUTED 30006f2c: eaffffea b 30006edc <rtems_assoc_name_by_local_bitfield+0x24><== NOT EXECUTED
strcat(buffer, rtems_assoc_name_by_local(ap, b));
}
}
return buffer;
}
30006f30: e1a00006 mov r0, r6 <== NOT EXECUTED
30006f34: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30006fe8 <rtems_assoc_name_by_remote>:
const char *rtems_assoc_name_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
30006fe8: e92d4010 push {r4, lr} <== NOT EXECUTED
30006fec: e1a04001 mov r4, r1 <== NOT EXECUTED
const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value);
30006ff0: eb00004b bl 30007124 <rtems_assoc_ptr_by_remote> <== NOT EXECUTED
if (nap)
30006ff4: e3500000 cmp r0, #0 <== NOT EXECUTED 30006ff8: 0a000001 beq 30007004 <rtems_assoc_name_by_remote+0x1c> <== NOT EXECUTED
return nap->name;
return rtems_assoc_name_bad(remote_value);
}
30006ffc: e5900000 ldr r0, [r0] <== NOT EXECUTED
30007000: 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);
30007004: e1a00004 mov r0, r4 <== NOT EXECUTED
}
30007008: 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);
3000700c: ea002147 b 3000f530 <rtems_assoc_name_bad> <== NOT EXECUTED
30006f64 <rtems_assoc_name_by_remote_bitfield>:
char *buffer
)
{
uint32_t b;
*buffer = 0;
30006f64: e3a03000 mov r3, #0 <== NOT EXECUTED
char *rtems_assoc_name_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t value,
char *buffer
)
{
30006f68: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006f6c: e1a06002 mov r6, r2 <== NOT EXECUTED
30006f70: e1a08000 mov r8, r0 <== NOT EXECUTED
30006f74: e1a07001 mov r7, r1 <== NOT EXECUTED
uint32_t b;
*buffer = 0;
30006f78: e5c23000 strb r3, [r2] <== NOT EXECUTED 30006f7c: e3a05020 mov r5, #32 <== NOT EXECUTED
for (b = 1; b; b <<= 1) {
30006f80: e3a04001 mov r4, #1 <== NOT EXECUTED 30006f84: ea000008 b 30006fac <rtems_assoc_name_by_remote_bitfield+0x48><== NOT EXECUTED
if (b & value) {
if (*buffer)
strcat(buffer, " ");
strcat(buffer, rtems_assoc_name_by_remote(ap, b));
30006f88: e1a01004 mov r1, r4 <== NOT EXECUTED 30006f8c: e1a00008 mov r0, r8 <== NOT EXECUTED 30006f90: eb000014 bl 30006fe8 <rtems_assoc_name_by_remote> <== NOT EXECUTED 30006f94: e1a01000 mov r1, r0 <== NOT EXECUTED 30006f98: e1a00006 mov r0, r6 <== NOT EXECUTED 30006f9c: eb0032bc bl 30013a94 <strcat> <== NOT EXECUTED
{
uint32_t b;
*buffer = 0;
for (b = 1; b; b <<= 1) {
30006fa0: e2555001 subs r5, r5, #1 <== NOT EXECUTED 30006fa4: e1a04084 lsl r4, r4, #1 <== NOT EXECUTED 30006fa8: 0a00000b beq 30006fdc <rtems_assoc_name_by_remote_bitfield+0x78><== NOT EXECUTED
if (b & value) {
30006fac: e1140007 tst r4, r7 <== NOT EXECUTED 30006fb0: 0afffffa beq 30006fa0 <rtems_assoc_name_by_remote_bitfield+0x3c><== NOT EXECUTED
if (*buffer)
30006fb4: e5d63000 ldrb r3, [r6] <== NOT EXECUTED 30006fb8: e3530000 cmp r3, #0 <== NOT EXECUTED 30006fbc: 0afffff1 beq 30006f88 <rtems_assoc_name_by_remote_bitfield+0x24><== NOT EXECUTED
strcat(buffer, " ");
30006fc0: e1a00006 mov r0, r6 <== NOT EXECUTED 30006fc4: eb0033b9 bl 30013eb0 <strlen> <== NOT EXECUTED 30006fc8: e3a02002 mov r2, #2 <== NOT EXECUTED 30006fcc: e0860000 add r0, r6, r0 <== NOT EXECUTED 30006fd0: e59f100c ldr r1, [pc, #12] ; 30006fe4 <rtems_assoc_name_by_remote_bitfield+0x80><== NOT EXECUTED 30006fd4: eb0031f9 bl 300137c0 <memcpy> <== NOT EXECUTED 30006fd8: eaffffea b 30006f88 <rtems_assoc_name_by_remote_bitfield+0x24><== NOT EXECUTED
strcat(buffer, rtems_assoc_name_by_remote(ap, b));
}
}
return buffer;
}
30006fdc: e1a00006 mov r0, r6 <== NOT EXECUTED
30006fe0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30013bfc <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30013bfc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30013c00: e1a04000 mov r4, r0 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30013c04: e5900000 ldr r0, [r0] <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30013c08: e1a05001 mov r5, r1 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30013c0c: e3500000 cmp r0, #0 <== 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;
30013c10: 01a04000 moveq r4, r0 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
30013c14: 0a00000a beq 30013c44 <rtems_assoc_ptr_by_local+0x48> <== NOT EXECUTED 30013c18: e59f1054 ldr r1, [pc, #84] ; 30013c74 <rtems_assoc_ptr_by_local+0x78><== NOT EXECUTED 30013c1c: eb0012df bl 300187a0 <strcmp> <== NOT EXECUTED 30013c20: e3500000 cmp r0, #0 <== 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;
30013c24: 13a02000 movne r2, #0 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
30013c28: 1a00000a bne 30013c58 <rtems_assoc_ptr_by_local+0x5c> <== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
30013c2c: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
30013c30: e284300c add r3, r4, #12 <== NOT EXECUTED
for ( ; ap->name; ap++)
30013c34: e3520000 cmp r2, #0 <== NOT EXECUTED 30013c38: 11a02004 movne r2, r4 <== NOT EXECUTED 30013c3c: 11a04003 movne r4, r3 <== NOT EXECUTED 30013c40: 1a000004 bne 30013c58 <rtems_assoc_ptr_by_local+0x5c> <== NOT EXECUTED
if (ap->local_value == local_value)
return ap;
return default_ap;
}
30013c44: e1a00004 mov r0, r4 <== NOT EXECUTED
30013c48: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30013c4c: e5b4300c ldr r3, [r4, #12]! <== NOT EXECUTED 30013c50: e3530000 cmp r3, #0 <== NOT EXECUTED 30013c54: 0a000003 beq 30013c68 <rtems_assoc_ptr_by_local+0x6c> <== NOT EXECUTED
if (ap->local_value == local_value)
30013c58: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30013c5c: e1530005 cmp r3, r5 <== NOT EXECUTED 30013c60: 1afffff9 bne 30013c4c <rtems_assoc_ptr_by_local+0x50> <== NOT EXECUTED 30013c64: eafffff6 b 30013c44 <rtems_assoc_ptr_by_local+0x48> <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30013c68: e1a04002 mov r4, r2 <== NOT EXECUTED
if (ap->local_value == local_value)
return ap;
return default_ap;
}
30013c6c: e1a00004 mov r0, r4 <== NOT EXECUTED
30013c70: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000708c <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
3000708c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30007090: e5904000 ldr r4, [r0] <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30007094: e1a06000 mov r6, r0 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30007098: e3540000 cmp r4, #0 <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
3000709c: e1a07001 mov r7, r1 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
300070a0: 01a06004 moveq r6, r4 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
300070a4: 0a000011 beq 300070f0 <rtems_assoc_ptr_by_name+0x64> <== NOT EXECUTED 300070a8: e1a00004 mov r0, r4 <== NOT EXECUTED 300070ac: e59f106c ldr r1, [pc, #108] ; 30007120 <rtems_assoc_ptr_by_name+0x94><== NOT EXECUTED 300070b0: eb0032a2 bl 30013b40 <strcmp> <== NOT EXECUTED 300070b4: 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;
300070b8: 13a08000 movne r8, #0 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
300070bc: 0a00000d beq 300070f8 <rtems_assoc_ptr_by_name+0x6c> <== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
300070c0: e1a05006 mov r5, r6 <== NOT EXECUTED 300070c4: ea000003 b 300070d8 <rtems_assoc_ptr_by_name+0x4c> <== NOT EXECUTED 300070c8: e595400c ldr r4, [r5, #12] <== NOT EXECUTED 300070cc: e285500c add r5, r5, #12 <== NOT EXECUTED 300070d0: e3540000 cmp r4, #0 <== NOT EXECUTED 300070d4: 0a00000e beq 30007114 <rtems_assoc_ptr_by_name+0x88> <== NOT EXECUTED
if (strcmp(ap->name, name) == 0)
300070d8: e1a00004 mov r0, r4 <== NOT EXECUTED 300070dc: e1a01007 mov r1, r7 <== NOT EXECUTED 300070e0: eb003296 bl 30013b40 <strcmp> <== NOT EXECUTED 300070e4: e3500000 cmp r0, #0 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
300070e8: e1a06005 mov r6, r5 <== NOT EXECUTED
if (strcmp(ap->name, name) == 0)
300070ec: 1afffff5 bne 300070c8 <rtems_assoc_ptr_by_name+0x3c> <== NOT EXECUTED
return ap;
return default_ap;
}
300070f0: e1a00006 mov r0, r6 <== NOT EXECUTED
300070f4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
300070f8: e596400c ldr r4, [r6, #12] <== NOT EXECUTED
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
300070fc: e286300c add r3, r6, #12 <== NOT EXECUTED
for ( ; ap->name; ap++)
30007100: e3540000 cmp r4, #0 <== NOT EXECUTED 30007104: 11a08006 movne r8, r6 <== NOT EXECUTED 30007108: 11a06003 movne r6, r3 <== NOT EXECUTED 3000710c: 1affffeb bne 300070c0 <rtems_assoc_ptr_by_name+0x34> <== NOT EXECUTED 30007110: eafffff6 b 300070f0 <rtems_assoc_ptr_by_name+0x64> <== NOT EXECUTED 30007114: e1a06008 mov r6, r8 <== NOT EXECUTED
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
30007118: e1a00006 mov r0, r6 <== NOT EXECUTED
3000711c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30011724 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
30011724: e92d4030 push {r4, r5, lr}
30011728: e1a04000 mov r4, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
3001172c: e5900000 ldr r0, [r0]
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
30011730: e1a05001 mov r5, r1
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30011734: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
30011738: 01a04000 moveq r4, r0
if (rtems_assoc_is_default(ap))
3001173c: 0a00000a beq 3001176c <rtems_assoc_ptr_by_remote+0x48>
30011740: e59f1054 ldr r1, [pc, #84] ; 3001179c <rtems_assoc_ptr_by_remote+0x78> 30011744: eb000558 bl 30012cac <strcmp> 30011748: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
3001174c: 13a02000 movne r2, #0
if (rtems_assoc_is_default(ap))
30011750: 1a00000a bne 30011780 <rtems_assoc_ptr_by_remote+0x5c>
default_ap = ap++;
for ( ; ap->name; ap++)
30011754: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
30011758: e284300c add r3, r4, #12 <== NOT EXECUTED
for ( ; ap->name; ap++)
3001175c: e3520000 cmp r2, #0 <== NOT EXECUTED 30011760: 11a02004 movne r2, r4 <== NOT EXECUTED 30011764: 11a04003 movne r4, r3 <== NOT EXECUTED 30011768: 1a000004 bne 30011780 <rtems_assoc_ptr_by_remote+0x5c> <== NOT EXECUTED
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
3001176c: e1a00004 mov r0, r4
30011770: e8bd8030 pop {r4, r5, pc}
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30011774: e5b4300c ldr r3, [r4, #12]! 30011778: e3530000 cmp r3, #0
3001177c: 0a000003 beq 30011790 <rtems_assoc_ptr_by_remote+0x6c>
if (ap->remote_value == remote_value)
30011780: e5943008 ldr r3, [r4, #8] 30011784: e1530005 cmp r3, r5
30011788: 1afffff9 bne 30011774 <rtems_assoc_ptr_by_remote+0x50>
3001178c: eafffff6 b 3001176c <rtems_assoc_ptr_by_remote+0x48>
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30011790: e1a04002 mov r4, r2
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
30011794: e1a00004 mov r0, r4
30011798: e8bd8030 pop {r4, r5, pc}
300071f4 <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
300071f4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
300071f8: ebffff84 bl 30007010 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if (nap)
300071fc: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->remote_value;
30007200: 15900008 ldrne r0, [r0, #8] <== NOT EXECUTED
return 0;
}
30007204: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300071a0 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
300071a0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
300071a4: e1a08000 mov r8, r0 <== NOT EXECUTED
300071a8: e1a06001 mov r6, r1 <== NOT EXECUTED
300071ac: e3a05020 mov r5, #32 <== NOT EXECUTED
uint32_t b; uint32_t remote_value = 0;
300071b0: e3a07000 mov r7, #0 <== NOT EXECUTED
for (b = 1; b; b <<= 1)
300071b4: e3a04001 mov r4, #1 <== NOT EXECUTED 300071b8: ea000002 b 300071c8 <rtems_assoc_remote_by_local_bitfield+0x28><== NOT EXECUTED 300071bc: e2555001 subs r5, r5, #1 <== NOT EXECUTED 300071c0: e1a04084 lsl r4, r4, #1 <== NOT EXECUTED 300071c4: 0a000008 beq 300071ec <rtems_assoc_remote_by_local_bitfield+0x4c><== NOT EXECUTED
if (b & local_value)
300071c8: e1140006 tst r4, r6 <== NOT EXECUTED 300071cc: 0afffffa beq 300071bc <rtems_assoc_remote_by_local_bitfield+0x1c><== NOT EXECUTED
remote_value |= rtems_assoc_remote_by_local(ap, b);
300071d0: e1a01004 mov r1, r4 <== NOT EXECUTED 300071d4: e1a00008 mov r0, r8 <== NOT EXECUTED 300071d8: eb000005 bl 300071f4 <rtems_assoc_remote_by_local> <== NOT EXECUTED
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
300071dc: e2555001 subs r5, r5, #1 <== NOT EXECUTED
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
300071e0: e1877000 orr r7, r7, r0 <== NOT EXECUTED
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
300071e4: e1a04084 lsl r4, r4, #1 <== NOT EXECUTED 300071e8: 1afffff6 bne 300071c8 <rtems_assoc_remote_by_local_bitfield+0x28><== NOT EXECUTED
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
return remote_value;
}
300071ec: e1a00007 mov r0, r7 <== NOT EXECUTED
300071f0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30007208 <rtems_assoc_remote_by_name>:
uint32_t rtems_assoc_remote_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30007208: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_name(ap, name);
3000720c: ebffff9e bl 3000708c <rtems_assoc_ptr_by_name> <== NOT EXECUTED
if (nap)
30007210: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->remote_value;
30007214: 15900008 ldrne r0, [r0, #8] <== NOT EXECUTED
return 0;
}
30007218: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300124ec <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
300124ec: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
300124f0: e2504000 subs r4, r0, #0
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
300124f4: e24dd008 sub sp, sp, #8 300124f8: e1a05001 mov r5, r1 300124fc: e1a07003 mov r7, r3
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30012500: 03a00003 moveq r0, #3
)
{
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
30012504: 0a00001e beq 30012584 <rtems_barrier_create+0x98>
return RTEMS_INVALID_NAME;
if ( !id )
30012508: e3530000 cmp r3, #0
return RTEMS_INVALID_ADDRESS;
3001250c: 03a00009 moveq r0, #9
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30012510: 0a00001b beq 30012584 <rtems_barrier_create+0x98>
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
30012514: e3110010 tst r1, #16
30012518: 0a00001b beq 3001258c <rtems_barrier_create+0xa0>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
3001251c: e3a03000 mov r3, #0 <== NOT EXECUTED
if ( maximum_waiters == 0 )
30012520: e3520000 cmp r2, #0 <== 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;
30012524: e58d3000 str r3, [sp] <== NOT EXECUTED
if ( maximum_waiters == 0 )
30012528: 0a00001a beq 30012598 <rtems_barrier_create+0xac> <== NOT EXECUTED
3001252c: e59f3078 ldr r3, [pc, #120] ; 300125ac <rtems_barrier_create+0xc0>
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
30012530: e58d2004 str r2, [sp, #4] 30012534: e5932000 ldr r2, [r3] 30012538: e2822001 add r2, r2, #1 3001253c: 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 );
30012540: e59f8068 ldr r8, [pc, #104] ; 300125b0 <rtems_barrier_create+0xc4> 30012544: e1a00008 mov r0, r8 30012548: ebffeb1b bl 3000d1bc <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
3001254c: e2506000 subs r6, r0, #0
30012550: 0a000012 beq 300125a0 <rtems_barrier_create+0xb4>
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
30012554: e2860014 add r0, r6, #20 30012558: e1a0100d mov r1, sp
if ( !the_barrier ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
3001255c: e5865010 str r5, [r6, #16]
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
30012560: eb00024c bl 30012e98 <_CORE_barrier_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30012564: e5963008 ldr r3, [r6, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30012568: e598201c ldr r2, [r8, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3001256c: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30012570: e7826721 str r6, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30012574: e586400c str r4, [r6, #12]
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
30012578: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
3001257c: ebffef86 bl 3000e39c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30012580: e3a00000 mov r0, #0
}
30012584: e28dd008 add sp, sp, #8
30012588: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
3001258c: e3a03001 mov r3, #1 30012590: e58d3000 str r3, [sp] 30012594: eaffffe4 b 3001252c <rtems_barrier_create+0x40>
/* 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;
30012598: e3a0000a mov r0, #10 <== NOT EXECUTED 3001259c: eafffff8 b 30012584 <rtems_barrier_create+0x98> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
300125a0: ebffef7d bl 3000e39c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
300125a4: e3a00005 mov r0, #5 <== NOT EXECUTED 300125a8: eafffff5 b 30012584 <rtems_barrier_create+0x98> <== NOT EXECUTED
30012664 <rtems_barrier_release>:
rtems_status_code rtems_barrier_release(
rtems_id id,
uint32_t *released
)
{
30012664: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
30012668: e2516000 subs r6, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_barrier_release(
rtems_id id,
uint32_t *released
)
{
3001266c: e1a05000 mov r5, r0 <== NOT EXECUTED 30012670: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
return RTEMS_INVALID_ADDRESS;
30012674: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
30012678: 0a00000e beq 300126b8 <rtems_barrier_release+0x54> <== NOT EXECUTED
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
3001267c: e59f003c ldr r0, [pc, #60] ; 300126c0 <rtems_barrier_release+0x5c><== NOT EXECUTED 30012680: e1a01005 mov r1, r5 <== NOT EXECUTED 30012684: e1a0200d mov r2, sp <== NOT EXECUTED 30012688: ebffebfc bl 3000d680 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
3001268c: e59d4000 ldr r4, [sp] <== NOT EXECUTED 30012690: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30012694: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !released )
return RTEMS_INVALID_ADDRESS;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
30012698: 1a000006 bne 300126b8 <rtems_barrier_release+0x54> <== NOT EXECUTED
case OBJECTS_LOCAL:
*released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
3001269c: e1a01005 mov r1, r5 <== NOT EXECUTED 300126a0: e1a02004 mov r2, r4 <== NOT EXECUTED 300126a4: e2800014 add r0, r0, #20 <== NOT EXECUTED 300126a8: eb000205 bl 30012ec4 <_CORE_barrier_Release> <== NOT EXECUTED 300126ac: e5860000 str r0, [r6] <== NOT EXECUTED
_Thread_Enable_dispatch();
300126b0: ebffef39 bl 3000e39c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300126b4: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300126b8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300126bc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300126c4 <rtems_barrier_wait>:
rtems_status_code rtems_barrier_wait(
rtems_id id,
rtems_interval timeout
)
{
300126c4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
300126c8: e1a04000 mov r4, r0 <== NOT EXECUTED
300126cc: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
300126d0: e1a05001 mov r5, r1 <== NOT EXECUTED
300126d4: e59f004c ldr r0, [pc, #76] ; 30012728 <rtems_barrier_wait+0x64><== NOT EXECUTED
300126d8: e1a01004 mov r1, r4 <== NOT EXECUTED
300126dc: e28d2004 add r2, sp, #4 <== NOT EXECUTED
300126e0: ebffebe6 bl 3000d680 <_Objects_Get> <== NOT EXECUTED
Barrier_Control *the_barrier;
Objects_Locations location;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
300126e4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 300126e8: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300126ec: 13a00004 movne r0, #4 <== NOT EXECUTED
{
Barrier_Control *the_barrier;
Objects_Locations location;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
300126f0: 1a00000a bne 30012720 <rtems_barrier_wait+0x5c> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_barrier_Wait(
300126f4: e2800014 add r0, r0, #20 <== NOT EXECUTED 300126f8: e58d3000 str r3, [sp] <== NOT EXECUTED 300126fc: e3a02001 mov r2, #1 <== NOT EXECUTED 30012700: e1a03005 mov r3, r5 <== NOT EXECUTED 30012704: e1a01004 mov r1, r4 <== NOT EXECUTED 30012708: eb0001f9 bl 30012ef4 <_CORE_barrier_Wait> <== NOT EXECUTED
id,
true,
timeout,
NULL
);
_Thread_Enable_dispatch();
3001270c: ebffef22 bl 3000e39c <_Thread_Enable_dispatch> <== NOT EXECUTED
return _Barrier_Translate_core_barrier_return_code(
_Thread_Executing->Wait.return_code );
30012710: e59f3014 ldr r3, [pc, #20] ; 3001272c <rtems_barrier_wait+0x68><== NOT EXECUTED 30012714: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
true,
timeout,
NULL
);
_Thread_Enable_dispatch();
return _Barrier_Translate_core_barrier_return_code(
30012718: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 3001271c: eb0006c4 bl 30014234 <_Barrier_Translate_core_barrier_return_code><== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30012720: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30012724: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b9e4 <rtems_build_id>:
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000b9e4: e1a00c00 lsl r0, r0, #24 <== NOT EXECUTED 3000b9e8: e1800d81 orr r0, r0, r1, lsl #27 <== NOT EXECUTED
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000b9ec: e1800003 orr r0, r0, r3 <== NOT EXECUTED
uint32_t node,
uint32_t index
)
{
return _Objects_Build_id( api, class, node, index );
}
3000b9f0: e1800802 orr r0, r0, r2, lsl #16 <== NOT EXECUTED 3000b9f4: e12fff1e bx lr <== NOT EXECUTED
3000b9f8 <rtems_build_name>:
char C1,
char C2,
char C3,
char C4
)
{
3000b9f8: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000b9fc: e1a02402 lsl r2, r2, #8 <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000ba00: e20118ff and r1, r1, #16711680 ; 0xff0000 <== NOT EXECUTED 3000ba04: e1811c00 orr r1, r1, r0, lsl #24 <== NOT EXECUTED 3000ba08: e2022cff and r2, r2, #65280 ; 0xff00 <== NOT EXECUTED
char C1,
char C2,
char C3,
char C4
)
{
3000ba0c: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000ba10: e1811002 orr r1, r1, r2 <== NOT EXECUTED
}
3000ba14: e1810003 orr r0, r1, r3 <== NOT EXECUTED 3000ba18: e12fff1e bx lr <== NOT EXECUTED
3000aa20 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
3000aa20: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000aa24: e1a04002 mov r4, r2 <== NOT EXECUTED
3000aa28: 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 );
3000aa2c: eb000147 bl 3000af50 <_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 ) {
3000aa30: e3500000 cmp r0, #0 <== NOT EXECUTED
3000aa34: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000aa38: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aa3c: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000aa40: 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 );
3000aa44: eafffd87 b 3000a068 <rtems_event_send> <== NOT EXECUTED
3000aa48 <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
3000aa48: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000aa4c: 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 );
3000aa50: e1a01003 mov r1, r3 <== NOT EXECUTED 3000aa54: e1a05002 mov r5, r2 <== NOT EXECUTED 3000aa58: eb00015f bl 3000afdc <_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 ) {
3000aa5c: e3500000 cmp r0, #0 <== NOT EXECUTED
3000aa60: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000aa64: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aa68: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000aa6c: 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 );
3000aa70: eafffd7c b 3000a068 <rtems_event_send> <== NOT EXECUTED
3000aa74 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
3000aa74: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3000aa78: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000aa7c: e1a07000 mov r7, r0 <== NOT EXECUTED
3000aa80: e1a06001 mov r6, r1 <== NOT EXECUTED
3000aa84: e1a05002 mov r5, r2 <== NOT EXECUTED
3000aa88: e1a0a003 mov sl, r3 <== NOT EXECUTED
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
3000aa8c: e1a0800d mov r8, sp <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
3000aa90: e1a00007 mov r0, r7 <== NOT EXECUTED 3000aa94: eb000165 bl 3000b030 <_Chain_Get> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000aa98: e2504000 subs r4, r0, #0 <== NOT EXECUTED
) {
rtems_event_set out;
sc = rtems_event_receive(
3000aa9c: e1a02005 mov r2, r5 <== NOT EXECUTED 3000aaa0: e1a0300d mov r3, sp <== NOT EXECUTED 3000aaa4: e1a01004 mov r1, r4 <== NOT EXECUTED 3000aaa8: e1a00006 mov r0, r6 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000aaac: 1a000005 bne 3000aac8 <rtems_chain_get_with_wait+0x54> <== NOT EXECUTED
) {
rtems_event_set out;
sc = rtems_event_receive(
3000aab0: ebfffd0f bl 30009ef4 <rtems_event_receive> <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
3000aab4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000aab8: 0afffff4 beq 3000aa90 <rtems_chain_get_with_wait+0x1c> <== NOT EXECUTED
timeout,
&out
);
}
*node_ptr = node;
3000aabc: e58a4000 str r4, [sl] <== NOT EXECUTED
return sc;
}
3000aac0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000aac4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000aac8: e3a00000 mov r0, #0 <== NOT EXECUTED 3000aacc: eafffffa b 3000aabc <rtems_chain_get_with_wait+0x48> <== NOT EXECUTED
3000aad0 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
3000aad0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000aad4: e1a04002 mov r4, r2 <== NOT EXECUTED
3000aad8: 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 );
3000aadc: eb00016a bl 3000b08c <_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) {
3000aae0: e3500000 cmp r0, #0 <== NOT EXECUTED
3000aae4: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000aae8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aaec: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000aaf0: 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 );
3000aaf4: eafffd5b b 3000a068 <rtems_event_send> <== NOT EXECUTED
30017014 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
30017014: e92d4010 push {r4, lr} <== NOT EXECUTED
if ( !time_buffer )
30017018: e2514000 subs r4, r1, #0 <== NOT EXECUTED 3001701c: 0a000012 beq 3001706c <rtems_clock_get+0x58> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
30017020: e3500000 cmp r0, #0 <== NOT EXECUTED 30017024: 0a00000d beq 30017060 <rtems_clock_get+0x4c> <== NOT EXECUTED
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
30017028: e3500001 cmp r0, #1 <== NOT EXECUTED 3001702c: 0a000011 beq 30017078 <rtems_clock_get+0x64> <== NOT EXECUTED
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
30017030: e3500002 cmp r0, #2 <== NOT EXECUTED 30017034: 0a000012 beq 30017084 <rtems_clock_get+0x70> <== NOT EXECUTED
*interval = rtems_clock_get_ticks_since_boot();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
30017038: e3500003 cmp r0, #3 <== NOT EXECUTED 3001703c: 0a000014 beq 30017094 <rtems_clock_get+0x80> <== NOT EXECUTED
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
30017040: e3500004 cmp r0, #4 <== NOT EXECUTED
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
30017044: 13a0300a movne r3, #10 <== NOT EXECUTED
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
30017048: 0a000001 beq 30017054 <rtems_clock_get+0x40> <== NOT EXECUTED
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
3001704c: e1a00003 mov r0, r3 <== NOT EXECUTED
30017050: e8bd8010 pop {r4, pc} <== 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 );
30017054: e1a00004 mov r0, r4 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
}
30017058: 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 );
3001705c: ea000060 b 300171e4 <rtems_clock_get_tod_timeval> <== 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 );
30017060: 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;
}
30017064: 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 );
30017068: ea000027 b 3001710c <rtems_clock_get_tod> <== NOT EXECUTED
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
3001706c: e3a03009 mov r3, #9 <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
30017070: e1a00003 mov r0, r3 <== NOT EXECUTED
30017074: e8bd8010 pop {r4, pc} <== 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);
30017078: 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;
}
3001707c: 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);
30017080: ea000007 b 300170a4 <rtems_clock_get_seconds_since_epoch> <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
30017084: eb00001c bl 300170fc <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30017088: e3a03000 mov r3, #0 <== NOT EXECUTED
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
3001708c: e5840000 str r0, [r4] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30017090: eaffffed b 3001704c <rtems_clock_get+0x38> <== NOT EXECUTED
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
30017094: eb000010 bl 300170dc <rtems_clock_get_ticks_per_second> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30017098: e3a03000 mov r3, #0 <== NOT EXECUTED
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
3001709c: e5840000 str r0, [r4] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300170a0: eaffffe9 b 3001704c <rtems_clock_get+0x38> <== NOT EXECUTED
3000a8fc <rtems_clock_get_seconds_since_epoch>:
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000a8fc: e2502000 subs r2, r0, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000a900: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000a904: 012fff1e bxeq lr <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
3000a908: e59f301c ldr r3, [pc, #28] ; 3000a92c <rtems_clock_get_seconds_since_epoch+0x30><== NOT EXECUTED 3000a90c: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 3000a910: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch();
3000a914: 159f3014 ldrne r3, [pc, #20] ; 3000a930 <rtems_clock_get_seconds_since_epoch+0x34><== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a918: 13a00000 movne r0, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch();
3000a91c: 15933000 ldrne r3, [r3] <== NOT EXECUTED
{
if ( !the_interval )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
3000a920: 03a0000b moveq r0, #11 <== NOT EXECUTED
*the_interval = _TOD_Seconds_since_epoch();
3000a924: 15823000 strne r3, [r2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL; }
3000a928: e12fff1e bx lr <== NOT EXECUTED
300094b4 <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 /
300094b4: e59f3010 ldr r3, [pc, #16] ; 300094cc <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)
{
300094b8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return TOD_MICROSECONDS_PER_SECOND /
300094bc: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 300094c0: e59f0008 ldr r0, [pc, #8] ; 300094d0 <rtems_clock_get_ticks_per_second+0x1c><== NOT EXECUTED 300094c4: eb0030ad bl 30015780 <__aeabi_uidiv> <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick();
}
300094c8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300094d4 <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;
300094d4: e59f3004 ldr r3, [pc, #4] ; 300094e0 <rtems_clock_get_ticks_since_boot+0xc><== NOT EXECUTED 300094d8: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
300094dc: e12fff1e bx lr <== NOT EXECUTED
300171e4 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
300171e4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !time )
300171e8: e2504000 subs r4, r0, #0 <== NOT EXECUTED
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
300171ec: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
if ( !time )
return RTEMS_INVALID_ADDRESS;
300171f0: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
300171f4: 0a000012 beq 30017244 <rtems_clock_get_tod_timeval+0x60> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
300171f8: e59f304c ldr r3, [pc, #76] ; 3001724c <rtems_clock_get_tod_timeval+0x68><== NOT EXECUTED 300171fc: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 30017200: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
30017204: 03a0000b moveq r0, #11 <== NOT EXECUTED
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
30017208: 0a00000d beq 30017244 <rtems_clock_get_tod_timeval+0x60> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001720c: e10f5000 mrs r5, CPSR <== NOT EXECUTED 30017210: e3853080 orr r3, r5, #128 ; 0x80 <== NOT EXECUTED 30017214: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
_TOD_Get( &now );
30017218: e1a0000d mov r0, sp <== NOT EXECUTED 3001721c: eb001203 bl 3001ba30 <_TOD_Get> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30017220: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
30017224: e59f2024 ldr r2, [pc, #36] ; 30017250 <rtems_clock_get_tod_timeval+0x6c><== NOT EXECUTED
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
30017228: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
3001722c: e3a00000 mov r0, #0 <== NOT EXECUTED
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
30017230: e0c21293 smull r1, r2, r3, r2 <== NOT EXECUTED 30017234: e1a03fc3 asr r3, r3, #31 <== NOT EXECUTED 30017238: e0633342 rsb r3, r3, r2, asr #6 <== NOT EXECUTED
time->tv_sec = now.tv_sec;
3001723c: e59d2000 ldr r2, [sp] <== NOT EXECUTED
time->tv_usec = useconds;
30017240: e884000c stm r4, {r2, r3} <== NOT EXECUTED
}
30017244: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30017248: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30009708 <rtems_clock_get_uptime>:
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
30009708: e3500000 cmp r0, #0 <== NOT EXECUTED
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
3000970c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !uptime )
30009710: 0a000002 beq 30009720 <rtems_clock_get_uptime+0x18> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
30009714: eb00059b bl 3000ad88 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30009718: e3a00000 mov r0, #0 <== NOT EXECUTED
3000971c: 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;
30009720: e3a00009 mov r0, #9 <== NOT EXECUTED
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
30009724: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009500 <rtems_clock_tick>:
*
* NOTE: This routine only works for leap-years through 2099.
*/
rtems_status_code rtems_clock_tick( void )
{
30009500: e52de004 push {lr} ; (str lr, [sp, #-4]!)
_TOD_Tickle_ticks();
30009504: eb000537 bl 3000a9e8 <_TOD_Tickle_ticks>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{
_Watchdog_Tickle( &_Watchdog_Ticks_chain );
30009508: e59f0038 ldr r0, [pc, #56] ; 30009548 <rtems_clock_tick+0x48> 3000950c: eb000f2f bl 3000d1d0 <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
30009510: eb000d91 bl 3000cb5c <_Thread_Tickle_timeslice>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
30009514: e59f3030 ldr r3, [pc, #48] ; 3000954c <rtems_clock_tick+0x4c> 30009518: e5d33010 ldrb r3, [r3, #16]
if ( _Thread_Is_context_switch_necessary() &&
3000951c: e3530000 cmp r3, #0
30009520: 0a000003 beq 30009534 <rtems_clock_tick+0x34>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
30009524: e59f3024 ldr r3, [pc, #36] ; 30009550 <rtems_clock_tick+0x50><== NOT EXECUTED 30009528: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000952c: e3530000 cmp r3, #0 <== NOT EXECUTED 30009530: 0a000001 beq 3000953c <rtems_clock_tick+0x3c> <== NOT EXECUTED
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
}
30009534: e3a00000 mov r0, #0
30009538: e49df004 pop {pc} ; (ldr pc, [sp], #4)
_Thread_Tickle_timeslice();
if ( _Thread_Is_context_switch_necessary() &&
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
3000953c: eb000a99 bl 3000bfa8 <_Thread_Dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
30009540: e3a00000 mov r0, #0 <== NOT EXECUTED
30009544: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006c68 <rtems_cpu_usage_report>:
void rtems_cpu_usage_report( void )
{
rtems_cpu_usage_report_with_plugin( NULL, printk_plugin );
30006c68: e59f1004 ldr r1, [pc, #4] ; 30006c74 <rtems_cpu_usage_report+0xc><== NOT EXECUTED 30006c6c: e3a00000 mov r0, #0 <== NOT EXECUTED 30006c70: eaffff80 b 30006a78 <rtems_cpu_usage_report_with_plugin> <== NOT EXECUTED
30006a78 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30006a78: 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 )
30006a7c: e251a000 subs sl, r1, #0 <== NOT EXECUTED
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30006a80: e24dd058 sub sp, sp, #88 ; 0x58 <== NOT EXECUTED 30006a84: e1a0b000 mov fp, r0 <== NOT EXECUTED
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
30006a88: 0a00006a beq 30006c38 <rtems_cpu_usage_report_with_plugin+0x1c0><== 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__
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
30006a8c: e59f31ac ldr r3, [pc, #428] ; 30006c40 <rtems_cpu_usage_report_with_plugin+0x1c8><== NOT EXECUTED
}
}
}
#endif
(*print)(
30006a90: e59f11ac ldr r1, [pc, #428] ; 30006c44 <rtems_cpu_usage_report_with_plugin+0x1cc><== 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__
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
30006a94: e8930018 ldm r3, {r3, r4} <== NOT EXECUTED
30006a98: e58d3030 str r3, [sp, #48] ; 0x30 <== NOT EXECUTED
30006a9c: e58d4034 str r4, [sp, #52] ; 0x34 <== NOT EXECUTED
}
}
}
#endif
(*print)(
30006aa0: e1a0e00f mov lr, pc <== NOT EXECUTED 30006aa4: e12fff1a bx sl <== NOT EXECUTED 30006aa8: e59f1198 ldr r1, [pc, #408] ; 30006c48 <rtems_cpu_usage_report_with_plugin+0x1d0><== NOT EXECUTED
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
30006aac: e28d7010 add r7, sp, #16 <== NOT EXECUTED
}
}
}
#endif
(*print)(
30006ab0: e58d100c str r1, [sp, #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 ];
30006ab4: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 30006ab8: e5b23004 ldr r3, [r2, #4]! <== NOT EXECUTED 30006abc: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED 30006ac0: e58d200c str r2, [sp, #12] <== NOT EXECUTED
if ( information ) {
30006ac4: e3560000 cmp r6, #0 <== NOT EXECUTED 30006ac8: 0a00004d beq 30006c04 <rtems_cpu_usage_report_with_plugin+0x18c><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
30006acc: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED 30006ad0: e3530000 cmp r3, #0 <== NOT EXECUTED 30006ad4: 0a00004a beq 30006c04 <rtems_cpu_usage_report_with_plugin+0x18c><== NOT EXECUTED 30006ad8: e3a05001 mov r5, #1 <== NOT EXECUTED
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
30006adc: e28d9040 add r9, sp, #64 ; 0x40 <== NOT EXECUTED
Timestamp_Control last = _Thread_Time_of_last_context_switch;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
30006ae0: e28d8048 add r8, sp, #72 ; 0x48 <== NOT EXECUTED 30006ae4: ea00001c b 30006b5c <rtems_cpu_usage_report_with_plugin+0xe4><== NOT EXECUTED 30006ae8: e1a00008 mov r0, r8 <== NOT EXECUTED 30006aec: eb001628 bl 3000c394 <_TOD_Get_uptime> <== NOT EXECUTED 30006af0: e28d4038 add r4, sp, #56 ; 0x38 <== NOT EXECUTED
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
30006af4: e28d0030 add r0, sp, #48 ; 0x30 <== NOT EXECUTED 30006af8: e1a01008 mov r1, r8 <== NOT EXECUTED 30006afc: e1a02009 mov r2, r9 <== NOT EXECUTED 30006b00: eb001f95 bl 3000e95c <_Timespec_Subtract> <== NOT EXECUTED
_Timestamp_Divide( &ran, &total, &ival, &fval );
30006b04: e1a01009 mov r1, r9 <== NOT EXECUTED 30006b08: e1a00004 mov r0, r4 <== NOT EXECUTED 30006b0c: e28d2054 add r2, sp, #84 ; 0x54 <== NOT EXECUTED 30006b10: e28d3050 add r3, sp, #80 ; 0x50 <== NOT EXECUTED 30006b14: eb001f6c bl 3000e8cc <_Timespec_Divide> <== NOT EXECUTED
/*
* Print the information
*/
(*print)( context,
30006b18: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED 30006b1c: e59f2128 ldr r2, [pc, #296] ; 30006c4c <rtems_cpu_usage_report_with_plugin+0x1d4><== NOT EXECUTED 30006b20: e1a0000b mov r0, fp <== NOT EXECUTED 30006b24: e0831392 umull r1, r3, r2, r3 <== NOT EXECUTED 30006b28: e59d2054 ldr r2, [sp, #84] ; 0x54 <== NOT EXECUTED 30006b2c: e1a03323 lsr r3, r3, #6 <== NOT EXECUTED 30006b30: e58d2000 str r2, [sp] <== NOT EXECUTED 30006b34: e59d2050 ldr r2, [sp, #80] ; 0x50 <== NOT EXECUTED 30006b38: e59f1110 ldr r1, [pc, #272] ; 30006c50 <rtems_cpu_usage_report_with_plugin+0x1d8><== NOT EXECUTED 30006b3c: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 30006b40: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 30006b44: e1a0e00f mov lr, pc <== NOT EXECUTED 30006b48: e12fff1a bx sl <== NOT EXECUTED 30006b4c: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
30006b50: e2855001 add r5, r5, #1 <== NOT EXECUTED 30006b54: e1530005 cmp r3, r5 <== NOT EXECUTED 30006b58: 3a000029 bcc 30006c04 <rtems_cpu_usage_report_with_plugin+0x18c><== NOT EXECUTED
the_thread = (Thread_Control *)information->local_table[ i ];
30006b5c: e596001c ldr r0, [r6, #28] <== NOT EXECUTED
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
30006b60: e1a02007 mov r2, r7 <== NOT EXECUTED
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
30006b64: e7904105 ldr r4, [r0, r5, lsl #2] <== NOT EXECUTED
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
30006b68: e3a0100d mov r1, #13 <== NOT EXECUTED
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
30006b6c: e3540000 cmp r4, #0 <== NOT EXECUTED 30006b70: 0afffff6 beq 30006b50 <rtems_cpu_usage_report_with_plugin+0xd8><== NOT EXECUTED
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
30006b74: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED 30006b78: eb00112d bl 3000b034 <rtems_object_get_name> <== NOT EXECUTED
(*print)(
30006b7c: e1a03007 mov r3, r7 <== NOT EXECUTED 30006b80: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 30006b84: e59f10c8 ldr r1, [pc, #200] ; 30006c54 <rtems_cpu_usage_report_with_plugin+0x1dc><== NOT EXECUTED 30006b88: e1a0000b mov r0, fp <== NOT EXECUTED 30006b8c: e1a0e00f mov lr, pc <== NOT EXECUTED 30006b90: 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;
30006b94: e2841084 add r1, r4, #132 ; 0x84 <== NOT EXECUTED
30006b98: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
30006b9c: e59f30b4 ldr r3, [pc, #180] ; 30006c58 <rtems_cpu_usage_report_with_plugin+0x1e0><== 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;
30006ba0: e58d0038 str r0, [sp, #56] ; 0x38 <== NOT EXECUTED 30006ba4: e58d103c str r1, [sp, #60] ; 0x3c <== NOT EXECUTED
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
30006ba8: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 30006bac: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30006bb0: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 30006bb4: e1520003 cmp r2, r3 <== NOT EXECUTED 30006bb8: 1affffca bne 30006ae8 <rtems_cpu_usage_report_with_plugin+0x70><== NOT EXECUTED
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
30006bbc: e59f1098 ldr r1, [pc, #152] ; 30006c5c <rtems_cpu_usage_report_with_plugin+0x1e4><== NOT EXECUTED
_TOD_Get_uptime( &uptime );
30006bc0: 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;
30006bc4: e8910018 ldm r1, {r3, r4} <== NOT EXECUTED
30006bc8: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
30006bcc: e58d4024 str r4, [sp, #36] ; 0x24 <== NOT EXECUTED
_TOD_Get_uptime( &uptime );
30006bd0: eb0015ef bl 3000c394 <_TOD_Get_uptime> <== NOT EXECUTED
_Timestamp_Subtract( &last, &uptime, &used );
30006bd4: e28d3028 add r3, sp, #40 ; 0x28 <== NOT EXECUTED 30006bd8: e28d0020 add r0, sp, #32 <== NOT EXECUTED 30006bdc: e1a01008 mov r1, r8 <== NOT EXECUTED 30006be0: e1a02003 mov r2, r3 <== NOT EXECUTED 30006be4: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 30006be8: eb001f5b bl 3000e95c <_Timespec_Subtract> <== NOT EXECUTED
_Timestamp_Add_to( &ran, &used );
30006bec: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30006bf0: e28d4038 add r4, sp, #56 ; 0x38 <== NOT EXECUTED 30006bf4: e1a00004 mov r0, r4 <== NOT EXECUTED 30006bf8: e1a01003 mov r1, r3 <== NOT EXECUTED 30006bfc: eb001f1b bl 3000e870 <_Timespec_Add_to> <== NOT EXECUTED 30006c00: eaffffbb b 30006af4 <rtems_cpu_usage_report_with_plugin+0x7c><== NOT EXECUTED
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
30006c04: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 30006c08: e59f3050 ldr r3, [pc, #80] ; 30006c60 <rtems_cpu_usage_report_with_plugin+0x1e8><== NOT EXECUTED 30006c0c: e1520003 cmp r2, r3 <== NOT EXECUTED 30006c10: 1affffa7 bne 30006ab4 <rtems_cpu_usage_report_with_plugin+0x3c><== NOT EXECUTED
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
30006c14: e59d2044 ldr r2, [sp, #68] ; 0x44 <== NOT EXECUTED 30006c18: e59f302c ldr r3, [pc, #44] ; 30006c4c <rtems_cpu_usage_report_with_plugin+0x1d4><== NOT EXECUTED 30006c1c: e1a0000b mov r0, fp <== NOT EXECUTED 30006c20: e0831392 umull r1, r3, r2, r3 <== NOT EXECUTED 30006c24: e59f1038 ldr r1, [pc, #56] ; 30006c64 <rtems_cpu_usage_report_with_plugin+0x1ec><== NOT EXECUTED 30006c28: e59d2040 ldr r2, [sp, #64] ; 0x40 <== NOT EXECUTED 30006c2c: e1a03323 lsr r3, r3, #6 <== NOT EXECUTED 30006c30: e1a0e00f mov lr, pc <== NOT EXECUTED 30006c34: e12fff1a bx sl <== NOT EXECUTED
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
30006c38: e28dd058 add sp, sp, #88 ; 0x58 <== NOT EXECUTED
30006c3c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30006c88 <rtems_cpu_usage_reset>:
/*
* rtems_cpu_usage_reset
*/
void rtems_cpu_usage_reset( void )
{
30006c88: e92d4010 push {r4, lr} <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &CPU_usage_Uptime_at_last_reset );
30006c8c: e59f401c ldr r4, [pc, #28] ; 30006cb0 <rtems_cpu_usage_reset+0x28><== NOT EXECUTED 30006c90: e1a00004 mov r0, r4 <== NOT EXECUTED 30006c94: eb0015be bl 3000c394 <_TOD_Get_uptime> <== NOT EXECUTED
_Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
30006c98: e8940006 ldm r4, {r1, r2} <== NOT EXECUTED
30006c9c: e59f3010 ldr r3, [pc, #16] ; 30006cb4 <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);
30006ca0: e59f0010 ldr r0, [pc, #16] ; 30006cb8 <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;
30006ca4: 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);
}
30006ca8: 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);
30006cac: ea00173a b 3000c99c <rtems_iterate_over_all_threads> <== NOT EXECUTED
30011fb8 <rtems_deviceio_errno>:
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
30011fb8: e2503000 subs r3, r0, #0
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
30011fbc: e92d4010 push {r4, lr}
if (sc == RTEMS_SUCCESSFUL) {
30011fc0: 1a000001 bne 30011fcc <rtems_deviceio_errno+0x14>
errno = eno;
return -1;
}
}
30011fc4: e1a00003 mov r0, r3
30011fc8: e8bd8010 pop {r4, pc}
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
30011fcc: e353001c cmp r3, #28 <== NOT EXECUTED
eno = status_code_to_errno [sc];
30011fd0: 959f2014 ldrls r2, [pc, #20] ; 30011fec <rtems_deviceio_errno+0x34><== NOT EXECUTED
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
30011fd4: 83a04016 movhi r4, #22 <== NOT EXECUTED
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
30011fd8: 97924103 ldrls r4, [r2, r3, lsl #2] <== NOT EXECUTED
}
errno = eno;
30011fdc: eb000024 bl 30012074 <__errno> <== NOT EXECUTED
return -1;
30011fe0: e3e03000 mvn r3, #0 <== NOT EXECUTED
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
30011fe4: e5804000 str r4, [r0] <== NOT EXECUTED
return -1;
30011fe8: eafffff5 b 30011fc4 <rtems_deviceio_errno+0xc> <== NOT EXECUTED
3000b0ac <rtems_error>:
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
3000b0ac: e92d000e push {r1, r2, r3} <== NOT EXECUTED
3000b0b0: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b0b4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
3000b0b8: e28d3010 add r3, sp, #16 <== NOT EXECUTED
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
3000b0bc: e1a04000 mov r4, r0 <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
chars_written = rtems_verror(error_flag, printf_format, arglist);
3000b0c0: e1a02003 mov r2, r3 <== NOT EXECUTED 3000b0c4: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
)
{
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
3000b0c8: e58d3000 str r3, [sp] <== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
3000b0cc: ebffff9c bl 3000af44 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
if (error_flag & RTEMS_ERROR_PANIC) {
3000b0d0: e2143202 ands r3, r4, #536870912 ; 0x20000000 <== NOT EXECUTED 3000b0d4: 1a000005 bne 3000b0f0 <rtems_error+0x44> <== NOT EXECUTED
rtems_error(0, "fatal error, exiting");
_exit(errno);
}
if (error_flag & RTEMS_ERROR_ABORT) {
3000b0d8: e3140201 tst r4, #268435456 ; 0x10000000 <== NOT EXECUTED 3000b0dc: 1a000009 bne 3000b108 <rtems_error+0x5c> <== NOT EXECUTED
rtems_error(0, "fatal error, aborting");
abort();
}
return chars_written;
}
3000b0e0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b0e4: e8bd4010 pop {r4, lr} <== NOT EXECUTED
3000b0e8: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000b0ec: e12fff1e bx lr <== NOT EXECUTED
va_start(arglist, printf_format);
chars_written = rtems_verror(error_flag, printf_format, arglist);
va_end(arglist);
if (error_flag & RTEMS_ERROR_PANIC) {
rtems_error(0, "fatal error, exiting");
3000b0f0: e59f1020 ldr r1, [pc, #32] ; 3000b118 <rtems_error+0x6c> <== NOT EXECUTED 3000b0f4: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b0f8: ebffffeb bl 3000b0ac <rtems_error> <== NOT EXECUTED
_exit(errno);
3000b0fc: eb0031a3 bl 30017790 <__errno> <== NOT EXECUTED 3000b100: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000b104: eb0002c4 bl 3000bc1c <_exit> <== NOT EXECUTED
}
if (error_flag & RTEMS_ERROR_ABORT) {
rtems_error(0, "fatal error, aborting");
3000b108: e59f100c ldr r1, [pc, #12] ; 3000b11c <rtems_error+0x70> <== NOT EXECUTED 3000b10c: e1a00003 mov r0, r3 <== NOT EXECUTED 3000b110: ebffffe5 bl 3000b0ac <rtems_error> <== NOT EXECUTED
abort();
3000b114: eb003193 bl 30017768 <abort> <== NOT EXECUTED
30009554 <rtems_event_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
30009554: e92d4070 push {r4, r5, r6, lr}
RTEMS_API_Control *api;
if ( !event_out )
30009558: e2536000 subs r6, r3, #0
3000955c: 0a000010 beq 300095a4 <rtems_event_receive+0x50>
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
30009560: e59f4044 ldr r4, [pc, #68] ; 300095ac <rtems_event_receive+0x58>
if ( _Event_sets_Is_empty( event_in ) ) {
30009564: e3500000 cmp r0, #0
RTEMS_API_Control *api;
if ( !event_out )
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
30009568: e5945004 ldr r5, [r4, #4] 3000956c: e59550f8 ldr r5, [r5, #248] ; 0xf8
if ( _Event_sets_Is_empty( event_in ) ) {
30009570: 1a000002 bne 30009580 <rtems_event_receive+0x2c>
*event_out = api->pending_events;
30009574: e5953000 ldr r3, [r5] 30009578: e5863000 str r3, [r6]
return RTEMS_SUCCESSFUL;
3000957c: e8bd8070 pop {r4, r5, r6, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009580: e59fc028 ldr ip, [pc, #40] ; 300095b0 <rtems_event_receive+0x5c> 30009584: e59ce000 ldr lr, [ip] 30009588: e28ee001 add lr, lr, #1 3000958c: e58ce000 str lr, [ip]
}
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
30009590: eb000007 bl 300095b4 <_Event_Seize>
_Thread_Enable_dispatch();
30009594: eb000ad9 bl 3000c100 <_Thread_Enable_dispatch>
return( _Thread_Executing->Wait.return_code );
30009598: e5943004 ldr r3, [r4, #4]
3000959c: e5930034 ldr r0, [r3, #52] ; 0x34
300095a0: e8bd8070 pop {r4, r5, r6, pc}
)
{
RTEMS_API_Control *api;
if ( !event_out )
return RTEMS_INVALID_ADDRESS;
300095a4: 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 );
}
300095a8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000baec <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000baec: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Extension_Control *the_extension;
if ( !id )
3000baf0: e2526000 subs r6, r2, #0
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000baf4: e1a04000 mov r4, r0 3000baf8: e1a08001 mov r8, r1
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000bafc: 03a00009 moveq r0, #9
rtems_id *id
)
{
Extension_Control *the_extension;
if ( !id )
3000bb00: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
3000bb04: e3540000 cmp r4, #0
3000bb08: 1a000001 bne 3000bb14 <rtems_extension_create+0x28>
return RTEMS_INVALID_NAME;
3000bb0c: e3a00003 mov r0, #3 <== NOT EXECUTED
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000bb10: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000bb14: e59f306c ldr r3, [pc, #108] ; 3000bb88 <rtems_extension_create+0x9c> 3000bb18: e5932000 ldr r2, [r3] 3000bb1c: e2822001 add r2, r2, #1 3000bb20: 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 );
3000bb24: e59f7060 ldr r7, [pc, #96] ; 3000bb8c <rtems_extension_create+0xa0> 3000bb28: e1a00007 mov r0, r7 3000bb2c: eb0003b5 bl 3000ca08 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
3000bb30: e2505000 subs r5, r0, #0
3000bb34: 0a000010 beq 3000bb7c <rtems_extension_create+0x90>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
3000bb38: e285c024 add ip, r5, #36 ; 0x24
3000bb3c: e1a0e008 mov lr, r8
3000bb40: e8be000f ldm lr!, {r0, r1, r2, r3}
3000bb44: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000bb48: e89e000f ldm lr, {r0, r1, r2, r3}
3000bb4c: e88c000f stm ip, {r0, r1, r2, r3}
_User_extensions_Add_set( extension );
3000bb50: e2850010 add r0, r5, #16 3000bb54: eb000b96 bl 3000e9b4 <_User_extensions_Add_set>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000bb58: e5953008 ldr r3, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000bb5c: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000bb60: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000bb64: e7825721 str r5, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000bb68: e585400c str r4, [r5, #12]
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
3000bb6c: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
3000bb70: eb000859 bl 3000dcdc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000bb74: e3a00000 mov r0, #0
3000bb78: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
_Thread_Enable_dispatch();
3000bb7c: eb000856 bl 3000dcdc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000bb80: e3a00005 mov r0, #5 <== NOT EXECUTED
3000bb84: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c78c <rtems_extension_ident>:
rtems_status_code rtems_extension_ident(
rtems_name name,
rtems_id *id
)
{
3000c78c: e1a02000 mov r2, r0 <== NOT EXECUTED
3000c790: e1a03001 mov r3, r1 <== NOT EXECUTED
3000c794: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
status = _Objects_Name_to_id_u32(
3000c798: e1a01002 mov r1, r2 <== NOT EXECUTED 3000c79c: e59f0010 ldr r0, [pc, #16] ; 3000c7b4 <rtems_extension_ident+0x28><== NOT EXECUTED 3000c7a0: e3e02102 mvn r2, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000c7a4: eb0004de bl 3000db24 <_Objects_Name_to_id_u32> <== NOT EXECUTED
name,
OBJECTS_SEARCH_LOCAL_NODE,
id
);
return _Status_Object_name_errors_to_status[ status ];
3000c7a8: e59f3008 ldr r3, [pc, #8] ; 3000c7b8 <rtems_extension_ident+0x2c><== NOT EXECUTED
}
3000c7ac: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
3000c7b0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300063f4 <rtems_filesystem_dirname>:
int rtems_filesystem_dirname(
const char *pathname
)
{
300063f4: e92d4030 push {r4, r5, lr}
300063f8: e1a05000 mov r5, r0
int len = strlen( pathname );
300063fc: eb003306 bl 3001301c <strlen>
while ( len ) {
30006400: e2504000 subs r4, r0, #0
30006404: 1a000002 bne 30006414 <rtems_filesystem_dirname+0x20>
30006408: ea000006 b 30006428 <rtems_filesystem_dirname+0x34> <== NOT EXECUTED
3000640c: e3540000 cmp r4, #0
30006410: 0a000004 beq 30006428 <rtems_filesystem_dirname+0x34>
len--;
30006414: e2444001 sub r4, r4, #1
if ( rtems_filesystem_is_separator( pathname[len] ) )
30006418: e7d50004 ldrb r0, [r5, r4] 3000641c: eb0003de bl 3000739c <rtems_filesystem_is_separator> 30006420: e3500000 cmp r0, #0
30006424: 0afffff8 beq 3000640c <rtems_filesystem_dirname+0x18>
break;
}
return len;
}
30006428: e1a00004 mov r0, r4
3000642c: e8bd8030 pop {r4, r5, pc}
300061cc <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 )
{
300061cc: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_filesystem_umask = 022;
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
300061d0: e59f20e8 ldr r2, [pc, #232] ; 300062c0 <rtems_filesystem_initialize+0xf4>
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
300061d4: e59f60e8 ldr r6, [pc, #232] ; 300062c4 <rtems_filesystem_initialize+0xf8>
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
300061d8: e5922000 ldr r2, [r2]
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
300061dc: e5963000 ldr r3, [r6]
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
300061e0: e3520000 cmp r2, #0
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
300061e4: e3a02012 mov r2, #18
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
300061e8: e24dd018 sub sp, sp, #24
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
300061ec: e583202c str r2, [r3, #44] ; 0x2c
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
300061f0: 0a00002c beq 300062a8 <rtems_filesystem_initialize+0xdc>
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
300061f4: e59f30cc ldr r3, [pc, #204] ; 300062c8 <rtems_filesystem_initialize+0xfc>
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
300061f8: 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];
300061fc: e5933000 ldr r3, [r3]
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
30006200: e5930008 ldr r0, [r3, #8]
30006204: e593100c ldr r1, [r3, #12]
30006208: e893000c ldm r3, {r2, r3}
3000620c: e58d5000 str r5, [sp]
30006210: eb000212 bl 30006a60 <mount>
if ( status == -1 )
30006214: e3700001 cmn r0, #1
30006218: 0a000026 beq 300062b8 <rtems_filesystem_initialize+0xec>
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
3000621c: e5963000 ldr r3, [r6]
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30006220: 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;
30006224: 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);
30006228: e3a01001 mov r1, #1 3000622c: e1a03004 mov r3, r4 30006230: e1a02005 mov r2, r5 30006234: e59f0090 ldr r0, [pc, #144] ; 300062cc <rtems_filesystem_initialize+0x100> 30006238: e58d5000 str r5, [sp] 3000623c: eb000056 bl 3000639c <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
30006240: e596c000 ldr ip, [r6]
30006244: e1a07004 mov r7, r4
30006248: e28cc018 add ip, ip, #24
3000624c: e8b7000f ldm r7!, {r0, r1, r2, r3}
30006250: e597e000 ldr lr, [r7]
30006254: e8ac000f stmia ip!, {r0, r1, r2, r3}
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30006258: 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;
3000625c: e58ce000 str lr, [ip]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30006260: e1a02005 mov r2, r5 30006264: e1a03004 mov r3, r4 30006268: e59f005c ldr r0, [pc, #92] ; 300062cc <rtems_filesystem_initialize+0x100> 3000626c: e58d5000 str r5, [sp] 30006270: eb000049 bl 3000639c <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
30006274: e8b4000f ldm r4!, {r0, r1, r2, r3}
30006278: e596c000 ldr ip, [r6]
3000627c: e597e000 ldr lr, [r7]
30006280: e28cc004 add ip, ip, #4
30006284: e8ac000f stmia ip!, {r0, r1, r2, r3}
*
* 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);
30006288: e59f0040 ldr r0, [pc, #64] ; 300062d0 <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;
3000628c: e58ce000 str lr, [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);
30006290: e59f103c ldr r1, [pc, #60] ; 300062d4 <rtems_filesystem_initialize+0x108> 30006294: eb000196 bl 300068f4 <mkdir>
if ( status != 0 )
30006298: e3500000 cmp r0, #0
3000629c: 1a000003 bne 300062b0 <rtems_filesystem_initialize+0xe4> * 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. */ }
300062a0: e28dd018 add sp, sp, #24
300062a4: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
300062a8: e59f0028 ldr r0, [pc, #40] ; 300062d8 <rtems_filesystem_initialize+0x10c><== NOT EXECUTED 300062ac: eb000fd0 bl 3000a1f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
300062b0: e59f0024 ldr r0, [pc, #36] ; 300062dc <rtems_filesystem_initialize+0x110><== NOT EXECUTED 300062b4: eb000fce bl 3000a1f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
300062b8: e59f0020 ldr r0, [pc, #32] ; 300062e0 <rtems_filesystem_initialize+0x114><== NOT EXECUTED 300062bc: eb000fcc bl 3000a1f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
3000ea8c <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
3000ea8c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
3000ea90: e59f60ac ldr r6, [pc, #172] ; 3000eb44 <rtems_filesystem_iterate+0xb8>
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
3000ea94: e1a04000 mov r4, r0
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
3000ea98: e5963000 ldr r3, [r6]
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
3000ea9c: e1a05001 mov r5, r1
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
3000eaa0: e3530000 cmp r3, #0
3000eaa4: 1a000002 bne 3000eab4 <rtems_filesystem_iterate+0x28>
3000eaa8: ea00000c b 3000eae0 <rtems_filesystem_iterate+0x54> <== NOT EXECUTED
3000eaac: e3500000 cmp r0, #0
3000eab0: 1a000021 bne 3000eb3c <rtems_filesystem_iterate+0xb0>
stop = (*routine)( table_entry, routine_arg );
3000eab4: e1a00006 mov r0, r6 3000eab8: e1a01005 mov r1, r5 3000eabc: e1a0e00f mov lr, pc 3000eac0: e12fff14 bx r4
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
3000eac4: e5963008 ldr r3, [r6, #8]
stop = (*routine)( table_entry, routine_arg );
3000eac8: e1a0a000 mov sl, r0
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
3000eacc: e3530000 cmp r3, #0 3000ead0: e2866008 add r6, r6, #8
3000ead4: 1afffff4 bne 3000eaac <rtems_filesystem_iterate+0x20>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
3000ead8: e3500000 cmp r0, #0
3000eadc: 1a000016 bne 3000eb3c <rtems_filesystem_iterate+0xb0>
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 );
3000eae0: e59f7060 ldr r7, [pc, #96] ; 3000eb48 <rtems_filesystem_iterate+0xbc> 3000eae4: e3a01000 mov r1, #0
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
3000eae8: e59f605c ldr r6, [pc, #92] ; 3000eb4c <rtems_filesystem_iterate+0xc0> 3000eaec: e5970000 ldr r0, [r7] 3000eaf0: e1a02001 mov r2, r1 3000eaf4: ebffec16 bl 30009b54 <rtems_semaphore_obtain> 3000eaf8: e4968004 ldr r8, [r6], #4
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
3000eafc: e1580006 cmp r8, r6 3000eb00: 03a0a000 moveq sl, #0
3000eb04: 1a000002 bne 3000eb14 <rtems_filesystem_iterate+0x88>
3000eb08: ea000009 b 3000eb34 <rtems_filesystem_iterate+0xa8>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
3000eb0c: e3500000 cmp r0, #0
3000eb10: 1a000007 bne 3000eb34 <rtems_filesystem_iterate+0xa8>
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
3000eb14: e2880008 add r0, r8, #8 3000eb18: e1a01005 mov r1, r5 3000eb1c: e1a0e00f mov lr, pc 3000eb20: e12fff14 bx r4
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
3000eb24: e5988000 ldr r8, [r8]
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
3000eb28: e1a0a000 mov sl, r0
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
3000eb2c: e1580006 cmp r8, r6
3000eb30: 1afffff5 bne 3000eb0c <rtems_filesystem_iterate+0x80>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3000eb34: e5970000 ldr r0, [r7] 3000eb38: ebffec4e bl 30009c78 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
return stop;
}
3000eb3c: e1a0000a mov r0, sl
3000eb40: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
300069e8 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
300069e8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
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 );
300069ec: e59f7064 ldr r7, [pc, #100] ; 30006a58 <rtems_filesystem_mount_iterate+0x70>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
300069f0: e59f4064 ldr r4, [pc, #100] ; 30006a5c <rtems_filesystem_mount_iterate+0x74>
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
300069f4: e1a06001 mov r6, r1 300069f8: e3a01000 mov r1, #0 300069fc: e1a05000 mov r5, r0 30006a00: e1a02001 mov r2, r1 30006a04: e5970000 ldr r0, [r7] 30006a08: eb000c51 bl 30009b54 <rtems_semaphore_obtain>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
30006a0c: e4948004 ldr r8, [r4], #4
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
30006a10: e1580004 cmp r8, r4
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
30006a14: 03a0a000 moveq sl, #0
rtems_libio_lock();
for (
30006a18: 1a000002 bne 30006a28 <rtems_filesystem_mount_iterate+0x40>
30006a1c: ea000009 b 30006a48 <rtems_filesystem_mount_iterate+0x60> <== NOT EXECUTED
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
30006a20: e3500000 cmp r0, #0
30006a24: 1a000007 bne 30006a48 <rtems_filesystem_mount_iterate+0x60>
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
30006a28: e1a00008 mov r0, r8 30006a2c: e1a01006 mov r1, r6 30006a30: e1a0e00f mov lr, pc 30006a34: e12fff15 bx r5
}
rtems_libio_unlock();
return stop;
}
30006a38: e5988000 ldr r8, [r8]
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
30006a3c: e1a0a000 mov sl, r0
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
30006a40: e1580004 cmp r8, r4
30006a44: 1afffff5 bne 30006a20 <rtems_filesystem_mount_iterate+0x38>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
30006a48: e5970000 ldr r0, [r7] 30006a4c: eb000c89 bl 30009c78 <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
30006a50: e1a0000a mov r0, sl
30006a54: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
30006430 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
30006430: e92d4070 push {r4, r5, r6, lr}
30006434: e1a05000 mov r5, r0
/* * Eat any separators at start of the path. */ int stripped = 0; while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
30006438: e5d00000 ldrb r0, [r0] 3000643c: e1a06001 mov r6, r1 30006440: e3510000 cmp r1, #0 30006444: 13500000 cmpne r0, #0 30006448: 03a04000 moveq r4, #0 3000644c: 13a04001 movne r4, #1
)
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
30006450: 13a04000 movne r4, #0
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) ) 30006454: 1a000005 bne 30006470 <rtems_filesystem_prefix_separators+0x40>
30006458: ea000007 b 3000647c <rtems_filesystem_prefix_separators+0x4c><== NOT EXECUTED
3000645c: e5f50001 ldrb r0, [r5, #1]!
{
pathname++;
pathnamelen--;
stripped++;
30006460: e2844001 add r4, r4, #1
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
30006464: e1560004 cmp r6, r4 30006468: 13500000 cmpne r0, #0
3000646c: 0a000002 beq 3000647c <rtems_filesystem_prefix_separators+0x4c>
30006470: eb0003c9 bl 3000739c <rtems_filesystem_is_separator> 30006474: e3500000 cmp r0, #0
30006478: 1afffff7 bne 3000645c <rtems_filesystem_prefix_separators+0x2c>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
3000647c: e1a00004 mov r0, r4
30006480: e8bd8070 pop {r4, r5, r6, pc}
3000c5f4 <rtems_get_version_string>:
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
}
3000c5f4: e59f0000 ldr r0, [pc, #0] ; 3000c5fc <rtems_get_version_string+0x8><== NOT EXECUTED 3000c5f8: e12fff1e bx lr <== NOT EXECUTED
300070ec <rtems_gxx_getspecific>:
void *rtems_gxx_getspecific(__gthread_key_t key)
{
300070ec: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
300070f0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
rtems_status_code status; void *p= 0;
300070f4: e3a05000 mov r5, #0 <== NOT EXECUTED
key = NULL;
return 0;
}
void *rtems_gxx_getspecific(__gthread_key_t key)
{
300070f8: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code status; void *p= 0;
300070fc: e28d2004 add r2, sp, #4 <== NOT EXECUTED 30007100: 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 );
30007104: e1a00005 mov r0, r5 <== NOT EXECUTED 30007108: e1a01004 mov r1, r4 <== NOT EXECUTED 3000710c: e1a0200d mov r2, sp <== NOT EXECUTED 30007110: eb000f84 bl 3000af28 <rtems_task_variable_get> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
30007114: e1500005 cmp r0, r5 <== NOT EXECUTED
/* We do not have to do this, but what the heck ! */
p= key->val;
30007118: 05940000 ldreq r0, [r4] <== 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 ) {
3000711c: 1a000001 bne 30007128 <rtems_gxx_getspecific+0x3c> <== NOT EXECUTED
p,
rtems_task_self()
);
#endif
return p;
}
30007120: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30007124: e8bd8030 pop {r4, r5, pc} <== 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 );
30007128: e1a00005 mov r0, r5 <== NOT EXECUTED 3000712c: e1a01004 mov r1, r4 <== NOT EXECUTED 30007130: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 30007134: eb000f28 bl 3000addc <rtems_task_variable_add> <== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL ) {
30007138: e2503000 subs r3, r0, #0 <== NOT EXECUTED
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_GXX_KEY_ADD_FAILED
);
}
key->val = (void *)0;
3000713c: 059d0000 ldreq r0, [sp] <== NOT EXECUTED 30007140: 05843000 streq r3, [r4] <== NOT EXECUTED 30007144: 0afffff5 beq 30007120 <rtems_gxx_getspecific+0x34> <== 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(
30007148: e1a00005 mov r0, r5 <== NOT EXECUTED 3000714c: e3a01001 mov r1, #1 <== NOT EXECUTED 30007150: e3a02015 mov r2, #21 <== NOT EXECUTED 30007154: eb001337 bl 3000be38 <_Internal_error_Occurred> <== NOT EXECUTED
30007060 <rtems_gxx_key_create>:
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
30007060: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30007064: 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 ) );
30007068: e3a00008 mov r0, #8 <== NOT EXECUTED
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
3000706c: 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 ) );
30007070: eb000107 bl 30007494 <malloc> <== NOT EXECUTED
*key = new_key; new_key->val = NULL;
30007074: e3a03000 mov r3, #0 <== 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 ) );
30007078: e1a04000 mov r4, r0 <== NOT EXECUTED
*key = new_key;
3000707c: 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 );
30007080: e1a01004 mov r1, r4 <== NOT EXECUTED 30007084: e1a00003 mov r0, r3 <== NOT EXECUTED 30007088: 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;
3000708c: e8840028 stm r4, {r3, 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 );
30007090: eb000f51 bl 3000addc <rtems_task_variable_add> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
30007094: e3500000 cmp r0, #0 <== NOT EXECUTED
30007098: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return 0;
free( new_key );
3000709c: e1a00004 mov r0, r4 <== NOT EXECUTED 300070a0: ebffff87 bl 30006ec4 <free> <== NOT EXECUTED
return -1;
300070a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
300070a8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300070bc <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
300070bc: e92d4010 push {r4, lr} <== 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 );
300070c0: e1a01000 mov r1, r0 <== NOT EXECUTED
key->val = 0;
return 0;
}
int rtems_gxx_key_delete (__gthread_key_t key)
{
300070c4: 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 );
300070c8: e3a00000 mov r0, #0 <== NOT EXECUTED 300070cc: eb000f6e bl 3000ae8c <rtems_task_variable_delete> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
300070d0: e3500000 cmp r0, #0 <== NOT EXECUTED 300070d4: 1a000002 bne 300070e4 <rtems_gxx_key_delete+0x28> <== NOT EXECUTED
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
300070d8: e3540000 cmp r4, #0 <== NOT EXECUTED 300070dc: 15940000 ldrne r0, [r4] <== NOT EXECUTED 300070e0: 1bffff77 blne 30006ec4 <free> <== NOT EXECUTED
return 0;
}
key = NULL;
return 0;
}
300070e4: e3a00000 mov r0, #0 <== NOT EXECUTED
300070e8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300070ac <rtems_gxx_key_dtor>:
{
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: dtor key=%x, ptr=%x\n", key, ptr );
#endif
key->val = 0;
300070ac: e3a03000 mov r3, #0 <== NOT EXECUTED 300070b0: e5803000 str r3, [r0] <== NOT EXECUTED
return 0; }
300070b4: e1a00003 mov r0, r3 <== NOT EXECUTED 300070b8: e12fff1e bx lr <== NOT EXECUTED
300071e8 <rtems_gxx_mutex_destroy>:
int rtems_gxx_mutex_destroy (__gthread_mutex_t *mutex)
{
300071e8: 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);
300071ec: e5900000 ldr r0, [r0] <== NOT EXECUTED 300071f0: eb000d53 bl 3000a744 <rtems_semaphore_delete> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
300071f4: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
300071f8: 13e00000 mvnne r0, #0 <== NOT EXECUTED
300071fc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007184 <rtems_gxx_mutex_init>:
/*
* MUTEX support
*/
void rtems_gxx_mutex_init (__gthread_mutex_t *mutex)
{
30007184: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007188: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: mutex init =%X\n", *mutex );
#endif
status = rtems_semaphore_create(
3000718c: e58d0000 str r0, [sp] <== NOT EXECUTED 30007190: e3a01001 mov r1, #1 <== NOT EXECUTED 30007194: e59f0028 ldr r0, [pc, #40] ; 300071c4 <rtems_gxx_mutex_init+0x40><== NOT EXECUTED 30007198: e3a02054 mov r2, #84 ; 0x54 <== NOT EXECUTED 3000719c: e3a03000 mov r3, #0 <== NOT EXECUTED 300071a0: eb000cf6 bl 3000a580 <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 ) {
300071a4: e3500000 cmp r0, #0 <== NOT EXECUTED 300071a8: 1a000001 bne 300071b4 <rtems_gxx_mutex_init+0x30> <== NOT EXECUTED
);
}
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );
#endif
}
300071ac: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300071b0: e8bd8000 pop {pc} <== NOT EXECUTED
"gxx_wrappers: mutex init failed %s (%d)\n",
rtems_status_text(status),
status
);
#endif
_Internal_error_Occurred(
300071b4: e3a00000 mov r0, #0 <== NOT EXECUTED 300071b8: e3a01001 mov r1, #1 <== NOT EXECUTED 300071bc: e3a02016 mov r2, #22 <== NOT EXECUTED 300071c0: eb00131c bl 3000be38 <_Internal_error_Occurred> <== NOT EXECUTED
300071c8 <rtems_gxx_mutex_lock>:
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: lock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain(
300071c8: 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)
{
300071cc: 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(
300071d0: e1a02001 mov r2, r1 <== NOT EXECUTED 300071d4: e5900000 ldr r0, [r0] <== NOT EXECUTED 300071d8: eb000d82 bl 3000a7e8 <rtems_semaphore_obtain> <== NOT EXECUTED
*(rtems_id *)mutex,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( status == RTEMS_SUCCESSFUL )
300071dc: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
300071e0: 13e00000 mvnne r0, #0 <== NOT EXECUTED
300071e4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007200 <rtems_gxx_mutex_trylock>:
int rtems_gxx_mutex_trylock (__gthread_mutex_t *mutex)
{
30007200: 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);
30007204: e3a01001 mov r1, #1 <== NOT EXECUTED 30007208: e3a02000 mov r2, #0 <== NOT EXECUTED 3000720c: e5900000 ldr r0, [r0] <== NOT EXECUTED 30007210: eb000d74 bl 3000a7e8 <rtems_semaphore_obtain> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
30007214: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
30007218: 13e00000 mvnne r0, #0 <== NOT EXECUTED
3000721c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007220 <rtems_gxx_mutex_unlock>:
int rtems_gxx_mutex_unlock (__gthread_mutex_t *mutex)
{
30007220: 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 );
30007224: e5900000 ldr r0, [r0] <== NOT EXECUTED 30007228: eb000db7 bl 3000a90c <rtems_semaphore_release> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
3000722c: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
30007230: 13e00000 mvnne r0, #0 <== NOT EXECUTED
30007234: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006fe0 <rtems_gxx_once>:
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
30006fe0: e92d4070 push {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 ) {
30006fe4: 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))
{
30006fe8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
30006fec: 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))
{
30006ff0: e1a04000 mov r4, r0 <== NOT EXECUTED 30006ff4: e1a05001 mov r5, 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 ) {
30006ff8: 0a000002 beq 30007008 <rtems_gxx_once+0x28> <== NOT EXECUTED
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
30006ffc: e3a00000 mov r0, #0 <== NOT EXECUTED
30007000: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30007004: e8bd8070 pop {r4, r5, r6, pc} <== 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);
30007008: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED 3000700c: e1a01000 mov r1, r0 <== NOT EXECUTED 30007010: e1a0200d mov r2, sp <== NOT EXECUTED 30007014: eb000ef9 bl 3000ac00 <rtems_task_mode> <== NOT EXECUTED
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
30007018: e5943000 ldr r3, [r4] <== 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);
3000701c: e1a0600d mov r6, sp <== NOT EXECUTED
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
30007020: e3530000 cmp r3, #0 <== NOT EXECUTED 30007024: 1a000008 bne 3000704c <rtems_gxx_once+0x6c> <== NOT EXECUTED
*(volatile __gthread_once_t *)once = 1;
30007028: e3a03001 mov r3, #1 <== NOT EXECUTED 3000702c: e5843000 str r3, [r4] <== NOT EXECUTED
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
30007030: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED 30007034: e1a0200d mov r2, sp <== NOT EXECUTED 30007038: e59d0000 ldr r0, [sp] <== NOT EXECUTED 3000703c: eb000eef bl 3000ac00 <rtems_task_mode> <== NOT EXECUTED
if ( o == 0 )
(*func)();
30007040: e1a0e00f mov lr, pc <== NOT EXECUTED 30007044: e12fff15 bx r5 <== NOT EXECUTED 30007048: eaffffeb b 30006ffc <rtems_gxx_once+0x1c> <== NOT EXECUTED
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
3000704c: e59d0000 ldr r0, [sp] <== NOT EXECUTED 30007050: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED 30007054: e1a0200d mov r2, sp <== NOT EXECUTED 30007058: eb000ee8 bl 3000ac00 <rtems_task_mode> <== NOT EXECUTED 3000705c: eaffffe6 b 30006ffc <rtems_gxx_once+0x1c> <== NOT EXECUTED
30007238 <rtems_gxx_recursive_mutex_init>:
void rtems_gxx_recursive_mutex_init(__gthread_recursive_mutex_t *mutex)
{
rtems_gxx_mutex_init(mutex);
30007238: eaffffd1 b 30007184 <rtems_gxx_mutex_init> <== NOT EXECUTED
3000723c <rtems_gxx_recursive_mutex_lock>:
}
int rtems_gxx_recursive_mutex_lock(__gthread_recursive_mutex_t *mutex)
{
return rtems_gxx_mutex_lock(mutex);
3000723c: eaffffe1 b 300071c8 <rtems_gxx_mutex_lock> <== NOT EXECUTED
30007240 <rtems_gxx_recursive_mutex_trylock>:
}
int rtems_gxx_recursive_mutex_trylock(__gthread_recursive_mutex_t *mutex)
{
return rtems_gxx_mutex_trylock(mutex);
30007240: eaffffee b 30007200 <rtems_gxx_mutex_trylock> <== NOT EXECUTED
30007244 <rtems_gxx_recursive_mutex_unlock>:
}
int rtems_gxx_recursive_mutex_unlock(__gthread_recursive_mutex_t *mutex)
{
return rtems_gxx_mutex_unlock(mutex);
30007244: eafffff5 b 30007220 <rtems_gxx_mutex_unlock> <== NOT EXECUTED
30007158 <rtems_gxx_setspecific>:
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
30007158: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000715c: e1a04000 mov r4, r0 <== NOT EXECUTED
30007160: 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 );
30007164: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 30007168: e1a01004 mov r1, r4 <== NOT EXECUTED 3000716c: e3a00000 mov r0, #0 <== NOT EXECUTED 30007170: eb000f19 bl 3000addc <rtems_task_variable_add> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
30007174: e3500000 cmp r0, #0 <== NOT EXECUTED
/* now let's set the proper value */
key->val = (void *)ptr;
30007178: 05845000 streq r5, [r4] <== NOT EXECUTED
return 0;
}
return -1;
3000717c: 13e00000 mvnne r0, #0 <== NOT EXECUTED
}
30007180: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b810 <rtems_heap_allocate_aligned_with_boundary>:
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
if (
3000b810: e59f3048 ldr r3, [pc, #72] ; 3000b860 <rtems_heap_allocate_aligned_with_boundary+0x50><== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b814: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if (
3000b818: e5933000 ldr r3, [r3] <== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b81c: e1a06000 mov r6, r0 <== NOT EXECUTED
if (
3000b820: e3530003 cmp r3, #3 <== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b824: e1a05001 mov r5, r1 <== NOT EXECUTED 3000b828: e1a04002 mov r4, r2 <== NOT EXECUTED
if (
3000b82c: 0a000007 beq 3000b850 <rtems_heap_allocate_aligned_with_boundary+0x40><== NOT EXECUTED
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
3000b830: ebfffba7 bl 3000a6d4 <malloc_deferred_frees_process> <== NOT EXECUTED
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
3000b834: e59f3028 ldr r3, [pc, #40] ; 3000b864 <rtems_heap_allocate_aligned_with_boundary+0x54><== NOT EXECUTED 3000b838: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b83c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000b840: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b844: e1a03004 mov r3, r4 <== NOT EXECUTED
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
3000b848: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
malloc_deferred_frees_process();
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
3000b84c: ea0014dd b 30010bc8 <_Protected_heap_Allocate_aligned_with_boundary><== NOT EXECUTED
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
3000b850: ebfffb8b bl 3000a684 <malloc_is_system_state_OK> <== NOT EXECUTED
3000b854: e3500000 cmp r0, #0 <== NOT EXECUTED
3000b858: 1afffff4 bne 3000b830 <rtems_heap_allocate_aligned_with_boundary+0x20><== NOT EXECUTED
3000b85c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000a9fc <rtems_interrupt_disable>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a9fc: e10f0000 mrs r0, CPSR <== NOT EXECUTED 3000aa00: e3803080 orr r3, r0, #128 ; 0x80 <== NOT EXECUTED 3000aa04: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_level previous_level;
_ISR_Disable( previous_level );
return previous_level;
}
3000aa08: e12fff1e bx lr <== NOT EXECUTED
3000aa0c <rtems_interrupt_enable>:
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000aa0c: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
void rtems_interrupt_enable(
rtems_interrupt_level previous_level
)
{
_ISR_Enable( previous_level );
}
3000aa10: e12fff1e bx lr <== NOT EXECUTED
3000aa14 <rtems_interrupt_flash>:
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000aa14: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000aa18: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3000aa1c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
void rtems_interrupt_flash(
rtems_interrupt_level previous_level
)
{
_ISR_Flash( previous_level );
}
3000aa20: e12fff1e bx lr <== NOT EXECUTED
3000aa24 <rtems_interrupt_is_in_progress>:
#undef rtems_interrupt_is_in_progress
bool rtems_interrupt_is_in_progress( void )
{
return _ISR_Is_in_progress();
3000aa24: e59f300c ldr r3, [pc, #12] ; 3000aa38 <rtems_interrupt_is_in_progress+0x14><== NOT EXECUTED 3000aa28: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
3000aa2c: e2500000 subs r0, r0, #0 <== NOT EXECUTED 3000aa30: 13a00001 movne r0, #1 <== NOT EXECUTED 3000aa34: e12fff1e bx lr <== NOT EXECUTED
3000a3cc <rtems_interrupt_level_attribute>:
rtems_attribute rtems_interrupt_level_attribute(
uint32_t level
)
{
return RTEMS_INTERRUPT_LEVEL(level);
}
3000a3cc: e2000080 and r0, r0, #128 ; 0x80 <== NOT EXECUTED 3000a3d0: e12fff1e bx lr <== NOT EXECUTED
30011cbc <rtems_io_close>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011cbc: e59fc044 ldr ip, [pc, #68] ; 30011d08 <rtems_io_close+0x4c>
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011cc0: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011cc4: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011cc8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011ccc: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30011cd0: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011cd4: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
30011cd8: e59fc02c ldr ip, [pc, #44] ; 30011d0c <rtems_io_close+0x50> 30011cdc: e0833083 add r3, r3, r3, lsl #1 30011ce0: e59cc000 ldr ip, [ip] 30011ce4: e08c3183 add r3, ip, r3, lsl #3 30011ce8: e5933008 ldr r3, [r3, #8]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30011cec: e3530000 cmp r3, #0
30011cf0: 0a000002 beq 30011d00 <rtems_io_close+0x44>
30011cf4: e1a0e00f mov lr, pc
30011cf8: e12fff13 bx r3
30011cfc: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30011d00: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30011d04: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30011d10 <rtems_io_control>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011d10: e59fc044 ldr ip, [pc, #68] ; 30011d5c <rtems_io_control+0x4c>
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011d14: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011d18: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011d1c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011d20: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30011d24: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011d28: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
30011d2c: e59fc02c ldr ip, [pc, #44] ; 30011d60 <rtems_io_control+0x50> 30011d30: e0833083 add r3, r3, r3, lsl #1 30011d34: e59cc000 ldr ip, [ip] 30011d38: e08c3183 add r3, ip, r3, lsl #3 30011d3c: e5933014 ldr r3, [r3, #20]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30011d40: e3530000 cmp r3, #0
30011d44: 0a000002 beq 30011d54 <rtems_io_control+0x44>
30011d48: e1a0e00f mov lr, pc
30011d4c: e12fff13 bx r3
30011d50: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30011d54: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30011d58: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006128 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
30006128: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000612c: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30006130: e1a05000 mov r5, r0 <== NOT EXECUTED
30006134: e1a06001 mov r6, 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(
30006138: eb0033b7 bl 3001301c <strlen> <== NOT EXECUTED 3000613c: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30006140: e1a01000 mov r1, r0 <== NOT EXECUTED 30006144: e3a0c001 mov ip, #1 <== NOT EXECUTED 30006148: e3a02000 mov r2, #0 <== NOT EXECUTED 3000614c: e1a03004 mov r3, r4 <== NOT EXECUTED 30006150: e1a00005 mov r0, r5 <== NOT EXECUTED 30006154: e58dc000 str ip, [sp] <== NOT EXECUTED 30006158: eb00008f bl 3000639c <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 );
3000615c: 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(
30006160: e1a07000 mov r7, r0 <== NOT EXECUTED
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
30006164: 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;
30006168: e59d8004 ldr r8, [sp, #4] <== NOT EXECUTED
node_type = (*loc.ops->node_type_h)( &loc );
3000616c: e1a0e00f mov lr, pc <== NOT EXECUTED 30006170: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
30006174: e3570000 cmp r7, #0 <== NOT EXECUTED 30006178: 03500002 cmpeq r0, #2 <== NOT EXECUTED 3000617c: 03a07000 moveq r7, #0 <== NOT EXECUTED 30006180: 13a07001 movne r7, #1 <== NOT EXECUTED 30006184: 0a000004 beq 3000619c <rtems_io_lookup_name+0x74> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30006188: e1a00004 mov r0, r4 <== NOT EXECUTED 3000618c: eb0000bc bl 30006484 <rtems_filesystem_freenode> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
30006190: e3a0000d mov r0, #13 <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
return RTEMS_SUCCESSFUL;
}
30006194: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30006198: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
rtems_filesystem_freenode( &loc );
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
3000619c: e5865000 str r5, [r6] <== NOT EXECUTED
device_info->device_name_length = strlen( name );
300061a0: e1a00005 mov r0, r5 <== NOT EXECUTED 300061a4: eb00339c bl 3001301c <strlen> <== NOT EXECUTED 300061a8: e5860004 str r0, [r6, #4] <== NOT EXECUTED
device_info->major = the_jnode->info.device.major;
300061ac: e5983050 ldr r3, [r8, #80] ; 0x50 <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
300061b0: 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;
300061b4: e5863008 str r3, [r6, #8] <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
300061b8: e5983054 ldr r3, [r8, #84] ; 0x54 <== NOT EXECUTED 300061bc: e586300c str r3, [r6, #12] <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
300061c0: eb0000af bl 30006484 <rtems_filesystem_freenode> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300061c4: e1a00007 mov r0, r7 <== NOT EXECUTED 300061c8: eafffff1 b 30006194 <rtems_io_lookup_name+0x6c> <== NOT EXECUTED
30011d64 <rtems_io_open>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011d64: e59fc044 ldr ip, [pc, #68] ; 30011db0 <rtems_io_open+0x4c>
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011d68: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011d6c: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011d70: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011d74: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30011d78: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011d7c: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
30011d80: e59fc02c ldr ip, [pc, #44] ; 30011db4 <rtems_io_open+0x50> 30011d84: e0833083 add r3, r3, r3, lsl #1 30011d88: e59cc000 ldr ip, [ip] 30011d8c: e08c3183 add r3, ip, r3, lsl #3 30011d90: e5933004 ldr r3, [r3, #4]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30011d94: e3530000 cmp r3, #0
30011d98: 0a000002 beq 30011da8 <rtems_io_open+0x44>
30011d9c: e1a0e00f mov lr, pc
30011da0: e12fff13 bx r3
30011da4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30011da8: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30011dac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30011db8 <rtems_io_read>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011db8: e59fc044 ldr ip, [pc, #68] ; 30011e04 <rtems_io_read+0x4c>
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011dbc: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011dc0: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011dc4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011dc8: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30011dcc: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011dd0: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
30011dd4: e59fc02c ldr ip, [pc, #44] ; 30011e08 <rtems_io_read+0x50> 30011dd8: e0833083 add r3, r3, r3, lsl #1 30011ddc: e59cc000 ldr ip, [ip] 30011de0: e08c3183 add r3, ip, r3, lsl #3 30011de4: e593300c ldr r3, [r3, #12]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30011de8: e3530000 cmp r3, #0
30011dec: 0a000002 beq 30011dfc <rtems_io_read+0x44>
30011df0: e1a0e00f mov lr, pc
30011df4: e12fff13 bx r3
30011df8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30011dfc: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30011e00: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b7ac <rtems_io_register_driver>:
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000b7ac: e59fc150 ldr ip, [pc, #336] ; 3000b904 <rtems_io_register_driver+0x158>
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;
3000b7b0: e59f3150 ldr r3, [pc, #336] ; 3000b908 <rtems_io_register_driver+0x15c>
if ( rtems_interrupt_is_in_progress() )
3000b7b4: e59cc000 ldr ip, [ip]
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
)
{
3000b7b8: e92d4030 push {r4, r5, lr}
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000b7bc: e35c0000 cmp ip, #0
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
)
{
3000b7c0: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
3000b7c4: e5930000 ldr r0, [r3]
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
3000b7c8: 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() )
3000b7cc: 18bd8030 popne {r4, r5, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
3000b7d0: e3520000 cmp r2, #0
3000b7d4: 0a00003f beq 3000b8d8 <rtems_io_register_driver+0x12c>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
3000b7d8: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
3000b7dc: e5820000 str r0, [r2]
if ( driver_table == NULL )
3000b7e0: 0a00003c beq 3000b8d8 <rtems_io_register_driver+0x12c>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000b7e4: e591c000 ldr ip, [r1] 3000b7e8: e35c0000 cmp ip, #0
3000b7ec: 0a000036 beq 3000b8cc <rtems_io_register_driver+0x120>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
3000b7f0: e1500004 cmp r0, r4
3000b7f4: 9a000027 bls 3000b898 <rtems_io_register_driver+0xec>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b7f8: e59f010c ldr r0, [pc, #268] ; 3000b90c <rtems_io_register_driver+0x160> 3000b7fc: e590c000 ldr ip, [r0] 3000b800: e28cc001 add ip, ip, #1 3000b804: e580c000 str ip, [r0]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
3000b808: e3540000 cmp r4, #0
3000b80c: 1a000023 bne 3000b8a0 <rtems_io_register_driver+0xf4>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
3000b810: e593c000 ldr ip, [r3]
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
3000b814: e35c0000 cmp ip, #0
3000b818: 0a000030 beq 3000b8e0 <rtems_io_register_driver+0x134>
3000b81c: e59fe0ec ldr lr, [pc, #236] ; 3000b910 <rtems_io_register_driver+0x164> 3000b820: e59e3000 ldr r3, [lr] 3000b824: ea000003 b 3000b838 <rtems_io_register_driver+0x8c> 3000b828: e2844001 add r4, r4, #1 3000b82c: e15c0004 cmp ip, r4 3000b830: e2833018 add r3, r3, #24
3000b834: 9a000005 bls 3000b850 <rtems_io_register_driver+0xa4>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000b838: e5930000 ldr r0, [r3] 3000b83c: e3500000 cmp r0, #0
3000b840: 1afffff8 bne 3000b828 <rtems_io_register_driver+0x7c>
3000b844: e5930004 ldr r0, [r3, #4] 3000b848: e3500000 cmp r0, #0
3000b84c: 1afffff5 bne 3000b828 <rtems_io_register_driver+0x7c>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
3000b850: e15c0004 cmp ip, r4 3000b854: 1084c084 addne ip, r4, r4, lsl #1
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
3000b858: e5824000 str r4, [r2]
if ( m != n )
3000b85c: 11a0c18c lslne ip, ip, #3
3000b860: 0a00001f beq 3000b8e4 <rtems_io_register_driver+0x138>
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
3000b864: e59e5000 ldr r5, [lr]
3000b868: e1a0e001 mov lr, r1
3000b86c: e085c00c add ip, r5, ip
3000b870: e8be000f ldm lr!, {r0, r1, r2, r3}
3000b874: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000b878: e89e0003 ldm lr, {r0, r1}
3000b87c: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
3000b880: eb0007cc bl 3000d7b8 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
3000b884: e3a01000 mov r1, #0 3000b888: e1a00004 mov r0, r4 3000b88c: e1a02001 mov r2, r1
}
3000b890: e8bd4030 pop {r4, r5, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
3000b894: ea0021dd b 30014010 <rtems_io_initialize>
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
3000b898: e3a0000a mov r0, #10 <== NOT EXECUTED
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
3000b89c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
3000b8a0: e59fe068 ldr lr, [pc, #104] ; 3000b910 <rtems_io_register_driver+0x164><== NOT EXECUTED 3000b8a4: e084c084 add ip, r4, r4, lsl #1 <== NOT EXECUTED 3000b8a8: e59e3000 ldr r3, [lr] <== NOT EXECUTED 3000b8ac: e1a0c18c lsl ip, ip, #3 <== 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;
3000b8b0: e793000c ldr r0, [r3, ip] <== NOT EXECUTED
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
3000b8b4: e083300c add r3, r3, ip <== 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;
3000b8b8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b8bc: 0a00000b beq 3000b8f0 <rtems_io_register_driver+0x144> <== NOT EXECUTED
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
3000b8c0: eb0007bc bl 3000d7b8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
3000b8c4: e3a0000c mov r0, #12 <== NOT EXECUTED
3000b8c8: e8bd8030 pop {r4, r5, pc} <== 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;
3000b8cc: e591c004 ldr ip, [r1, #4] 3000b8d0: e35c0000 cmp ip, #0
3000b8d4: 1affffc5 bne 3000b7f0 <rtems_io_register_driver+0x44>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
3000b8d8: e3a00009 mov r0, #9 <== NOT EXECUTED
3000b8dc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
3000b8e0: e5824000 str r4, [r2] <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
3000b8e4: eb0007b3 bl 3000d7b8 <_Thread_Enable_dispatch> <== NOT EXECUTED
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
3000b8e8: 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;
3000b8ec: e8bd8030 pop {r4, r5, pc} <== 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;
3000b8f0: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000b8f4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b8f8: 1afffff0 bne 3000b8c0 <rtems_io_register_driver+0x114> <== NOT EXECUTED
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
3000b8fc: e5824000 str r4, [r2] <== NOT EXECUTED 3000b900: eaffffd7 b 3000b864 <rtems_io_register_driver+0xb8> <== NOT EXECUTED
3000b914 <rtems_io_unregister_driver>:
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000b914: e59f3060 ldr r3, [pc, #96] ; 3000b97c <rtems_io_unregister_driver+0x68>
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
3000b918: e92d4010 push {r4, lr}
if ( rtems_interrupt_is_in_progress() )
3000b91c: e5934000 ldr r4, [r3] 3000b920: e3540000 cmp r4, #0
return RTEMS_CALLED_FROM_ISR;
3000b924: 13a00012 movne r0, #18
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000b928: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
3000b92c: e59f304c ldr r3, [pc, #76] ; 3000b980 <rtems_io_unregister_driver+0x6c> 3000b930: e5933000 ldr r3, [r3] 3000b934: e1530000 cmp r3, r0
3000b938: 8a000001 bhi 3000b944 <rtems_io_unregister_driver+0x30>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
3000b93c: e3a0000d mov r0, #13 <== NOT EXECUTED
}
3000b940: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b944: e59f3038 ldr r3, [pc, #56] ; 3000b984 <rtems_io_unregister_driver+0x70> 3000b948: e5932000 ldr r2, [r3] 3000b94c: e2822001 add r2, r2, #1 3000b950: e5832000 str r2, [r3]
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
3000b954: e59f302c ldr r3, [pc, #44] ; 3000b988 <rtems_io_unregister_driver+0x74>
&_IO_Driver_address_table[major],
3000b958: e0800080 add r0, r0, r0, lsl #1
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
3000b95c: e5933000 ldr r3, [r3] 3000b960: e1a01004 mov r1, r4 3000b964: e3a02018 mov r2, #24 3000b968: e0830180 add r0, r3, r0, lsl #3 3000b96c: eb002d6f bl 30016f30 <memset>
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
3000b970: eb000790 bl 3000d7b8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b974: e1a00004 mov r0, r4
3000b978: e8bd8010 pop {r4, pc}
30011e0c <rtems_io_write>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011e0c: e59fc044 ldr ip, [pc, #68] ; 30011e58 <rtems_io_write+0x4c>
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011e10: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011e14: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30011e18: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011e1c: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30011e20: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30011e24: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
30011e28: e59fc02c ldr ip, [pc, #44] ; 30011e5c <rtems_io_write+0x50> 30011e2c: e0833083 add r3, r3, r3, lsl #1 30011e30: e59cc000 ldr ip, [ip] 30011e34: e08c3183 add r3, ip, r3, lsl #3 30011e38: e5933010 ldr r3, [r3, #16]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30011e3c: e3530000 cmp r3, #0
30011e40: 0a000002 beq 30011e50 <rtems_io_write+0x44>
30011e44: e1a0e00f mov lr, pc
30011e48: e12fff13 bx r3
30011e4c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30011e50: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30011e54: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c99c <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)
{
3000c99c: 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 )
3000c9a0: e2506000 subs r6, r0, #0 <== NOT EXECUTED
3000c9a4: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c9a8: e59f7054 ldr r7, [pc, #84] ; 3000ca04 <rtems_iterate_over_all_threads+0x68><== NOT EXECUTED
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
3000c9ac: e287800c add r8, r7, #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 ];
3000c9b0: e5b73004 ldr r3, [r7, #4]! <== NOT EXECUTED 3000c9b4: e5935004 ldr r5, [r3, #4] <== NOT EXECUTED
if ( !information )
3000c9b8: e3550000 cmp r5, #0 <== NOT EXECUTED 3000c9bc: 0a00000d beq 3000c9f8 <rtems_iterate_over_all_threads+0x5c><== NOT EXECUTED
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000c9c0: e1d521b0 ldrh r2, [r5, #16] <== NOT EXECUTED 3000c9c4: e3520000 cmp r2, #0 <== NOT EXECUTED 3000c9c8: 0a00000a beq 3000c9f8 <rtems_iterate_over_all_threads+0x5c><== NOT EXECUTED 3000c9cc: e3a04001 mov r4, #1 <== NOT EXECUTED
the_thread = (Thread_Control *)information->local_table[ i ];
3000c9d0: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3000c9d4: e7930104 ldr r0, [r3, r4, lsl #2] <== NOT EXECUTED
if ( !the_thread )
3000c9d8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c9dc: 0a000002 beq 3000c9ec <rtems_iterate_over_all_threads+0x50><== NOT EXECUTED
continue;
(*routine)(the_thread);
3000c9e0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c9e4: e12fff16 bx r6 <== NOT EXECUTED 3000c9e8: e1d521b0 ldrh r2, [r5, #16] <== NOT EXECUTED
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000c9ec: e2844001 add r4, r4, #1 <== NOT EXECUTED 3000c9f0: e1520004 cmp r2, r4 <== NOT EXECUTED 3000c9f4: 2afffff5 bcs 3000c9d0 <rtems_iterate_over_all_threads+0x34><== NOT EXECUTED
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
3000c9f8: e1570008 cmp r7, r8 <== NOT EXECUTED
3000c9fc: 1affffeb bne 3000c9b0 <rtems_iterate_over_all_threads+0x14><== NOT EXECUTED
3000ca00: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300065b4 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
300065b4: e92d4010 push {r4, lr}
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
300065b8: e59f30b8 ldr r3, [pc, #184] ; 30006678 <rtems_libio_init+0xc4>
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
300065bc: e24dd004 sub sp, sp, #4
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
300065c0: e5934000 ldr r4, [r3] 300065c4: e3540000 cmp r4, #0
300065c8: 0a000017 beq 3000662c <rtems_libio_init+0x78>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
300065cc: e1a00004 mov r0, r4 300065d0: e3a01038 mov r1, #56 ; 0x38 300065d4: ebffff42 bl 300062e4 <calloc> 300065d8: e59f309c ldr r3, [pc, #156] ; 3000667c <rtems_libio_init+0xc8>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
300065dc: 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,
300065e0: e1a02000 mov r2, r0 300065e4: e5830000 str r0, [r3]
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
300065e8: 0a000020 beq 30006670 <rtems_libio_init+0xbc>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
300065ec: e59f308c ldr r3, [pc, #140] ; 30006680 <rtems_libio_init+0xcc>
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
300065f0: e3540001 cmp r4, #1
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
300065f4: e5830000 str r0, [r3]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
300065f8: 9a000009 bls 30006624 <rtems_libio_init+0x70>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
300065fc: e2803038 add r3, r0, #56 ; 0x38 30006600: e3a02001 mov r2, #1
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++)
iop->data1 = iop + 1;
30006604: e2822001 add r2, r2, #1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
30006608: e1520004 cmp r2, r4
iop->data1 = iop + 1;
3000660c: e5033004 str r3, [r3, #-4] 30006610: e2833038 add r3, r3, #56 ; 0x38
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++)
30006614: 1afffffa bne 30006604 <rtems_libio_init+0x50>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
30006618: e2422001 sub r2, r2, #1 3000661c: e0622182 rsb r2, r2, r2, lsl #3
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++)
30006620: e0802182 add r2, r0, r2, lsl #3
iop->data1 = iop + 1;
iop->data1 = NULL;
30006624: e3a03000 mov r3, #0 30006628: e5823034 str r3, [r2, #52] ; 0x34
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
3000662c: e59fc050 ldr ip, [pc, #80] ; 30006684 <rtems_libio_init+0xd0> 30006630: e59f0050 ldr r0, [pc, #80] ; 30006688 <rtems_libio_init+0xd4> 30006634: e3a01001 mov r1, #1 30006638: e3a02054 mov r2, #84 ; 0x54 3000663c: e3a03000 mov r3, #0 30006640: e58dc000 str ip, [sp] 30006644: eb000ca8 bl 300098ec <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
30006648: e3500000 cmp r0, #0
3000664c: 1a000006 bne 3000666c <rtems_libio_init+0xb8>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
30006650: e59f3034 ldr r3, [pc, #52] ; 3000668c <rtems_libio_init+0xd8> 30006654: e5933000 ldr r3, [r3] 30006658: e3530000 cmp r3, #0
(* rtems_fs_init_helper)();
3000665c: 11a0e00f movne lr, pc 30006660: 112fff13 bxne r3
}
30006664: e28dd004 add sp, sp, #4
30006668: e8bd8010 pop {r4, pc}
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
3000666c: eb000ee0 bl 3000a1f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
30006670: e280001a add r0, r0, #26 <== NOT EXECUTED 30006674: eb000ede bl 3000a1f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
30007bd4 <rtems_libio_set_private_env>:
}
}
rtems_status_code rtems_libio_set_private_env(void)
{
30007bd4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30007bd8: e24dd02c sub sp, sp, #44 ; 0x2c
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id task_id = rtems_task_self();
30007bdc: eb000b9a bl 3000aa4c <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);
30007be0: e28d7018 add r7, sp, #24 30007be4: e3a0c000 mov ip, #0 30007be8: e1a0200c mov r2, ip
}
rtems_status_code rtems_libio_set_private_env(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
30007bec: e1a06000 mov r6, 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);
30007bf0: e3a01001 mov r1, #1 30007bf4: e59f00fc ldr r0, [pc, #252] ; 30007cf8 <rtems_libio_set_private_env+0x124> 30007bf8: e1a03007 mov r3, r7 30007bfc: e58dc000 str ip, [sp] 30007c00: ebfffb32 bl 300068d0 <rtems_filesystem_evaluate_path>
if (rv != 0)
30007c04: e250c000 subs ip, r0, #0
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
30007c08: 13a0001a movne r0, #26
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);
if (rv != 0)
30007c0c: 0a000001 beq 30007c18 <rtems_libio_set_private_env+0x44>
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
}
30007c10: e28dd02c add sp, sp, #44 ; 0x2c
30007c14: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
if (rv != 0)
goto error_0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);
30007c18: e28d5004 add r5, sp, #4 30007c1c: e59f00d4 ldr r0, [pc, #212] ; 30007cf8 <rtems_libio_set_private_env+0x124> 30007c20: e3a01001 mov r1, #1 30007c24: e1a0200c mov r2, ip 30007c28: e1a03005 mov r3, r5 30007c2c: e58dc000 str ip, [sp] 30007c30: ebfffb26 bl 300068d0 <rtems_filesystem_evaluate_path>
if (rv != 0)
30007c34: e3500000 cmp r0, #0
30007c38: 1a00002a bne 30007ce8 <rtems_libio_set_private_env+0x114>
* 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
30007c3c: e59f30b8 ldr r3, [pc, #184] ; 30007cfc <rtems_libio_set_private_env+0x128> 30007c40: e5934000 ldr r4, [r3]
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
30007c44: e59f30b4 ldr r3, [pc, #180] ; 30007d00 <rtems_libio_set_private_env+0x12c> 30007c48: e1540003 cmp r4, r3
30007c4c: 0a000002 beq 30007c5c <rtems_libio_set_private_env+0x88>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
30007c50: e5943000 ldr r3, [r4] 30007c54: e1530006 cmp r3, r6
30007c58: 0a00000d beq 30007c94 <rtems_libio_set_private_env+0xc0>
) {
new_env = malloc(sizeof(rtems_user_env_t));
30007c5c: e3a00048 mov r0, #72 ; 0x48 30007c60: ebfffd02 bl 30007070 <malloc>
if (new_env == NULL)
30007c64: e3500000 cmp r0, #0
if (
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
) {
new_env = malloc(sizeof(rtems_user_env_t));
30007c68: e1a04000 mov r4, r0 30007c6c: e1a0a000 mov sl, r0
if (new_env == NULL)
30007c70: 0a00001a beq 30007ce0 <rtems_libio_set_private_env+0x10c>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
30007c74: e59f8080 ldr r8, [pc, #128] ; 30007cfc <rtems_libio_set_private_env+0x128> 30007c78: e3a00000 mov r0, #0 30007c7c: e1a01008 mov r1, r8 30007c80: e59f207c ldr r2, [pc, #124] ; 30007d04 <rtems_libio_set_private_env+0x130> 30007c84: eb000b8f bl 3000aac8 <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
30007c88: e3500000 cmp r0, #0
30007c8c: 1a000011 bne 30007cd8 <rtems_libio_set_private_env+0x104>
goto error_3;
rtems_current_user_env = new_env;
30007c90: e5884000 str r4, [r8]
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
30007c94: e59f1064 ldr r1, [pc, #100] ; 30007d00 <rtems_libio_set_private_env+0x12c> 30007c98: e3a02048 mov r2, #72 ; 0x48 30007c9c: e1a00004 mov r0, r4 30007ca0: eb002d66 bl 30013240 <memcpy>
* 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;
30007ca4: e8b7000f ldm r7!, {r0, r1, r2, r3}
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
rtems_current_user_env->task_id = task_id;
30007ca8: e1a0c004 mov ip, r4 30007cac: e48c6018 str r6, [ip], #24
* 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;
30007cb0: e2844004 add r4, r4, #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;
30007cb4: e5976000 ldr r6, [r7]
30007cb8: e8ac000f stmia ip!, {r0, r1, r2, r3}
rtems_filesystem_current = current_loc;
30007cbc: e8b5000f ldm r5!, {r0, r1, r2, r3}
30007cc0: e8a4000f stmia r4!, {r0, r1, r2, r3}
30007cc4: e5953000 ldr r3, [r5]
* 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;
30007cc8: e58c6000 str r6, [ip]
rtems_filesystem_current = current_loc;
30007ccc: e5843000 str r3, [r4]
return RTEMS_SUCCESSFUL;
30007cd0: e3a00000 mov r0, #0 30007cd4: eaffffcd b 30007c10 <rtems_libio_set_private_env+0x3c>
error_3:
free(new_env);
30007cd8: e1a00004 mov r0, r4 <== NOT EXECUTED 30007cdc: ebfffb3a bl 300069cc <free> <== NOT EXECUTED
error_2:
rtems_filesystem_freenode(¤t_loc);
30007ce0: e1a00005 mov r0, r5 30007ce4: ebfffb33 bl 300069b8 <rtems_filesystem_freenode>
error_1:
rtems_filesystem_freenode(&root_loc);
30007ce8: e1a00007 mov r0, r7 30007cec: ebfffb31 bl 300069b8 <rtems_filesystem_freenode>
error_0:
return RTEMS_NO_MEMORY;
30007cf0: e3a0001a mov r0, #26 30007cf4: eaffffc5 b 30007c10 <rtems_libio_set_private_env+0x3c>
30007d08 <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)
{
30007d08: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30007d0c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
30007d10: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
30007d14: eb000b4c bl 3000aa4c <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 )
30007d18: e1560000 cmp r6, r0 <== NOT EXECUTED
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
30007d1c: 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;
30007d20: 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 )
30007d24: 0a00000c beq 30007d5c <rtems_libio_share_private_env+0x54> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
30007d28: e59f5040 ldr r5, [pc, #64] ; 30007d70 <rtems_libio_share_private_env+0x68><== NOT EXECUTED 30007d2c: e1a00006 mov r0, r6 <== NOT EXECUTED 30007d30: e1a01005 mov r1, r5 <== NOT EXECUTED 30007d34: e1a0200d mov r2, sp <== NOT EXECUTED 30007d38: eb000b8e bl 3000ab78 <rtems_task_variable_get> <== NOT EXECUTED
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
30007d3c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30007d40: 1a000005 bne 30007d5c <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) {
30007d44: e5950000 ldr r0, [r5] <== NOT EXECUTED 30007d48: e5903000 ldr r3, [r0] <== NOT EXECUTED 30007d4c: e1530004 cmp r3, r4 <== NOT EXECUTED 30007d50: 0a000004 beq 30007d68 <rtems_libio_share_private_env+0x60> <== NOT EXECUTED
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
30007d54: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30007d58: e5853000 str r3, [r5] <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
30007d5c: e1a00006 mov r0, r6 <== NOT EXECUTED
30007d60: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30007d64: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
30007d68: ebffff8c bl 30007ba0 <free_user_env> <== NOT EXECUTED 30007d6c: eafffff8 b 30007d54 <rtems_libio_share_private_env+0x4c> <== NOT EXECUTED
3000e77c <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
3000e77c: e2002006 and r2, r0, #6 3000e780: e3520006 cmp r2, #6
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
3000e784: e1a03000 mov r3, r0
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
3000e788: 03a00002 moveq r0, #2
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
3000e78c: 0a000002 beq 3000e79c <rtems_libio_to_fcntl_flags+0x20>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
3000e790: e3130002 tst r3, #2
fcntl_flags |= O_RDONLY;
3000e794: 13a00000 movne r0, #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) {
3000e798: 0a000006 beq 3000e7b8 <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
3000e79c: e3130001 tst r3, #1
fcntl_flags |= O_NONBLOCK;
3000e7a0: 13800901 orrne r0, r0, #16384 ; 0x4000
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
3000e7a4: e3130c02 tst r3, #512 ; 0x200
fcntl_flags |= O_APPEND;
3000e7a8: 13800008 orrne r0, r0, #8
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
3000e7ac: e3130b01 tst r3, #1024 ; 0x400
fcntl_flags |= O_CREAT;
3000e7b0: 13800c02 orrne r0, r0, #512 ; 0x200
}
return fcntl_flags;
}
3000e7b4: e12fff1e bx lr
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
3000e7b8: e3130004 tst r3, #4 <== NOT EXECUTED 3000e7bc: 03a00000 moveq r0, #0 <== NOT EXECUTED 3000e7c0: 13a00001 movne r0, #1 <== NOT EXECUTED 3000e7c4: eafffff4 b 3000e79c <rtems_libio_to_fcntl_flags+0x20> <== NOT EXECUTED
3000aa64 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
3000aa64: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
3000aa68: e59f3040 ldr r3, [pc, #64] ; 3000aab0 <rtems_malloc_statistics_at_free+0x4c><== NOT EXECUTED
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
3000aa6c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000aa70: e1a01000 mov r1, r0 <== NOT EXECUTED
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
3000aa74: e1a0200d mov r2, sp <== NOT EXECUTED 3000aa78: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000aa7c: eb001887 bl 30010ca0 <_Protected_heap_Get_block_size> <== NOT EXECUTED 3000aa80: e3500000 cmp r0, #0 <== NOT EXECUTED 3000aa84: 0a000007 beq 3000aaa8 <rtems_malloc_statistics_at_free+0x44><== NOT EXECUTED
MSBUMP(lifetime_freed, size);
3000aa88: e59f3024 ldr r3, [pc, #36] ; 3000aab4 <rtems_malloc_statistics_at_free+0x50><== NOT EXECUTED
3000aa8c: e59d0000 ldr r0, [sp] <== NOT EXECUTED
3000aa90: e2832024 add r2, r3, #36 ; 0x24 <== NOT EXECUTED
3000aa94: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
3000aa98: e0911000 adds r1, r1, r0 <== NOT EXECUTED
3000aa9c: e2a22000 adc r2, r2, #0 <== NOT EXECUTED
3000aaa0: e5831024 str r1, [r3, #36] ; 0x24 <== NOT EXECUTED
3000aaa4: e5832028 str r2, [r3, #40] ; 0x28 <== NOT EXECUTED
} }
3000aaa8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000aaac: e8bd8000 pop {pc} <== NOT EXECUTED
30012f20 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
30012f20: e92d4070 push {r4, r5, r6, lr}
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
30012f24: e2504000 subs r4, r0, #0
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
30012f28: e1a05001 mov r5, r1 30012f2c: e1a06002 mov r6, r2
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
30012f30: 0a00001a beq 30012fa0 <rtems_memalign+0x80>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30012f34: e59f3074 ldr r3, [pc, #116] ; 30012fb0 <rtems_memalign+0x90>
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
*pointer = NULL;
30012f38: e3a02000 mov r2, #0
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30012f3c: e5933000 ldr r3, [r3]
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
*pointer = NULL;
30012f40: e5842000 str r2, [r4]
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30012f44: e3530003 cmp r3, #3
30012f48: 0a000011 beq 30012f94 <rtems_memalign+0x74>
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
30012f4c: ebffd284 bl 30007964 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
30012f50: e59f305c ldr r3, [pc, #92] ; 30012fb4 <rtems_memalign+0x94> 30012f54: e1a02005 mov r2, r5 30012f58: e5930000 ldr r0, [r3] 30012f5c: e1a01006 mov r1, r6 30012f60: e3a03000 mov r3, #0 30012f64: ebffe748 bl 3000cc8c <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
30012f68: e2505000 subs r5, r0, #0
30012f6c: 0a00000d beq 30012fa8 <rtems_memalign+0x88>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
30012f70: e59f3040 ldr r3, [pc, #64] ; 30012fb8 <rtems_memalign+0x98> 30012f74: e5933000 ldr r3, [r3] 30012f78: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
30012f7c: 11a00004 movne r0, r4 30012f80: 11a0e00f movne lr, pc 30012f84: 1593f004 ldrne pc, [r3, #4]
*pointer = return_this;
30012f88: e5845000 str r5, [r4]
return 0;
30012f8c: e3a00000 mov r0, #0
30012f90: 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() )
30012f94: ebffd25e bl 30007914 <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()) &&
30012f98: e3500000 cmp r0, #0
30012f9c: 1affffea bne 30012f4c <rtems_memalign+0x2c>
!malloc_is_system_state_OK() )
return EINVAL;
30012fa0: e3a00016 mov r0, #22 <== NOT EXECUTED
30012fa4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
30012fa8: e3a0000c mov r0, #12 <== NOT EXECUTED
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
30012fac: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30017a90 <rtems_message_queue_broadcast>:
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
30017a90: e92d40f0 push {r4, r5, r6, r7, lr}
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
30017a94: e2516000 subs r6, r1, #0
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
30017a98: e24dd00c sub sp, sp, #12 30017a9c: e1a04000 mov r4, r0 30017aa0: e1a05002 mov r5, r2 30017aa4: e1a07003 mov r7, r3
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
30017aa8: 0a000016 beq 30017b08 <rtems_message_queue_broadcast+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !count )
30017aac: e3530000 cmp r3, #0
30017ab0: 0a000014 beq 30017b08 <rtems_message_queue_broadcast+0x78>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
30017ab4: e59f0054 ldr r0, [pc, #84] ; 30017b10 <rtems_message_queue_broadcast+0x80> 30017ab8: e1a01004 mov r1, r4 30017abc: e28d2008 add r2, sp, #8 30017ac0: eb001521 bl 3001cf4c <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30017ac4: e59d3008 ldr r3, [sp, #8] 30017ac8: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30017acc: 13a00004 movne r0, #4
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30017ad0: 1a00000a bne 30017b00 <rtems_message_queue_broadcast+0x70>
case OBJECTS_LOCAL:
core_status = _CORE_message_queue_Broadcast(
30017ad4: e58d3000 str r3, [sp] 30017ad8: e1a01006 mov r1, r6 30017adc: e1a03004 mov r3, r4 30017ae0: e1a02005 mov r2, r5 30017ae4: e2800014 add r0, r0, #20 30017ae8: e58d7004 str r7, [sp, #4] 30017aec: eb000dd2 bl 3001b23c <_CORE_message_queue_Broadcast> 30017af0: e1a04000 mov r4, r0
NULL,
#endif
count
);
_Thread_Enable_dispatch();
30017af4: eb00186f bl 3001dcb8 <_Thread_Enable_dispatch>
return
30017af8: e1a00004 mov r0, r4 30017afc: eb0000d5 bl 30017e58 <_Message_queue_Translate_core_message_queue_return_code>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30017b00: e28dd00c add sp, sp, #12
30017b04: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
30017b08: e3a00009 mov r0, #9 <== NOT EXECUTED 30017b0c: eafffffb b 30017b00 <rtems_message_queue_broadcast+0x70> <== NOT EXECUTED
3001204c <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3001204c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
30012050: e2507000 subs r7, r0, #0
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30012054: e24dd008 sub sp, sp, #8 30012058: e1a04001 mov r4, r1 3001205c: e1a06002 mov r6, r2 30012060: e59d5020 ldr r5, [sp, #32]
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30012064: 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 ) )
30012068: 0a000008 beq 30012090 <rtems_message_queue_create+0x44>
return RTEMS_INVALID_NAME;
if ( !id )
3001206c: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
30012070: 03a00009 moveq r0, #9
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30012074: 0a000005 beq 30012090 <rtems_message_queue_create+0x44>
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
30012078: e3510000 cmp r1, #0
return RTEMS_INVALID_NUMBER;
3001207c: 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 )
30012080: 0a000002 beq 30012090 <rtems_message_queue_create+0x44>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
30012084: e3520000 cmp r2, #0
return RTEMS_INVALID_SIZE;
30012088: 03a00008 moveq r0, #8
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
3001208c: 1a000001 bne 30012098 <rtems_message_queue_create+0x4c>
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
30012090: e28dd008 add sp, sp, #8
30012094: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30012098: e59f2098 ldr r2, [pc, #152] ; 30012138 <rtems_message_queue_create+0xec> 3001209c: e5921000 ldr r1, [r2] 300120a0: e2811001 add r1, r1, #1 300120a4: e5821000 str r1, [r2]
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
300120a8: e58d3000 str r3, [sp] 300120ac: eb0019d8 bl 30018814 <_Message_queue_Allocate>
if ( !the_message_queue ) {
300120b0: e2508000 subs r8, r0, #0 300120b4: e59d3000 ldr r3, [sp]
300120b8: 0a00001b beq 3001212c <rtems_message_queue_create+0xe0>
}
#endif
the_message_queue->attribute_set = attribute_set;
if (_Attributes_Is_priority( attribute_set ) )
300120bc: e2132004 ands r2, r3, #4
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
300120c0: e5883010 str r3, [r8, #16]
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
300120c4: 13a03001 movne r3, #1 300120c8: 158d3004 strne r3, [sp, #4]
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
300120cc: 058d2004 streq r2, [sp, #4]
if ( ! _CORE_message_queue_Initialize(
300120d0: e2880014 add r0, r8, #20 300120d4: e28d1004 add r1, sp, #4 300120d8: e1a02004 mov r2, r4 300120dc: e1a03006 mov r3, r6 300120e0: eb000487 bl 30013304 <_CORE_message_queue_Initialize> 300120e4: e3500000 cmp r0, #0
300120e8: 1a000005 bne 30012104 <rtems_message_queue_create+0xb8>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
300120ec: e59f0048 ldr r0, [pc, #72] ; 3001213c <rtems_message_queue_create+0xf0><== NOT EXECUTED 300120f0: e1a01008 mov r1, r8 <== NOT EXECUTED 300120f4: eb000872 bl 300142c4 <_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();
300120f8: eb000c4b bl 3001522c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
300120fc: e3a0000d mov r0, #13 <== NOT EXECUTED 30012100: eaffffe2 b 30012090 <rtems_message_queue_create+0x44> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30012104: e59f2030 ldr r2, [pc, #48] ; 3001213c <rtems_message_queue_create+0xf0>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30012108: e5983008 ldr r3, [r8, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3001210c: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30012110: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30012114: e7828721 str r8, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30012118: e588700c str r7, [r8, #12]
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
3001211c: e5853000 str r3, [r5]
name,
0
);
#endif
_Thread_Enable_dispatch();
30012120: eb000c41 bl 3001522c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30012124: e3a00000 mov r0, #0 30012128: eaffffd8 b 30012090 <rtems_message_queue_create+0x44>
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
3001212c: eb000c3e bl 3001522c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30012130: e3a00005 mov r0, #5 <== NOT EXECUTED 30012134: eaffffd5 b 30012090 <rtems_message_queue_create+0x44> <== NOT EXECUTED
30017cc4 <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
30017cc4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
30017cc8: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
30017ccc: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30017cd0: e1a01000 mov r1, r0 <== NOT EXECUTED
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
30017cd4: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
30017cd8: 0a00000a beq 30017d08 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED 30017cdc: e59f002c ldr r0, [pc, #44] ; 30017d10 <rtems_message_queue_get_number_pending+0x4c><== NOT EXECUTED 30017ce0: e1a0200d mov r2, sp <== NOT EXECUTED 30017ce4: eb001498 bl 3001cf4c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30017ce8: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30017cec: e3550000 cmp r5, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30017cf0: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30017cf4: 1a000003 bne 30017d08 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
30017cf8: e590305c ldr r3, [r0, #92] ; 0x5c <== NOT EXECUTED 30017cfc: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
30017d00: eb0017ec bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30017d04: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30017d08: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30017d0c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30012174 <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
30012174: e92d4070 push {r4, r5, r6, lr}
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
30012178: e2515000 subs r5, r1, #0
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
3001217c: e24dd00c sub sp, sp, #12 30012180: e1a01000 mov r1, r0 30012184: e1a04002 mov r4, r2 30012188: e1a06003 mov r6, r3
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
3001218c: 0a000019 beq 300121f8 <rtems_message_queue_receive+0x84>
return RTEMS_INVALID_ADDRESS;
if ( !size )
30012190: e3520000 cmp r2, #0
30012194: 0a000017 beq 300121f8 <rtems_message_queue_receive+0x84>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
30012198: e59f0060 ldr r0, [pc, #96] ; 30012200 <rtems_message_queue_receive+0x8c> 3001219c: e28d2008 add r2, sp, #8 300121a0: eb00089e bl 30014420 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
300121a4: e59d3008 ldr r3, [sp, #8] 300121a8: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300121ac: 13a00004 movne r0, #4
if ( !size )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
300121b0: 1a00000e bne 300121f0 <rtems_message_queue_receive+0x7c>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
300121b4: e59d301c ldr r3, [sp, #28]
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
300121b8: e2066001 and r6, r6, #1 300121bc: e5901008 ldr r1, [r0, #8] 300121c0: e1a02005 mov r2, r5 300121c4: e2800014 add r0, r0, #20 300121c8: e58d3004 str r3, [sp, #4] 300121cc: e2266001 eor r6, r6, #1 300121d0: e1a03004 mov r3, r4 300121d4: e58d6000 str r6, [sp] 300121d8: eb00047c bl 300133d0 <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
300121dc: eb000c12 bl 3001522c <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
_Thread_Executing->Wait.return_code
300121e0: e59f301c ldr r3, [pc, #28] ; 30012204 <rtems_message_queue_receive+0x90> 300121e4: e5933004 ldr r3, [r3, #4]
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
300121e8: e5930034 ldr r0, [r3, #52] ; 0x34 300121ec: eb000024 bl 30012284 <_Message_queue_Translate_core_message_queue_return_code>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300121f0: e28dd00c add sp, sp, #12
300121f4: e8bd8070 pop {r4, r5, r6, pc}
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
300121f8: e3a00009 mov r0, #9 <== NOT EXECUTED 300121fc: eafffffb b 300121f0 <rtems_message_queue_receive+0x7c> <== NOT EXECUTED
30009e40 <rtems_object_api_maximum_class>:
int rtems_object_api_maximum_class(
int api
)
{
return _Objects_API_maximum_class(api);
30009e40: ea0005bb b 3000b534 <_Objects_API_maximum_class> <== NOT EXECUTED
30009e44 <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 )
30009e44: e2400001 sub r0, r0, #1 <== NOT EXECUTED
uint32_t api
)
{
if ( _Objects_Is_api_valid( api ) )
return 1;
return -1;
30009e48: e3500003 cmp r0, #3 <== NOT EXECUTED
}
30009e4c: 33a00001 movcc r0, #1 <== NOT EXECUTED 30009e50: 23e00000 mvncs r0, #0 <== NOT EXECUTED 30009e54: e12fff1e bx lr <== NOT EXECUTED
30009e58 <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
30009e58: e3500001 cmp r0, #1 <== NOT EXECUTED
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
30009e5c: 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 )
30009e60: 0a00000d beq 30009e9c <rtems_object_get_api_class_name+0x44><== NOT EXECUTED
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
30009e64: e3500002 cmp r0, #2 <== NOT EXECUTED 30009e68: 0a000004 beq 30009e80 <rtems_object_get_api_class_name+0x28><== NOT EXECUTED
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
30009e6c: e3500003 cmp r0, #3 <== NOT EXECUTED
api_assoc = rtems_object_api_posix_assoc;
30009e70: 059f003c ldreq r0, [pc, #60] ; 30009eb4 <rtems_object_get_api_class_name+0x5c><== 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 )
30009e74: 0a000002 beq 30009e84 <rtems_object_get_api_class_name+0x2c><== NOT EXECUTED
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
30009e78: e59f0038 ldr r0, [pc, #56] ; 30009eb8 <rtems_object_get_api_class_name+0x60><== NOT EXECUTED
30009e7c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
30009e80: e59f0034 ldr r0, [pc, #52] ; 30009ebc <rtems_object_get_api_class_name+0x64><== 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 );
30009e84: eb0013b1 bl 3000ed50 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( class_assoc )
30009e88: e3500000 cmp r0, #0 <== NOT EXECUTED
return class_assoc->name;
30009e8c: 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 )
30009e90: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
return class_assoc->name;
return "BAD CLASS";
30009e94: e59f0024 ldr r0, [pc, #36] ; 30009ec0 <rtems_object_get_api_class_name+0x68><== NOT EXECUTED
}
30009e98: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== 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;
30009e9c: e59f0020 ldr r0, [pc, #32] ; 30009ec4 <rtems_object_get_api_class_name+0x6c><== 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 );
30009ea0: eb0013aa bl 3000ed50 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( class_assoc )
30009ea4: e3500000 cmp r0, #0 <== NOT EXECUTED
return class_assoc->name;
30009ea8: 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 )
30009eac: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
30009eb0: eafffff7 b 30009e94 <rtems_object_get_api_class_name+0x3c> <== NOT EXECUTED
30009ec8 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
30009ec8: e1a01000 mov r1, r0 <== NOT EXECUTED
30009ecc: 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 );
30009ed0: e59f0010 ldr r0, [pc, #16] ; 30009ee8 <rtems_object_get_api_name+0x20><== NOT EXECUTED 30009ed4: eb00139d bl 3000ed50 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( api_assoc )
30009ed8: e3500000 cmp r0, #0 <== NOT EXECUTED
return api_assoc->name;
30009edc: 15900000 ldrne r0, [r0] <== NOT EXECUTED
return "BAD CLASS";
30009ee0: 059f0004 ldreq r0, [pc, #4] ; 30009eec <rtems_object_get_api_name+0x24><== NOT EXECUTED
}
30009ee4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000bb04 <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
)
{
3000bb04: e92d4010 push {r4, lr} <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000bb08: e2524000 subs r4, r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000bb0c: 03a00009 moveq r0, #9 <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000bb10: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
3000bb14: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000bb18: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3000bb1c: eb0006ec bl 3000d6d4 <_Objects_Get_information> <== NOT EXECUTED
if ( !obj_info )
3000bb20: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bb24: 0a000018 beq 3000bb8c <rtems_object_get_class_information+0x88><== 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; info->maximum = obj_info->maximum;
3000bb28: 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;
3000bb2c: e590c008 ldr ip, [r0, #8] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id;
3000bb30: e590200c ldr r2, [r0, #12] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
3000bb34: e5d03012 ldrb r3, [r0, #18] <== NOT EXECUTED
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000bb38: e3510000 cmp r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
3000bb3c: e584c000 str ip, [r4] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id;
3000bb40: e5842004 str r2, [r4, #4] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
3000bb44: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED
info->maximum = obj_info->maximum;
3000bb48: e5841008 str r1, [r4, #8] <== NOT EXECUTED
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000bb4c: 01a0c001 moveq ip, r1 <== NOT EXECUTED 3000bb50: 0a00000a beq 3000bb80 <rtems_object_get_class_information+0x7c><== NOT EXECUTED 3000bb54: e3a02001 mov r2, #1 <== NOT EXECUTED 3000bb58: e590001c ldr r0, [r0, #28] <== NOT EXECUTED 3000bb5c: e1a03002 mov r3, r2 <== NOT EXECUTED 3000bb60: e3a0c000 mov ip, #0 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000bb64: e7902102 ldr r2, [r0, r2, 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++ )
3000bb68: e2833001 add r3, r3, #1 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000bb6c: e3520000 cmp r2, #0 <== NOT EXECUTED
unallocated++;
3000bb70: 028cc001 addeq ip, ip, #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++ )
3000bb74: e1510003 cmp r1, r3 <== NOT EXECUTED 3000bb78: e1a02003 mov r2, r3 <== NOT EXECUTED 3000bb7c: 2afffff8 bcs 3000bb64 <rtems_object_get_class_information+0x60><== NOT EXECUTED
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
3000bb80: e584c010 str ip, [r4, #16] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000bb84: e3a00000 mov r0, #0 <== NOT EXECUTED
3000bb88: 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;
3000bb8c: e3a0000a mov r0, #10 <== NOT EXECUTED
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
3000bb90: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ae28 <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
3000ae28: e92d4010 push {r4, lr} <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
3000ae2c: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
3000ae30: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
return RTEMS_INVALID_ADDRESS;
3000ae34: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
3000ae38: 0a000005 beq 3000ae54 <rtems_object_get_classic_name+0x2c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
3000ae3c: e1a0100d mov r1, sp <== NOT EXECUTED 3000ae40: eb000718 bl 3000caa8 <_Objects_Id_to_name> <== NOT EXECUTED
*name = name_u.name_u32;
3000ae44: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000ae48: e5843000 str r3, [r4] <== NOT EXECUTED
return _Status_Object_name_errors_to_status[ status ];
3000ae4c: e59f3008 ldr r3, [pc, #8] ; 3000ae5c <rtems_object_get_classic_name+0x34><== NOT EXECUTED 3000ae50: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
}
3000ae54: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000ae58: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b034 <rtems_object_get_name>:
Objects_Id id,
size_t length,
char *name
)
{
return _Objects_Get_name_as_string( id, length, name );
3000b034: ea0007a4 b 3000cecc <_Objects_Get_name_as_string> <== NOT EXECUTED
3000bb98 <rtems_object_id_api_maximum>:
#undef rtems_object_id_api_maximum
int rtems_object_id_api_maximum(void)
{
return OBJECTS_APIS_LAST;
}
3000bb98: e3a00003 mov r0, #3 <== NOT EXECUTED 3000bb9c: e12fff1e bx lr <== NOT EXECUTED
3000bba0 <rtems_object_id_api_minimum>:
#undef rtems_object_id_api_minimum
int rtems_object_id_api_minimum(void)
{
return OBJECTS_INTERNAL_API;
}
3000bba0: e3a00001 mov r0, #1 <== NOT EXECUTED 3000bba4: e12fff1e bx lr <== NOT EXECUTED
3000bba8 <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);
3000bba8: e1a00c20 lsr r0, r0, #24 <== NOT EXECUTED
int rtems_object_id_get_api(
rtems_id id
)
{
return _Objects_Get_API( id );
}
3000bbac: e2000007 and r0, r0, #7 <== NOT EXECUTED 3000bbb0: e12fff1e bx lr <== NOT EXECUTED
3000bbb4 <rtems_object_id_get_class>:
int rtems_object_id_get_class(
rtems_id id
)
{
return _Objects_Get_class( id );
}
3000bbb4: e1a00da0 lsr r0, r0, #27 <== NOT EXECUTED 3000bbb8: e12fff1e bx lr <== NOT EXECUTED
3000bbbc <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 );
3000bbbc: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
}
3000bbc0: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 3000bbc4: e12fff1e bx lr <== NOT EXECUTED
3000bbc8 <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;
3000bbc8: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED
int rtems_object_id_get_node(
rtems_id id
)
{
return _Objects_Get_node( id );
}
3000bbcc: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 3000bbd0: e12fff1e bx lr <== NOT EXECUTED
30009ef4 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
30009ef4: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
30009ef8: e2515000 subs r5, r1, #0 <== NOT EXECUTED
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
30009efc: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
30009f00: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
30009f04: 0a000010 beq 30009f4c <rtems_object_set_name+0x58> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
30009f08: e3500000 cmp r0, #0 <== NOT EXECUTED 30009f0c: 059f3058 ldreq r3, [pc, #88] ; 30009f6c <rtems_object_set_name+0x78><== NOT EXECUTED 30009f10: 11a04000 movne r4, r0 <== NOT EXECUTED 30009f14: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 30009f18: 05934008 ldreq r4, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
30009f1c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009f20: eb00065c bl 3000b898 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
30009f24: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30009f28: 0a000006 beq 30009f48 <rtems_object_set_name+0x54> <== NOT EXECUTED
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
30009f2c: e1a01004 mov r1, r4 <== NOT EXECUTED 30009f30: e1a0200d mov r2, sp <== NOT EXECUTED 30009f34: eb0006dc bl 3000baac <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
30009f38: 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 );
30009f3c: e1a01000 mov r1, r0 <== NOT EXECUTED
switch ( location ) {
30009f40: e3540000 cmp r4, #0 <== NOT EXECUTED 30009f44: 0a000002 beq 30009f54 <rtems_object_set_name+0x60> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009f48: e3a00004 mov r0, #4 <== NOT EXECUTED
}
30009f4c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30009f50: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
30009f54: e1a02005 mov r2, r5 <== NOT EXECUTED 30009f58: e1a00006 mov r0, r6 <== NOT EXECUTED 30009f5c: eb000732 bl 3000bc2c <_Objects_Set_name> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009f60: eb000a3f bl 3000c864 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30009f64: e1a00004 mov r0, r4 <== NOT EXECUTED 30009f68: eafffff7 b 30009f4c <rtems_object_set_name+0x58> <== NOT EXECUTED
3000b120 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
3000b120: e92d000f push {r0, r1, r2, r3} <== NOT EXECUTED
3000b124: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000b128: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
3000b12c: e28d300c add r3, sp, #12 <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
3000b130: e1a02003 mov r2, r3 <== NOT EXECUTED 3000b134: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3000b138: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
3000b13c: e58d3000 str r3, [sp] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
3000b140: ebffff7f bl 3000af44 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
rtems_error(0, "fatal error, exiting");
3000b144: e59f1010 ldr r1, [pc, #16] ; 3000b15c <rtems_panic+0x3c> <== NOT EXECUTED 3000b148: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b14c: ebffffd6 bl 3000b0ac <rtems_error> <== NOT EXECUTED
_exit(errno);
3000b150: eb00318e bl 30017790 <__errno> <== NOT EXECUTED 3000b154: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000b158: eb0002af bl 3000bc1c <_exit> <== NOT EXECUTED
30017ee4 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30017ee4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
30017ee8: e2506000 subs r6, r0, #0
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30017eec: e24dd008 sub sp, sp, #8 30017ef0: e1a04001 mov r4, r1 30017ef4: e59d502c ldr r5, [sp, #44] ; 0x2c
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30017ef8: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
30017efc: 0a000031 beq 30017fc8 <rtems_partition_create+0xe4>
return RTEMS_INVALID_NAME;
if ( !starting_address )
30017f00: e3510000 cmp r1, #0
30017f04: 0a000033 beq 30017fd8 <rtems_partition_create+0xf4>
return RTEMS_INVALID_ADDRESS;
if ( !id )
30017f08: e3550000 cmp r5, #0
30017f0c: 0a000031 beq 30017fd8 <rtems_partition_create+0xf4>
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
30017f10: e3520000 cmp r2, #0 30017f14: 13530000 cmpne r3, #0
30017f18: 0a00002c beq 30017fd0 <rtems_partition_create+0xec>
30017f1c: e1520003 cmp r2, r3
30017f20: 3a00002a bcc 30017fd0 <rtems_partition_create+0xec>
30017f24: e3130007 tst r3, #7
30017f28: 1a000028 bne 30017fd0 <rtems_partition_create+0xec>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
30017f2c: e2118007 ands r8, r1, #7
30017f30: 1a000028 bne 30017fd8 <rtems_partition_create+0xf4>
30017f34: e59f10b0 ldr r1, [pc, #176] ; 30017fec <rtems_partition_create+0x108> 30017f38: e5910000 ldr r0, [r1] 30017f3c: e2800001 add r0, r0, #1 30017f40: e5810000 str r0, [r1]
* 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 );
30017f44: e59fa0a4 ldr sl, [pc, #164] ; 30017ff0 <rtems_partition_create+0x10c> 30017f48: e58d2004 str r2, [sp, #4] 30017f4c: e1a0000a mov r0, sl 30017f50: e58d3000 str r3, [sp] 30017f54: eb0012bb bl 3001ca48 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
30017f58: e2507000 subs r7, r0, #0 30017f5c: e59d2004 ldr r2, [sp, #4] 30017f60: e59d3000 ldr r3, [sp]
30017f64: 0a00001d beq 30017fe0 <rtems_partition_create+0xfc>
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
30017f68: e59d1028 ldr r1, [sp, #40] ; 0x28
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
30017f6c: e5872014 str r2, [r7, #20]
the_partition->buffer_size = buffer_size;
30017f70: e5873018 str r3, [r7, #24]
the_partition->attribute_set = attribute_set;
30017f74: e587101c str r1, [r7, #28]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
30017f78: e5874010 str r4, [r7, #16]
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
30017f7c: e1a01003 mov r1, r3
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
30017f80: e5878020 str r8, [r7, #32]
_Chain_Initialize( &the_partition->Memory, starting_address,
30017f84: e1a00002 mov r0, r2 30017f88: e58d3000 str r3, [sp] 30017f8c: eb0064a3 bl 30031220 <__aeabi_uidiv> 30017f90: e2879024 add r9, r7, #36 ; 0x24 30017f94: e1a02000 mov r2, r0 30017f98: e1a01004 mov r1, r4 30017f9c: e1a00009 mov r0, r9 30017fa0: e59d3000 ldr r3, [sp] 30017fa4: eb000c8b bl 3001b1d8 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30017fa8: e5973008 ldr r3, [r7, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30017fac: e59a201c ldr r2, [sl, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30017fb0: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30017fb4: e7827721 str r7, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30017fb8: e587600c str r6, [r7, #12]
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
30017fbc: e5853000 str r3, [r5]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
30017fc0: eb00173c bl 3001dcb8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30017fc4: e1a00008 mov r0, r8
}
30017fc8: e28dd008 add sp, sp, #8
30017fcc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
30017fd0: e3a00008 mov r0, #8 <== NOT EXECUTED 30017fd4: eafffffb b 30017fc8 <rtems_partition_create+0xe4> <== NOT EXECUTED
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
30017fd8: e3a00009 mov r0, #9 <== NOT EXECUTED 30017fdc: eafffff9 b 30017fc8 <rtems_partition_create+0xe4> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
30017fe0: eb001734 bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30017fe4: e3a00005 mov r0, #5 <== NOT EXECUTED 30017fe8: eafffff6 b 30017fc8 <rtems_partition_create+0xe4> <== NOT EXECUTED
30017ff4 <rtems_partition_delete>:
*/
rtems_status_code rtems_partition_delete(
rtems_id id
)
{
30017ff4: e92d4030 push {r4, r5, lr}
30017ff8: e24dd004 sub sp, sp, #4
30017ffc: e1a01000 mov r1, r0
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
30018000: e1a0200d mov r2, sp 30018004: e59f0054 ldr r0, [pc, #84] ; 30018060 <rtems_partition_delete+0x6c> 30018008: eb0013cf bl 3001cf4c <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
3001800c: e59d3000 ldr r3, [sp] 30018010: e1a04000 mov r4, r0 30018014: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018018: 13a00004 movne r0, #4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
3001801c: 1a000004 bne 30018034 <rtems_partition_delete+0x40>
case OBJECTS_LOCAL:
if ( the_partition->number_of_used_blocks == 0 ) {
30018020: e5945020 ldr r5, [r4, #32] 30018024: e3550000 cmp r5, #0
30018028: 0a000003 beq 3001803c <rtems_partition_delete+0x48>
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3001802c: eb001721 bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
30018030: e3a0000c mov r0, #12 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018034: e28dd004 add sp, sp, #4
30018038: e8bd8030 pop {r4, r5, pc}
the_partition = _Partition_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_partition->number_of_used_blocks == 0 ) {
_Objects_Close( &_Partition_Information, &the_partition->Object );
3001803c: e1a01004 mov r1, r4 30018040: e59f0018 ldr r0, [pc, #24] ; 30018060 <rtems_partition_delete+0x6c> 30018044: eb0012a4 bl 3001cadc <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Partition_Free (
Partition_Control *the_partition
)
{
_Objects_Free( &_Partition_Information, &the_partition->Object );
30018048: e59f0010 ldr r0, [pc, #16] ; 30018060 <rtems_partition_delete+0x6c> 3001804c: e1a01004 mov r1, r4 30018050: eb001356 bl 3001cdb0 <_Objects_Free>
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
30018054: eb001717 bl 3001dcb8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30018058: e1a00005 mov r0, r5 3001805c: eafffff4 b 30018034 <rtems_partition_delete+0x40>
30018110 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
30018110: e92d4070 push {r4, r5, r6, lr}
30018114: e1a03000 mov r3, r0
30018118: e24dd004 sub sp, sp, #4
3001811c: e1a04001 mov r4, r1
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
30018120: e59f008c ldr r0, [pc, #140] ; 300181b4 <rtems_partition_return_buffer+0xa4> 30018124: e1a01003 mov r1, r3 30018128: e1a0200d mov r2, sp 3001812c: eb001386 bl 3001cf4c <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
30018130: e59d3000 ldr r3, [sp] 30018134: e1a05000 mov r5, r0 30018138: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001813c: 13a00004 movne r0, #4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
30018140: 1a000016 bne 300181a0 <rtems_partition_return_buffer+0x90>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
30018144: e5950010 ldr r0, [r5, #16] 30018148: e5953014 ldr r3, [r5, #20] 3001814c: e0803003 add r3, r0, r3
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
30018150: e1540003 cmp r4, r3 30018154: 83a03000 movhi r3, #0 30018158: 93a03001 movls r3, #1 3001815c: e1540000 cmp r4, r0 30018160: 33a03000 movcc r3, #0
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
30018164: e3530000 cmp r3, #0
30018168: 0a00000e beq 300181a8 <rtems_partition_return_buffer+0x98>
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
3001816c: e0600004 rsb r0, r0, r4 30018170: e5951018 ldr r1, [r5, #24] 30018174: eb00646f bl 30031338 <__umodsi3>
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
30018178: e2506000 subs r6, r0, #0
3001817c: 1a000009 bne 300181a8 <rtems_partition_return_buffer+0x98>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
30018180: e2850024 add r0, r5, #36 ; 0x24 30018184: e1a01004 mov r1, r4 30018188: eb000bf2 bl 3001b158 <_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;
3001818c: e5953020 ldr r3, [r5, #32] 30018190: e2433001 sub r3, r3, #1 30018194: e5853020 str r3, [r5, #32]
_Thread_Enable_dispatch();
30018198: eb0016c6 bl 3001dcb8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3001819c: e1a00006 mov r0, r6
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300181a0: e28dd004 add sp, sp, #4
300181a4: e8bd8070 pop {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();
300181a8: eb0016c2 bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
300181ac: e3a00009 mov r0, #9 <== NOT EXECUTED 300181b0: eafffffa b 300181a0 <rtems_partition_return_buffer+0x90> <== NOT EXECUTED
300174d4 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
300174d4: e92d40f0 push {r4, r5, r6, r7, lr}
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
300174d8: e2504000 subs r4, r0, #0
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
300174dc: e24dd00c sub sp, sp, #12 300174e0: e59d5020 ldr r5, [sp, #32]
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
300174e4: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
300174e8: 0a000005 beq 30017504 <rtems_port_create+0x30>
return RTEMS_INVALID_NAME;
if ( !id )
300174ec: e3550000 cmp r5, #0
300174f0: 0a000002 beq 30017500 <rtems_port_create+0x2c>
* id - port id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_port_create(
300174f4: e1826001 orr r6, r2, r1
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
300174f8: e2166007 ands r6, r6, #7
300174fc: 0a000002 beq 3001750c <rtems_port_create+0x38>
!_Addresses_Is_aligned( external_start ) )
return RTEMS_INVALID_ADDRESS;
30017500: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
30017504: e28dd00c add sp, sp, #12
30017508: e8bd80f0 pop {r4, r5, r6, r7, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3001750c: e59f0074 ldr r0, [pc, #116] ; 30017588 <rtems_port_create+0xb4> 30017510: e590c000 ldr ip, [r0] 30017514: e28cc001 add ip, ip, #1 30017518: e580c000 str ip, [r0]
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
_Objects_Allocate( &_Dual_ported_memory_Information );
3001751c: e59f7068 ldr r7, [pc, #104] ; 3001758c <rtems_port_create+0xb8> 30017520: e58d1008 str r1, [sp, #8] 30017524: e1a00007 mov r0, r7 30017528: e58d2004 str r2, [sp, #4] 3001752c: e58d3000 str r3, [sp] 30017530: eb001544 bl 3001ca48 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
30017534: e3500000 cmp r0, #0 30017538: e59d1008 ldr r1, [sp, #8] 3001753c: e59d2004 ldr r2, [sp, #4] 30017540: e59d3000 ldr r3, [sp]
30017544: 0a00000c beq 3001757c <rtems_port_create+0xa8>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30017548: e590c008 ldr ip, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3001754c: e597e01c ldr lr, [r7, #28]
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
the_port->external_base = external_start;
the_port->length = length - 1;
30017550: e2433001 sub r3, r3, #1
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30017554: e1a0780c lsl r7, ip, #16
if ( !the_port ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
30017558: e5801010 str r1, [r0, #16]
the_port->external_base = external_start;
3001755c: e5802014 str r2, [r0, #20]
the_port->length = length - 1;
30017560: e5803018 str r3, [r0, #24]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30017564: e78e0727 str r0, [lr, r7, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30017568: e580400c str r4, [r0, #12]
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
3001756c: e585c000 str ip, [r5]
_Thread_Enable_dispatch();
30017570: eb0019d0 bl 3001dcb8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30017574: e1a00006 mov r0, r6 30017578: eaffffe1 b 30017504 <rtems_port_create+0x30>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
_Thread_Enable_dispatch();
3001757c: eb0019cd bl 3001dcb8 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
30017580: e3a00005 mov r0, #5 30017584: eaffffde b 30017504 <rtems_port_create+0x30>
30005b48 <rtems_print_buffer>:
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
30005b48: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int i, mod, max;
if ( !length ) return;
30005b4c: e3510000 cmp r1, #0 <== NOT EXECUTED
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
30005b50: e24dd078 sub sp, sp, #120 ; 0x78 <== NOT EXECUTED 30005b54: e1a0b000 mov fp, r0 <== NOT EXECUTED
int i, mod, max;
if ( !length ) return;
30005b58: 0a000037 beq 30005c3c <rtems_print_buffer+0xf4> <== NOT EXECUTED
mod = length % 16;
30005b5c: e1a03fc1 asr r3, r1, #31 <== NOT EXECUTED 30005b60: e1a03e23 lsr r3, r3, #28 <== NOT EXECUTED 30005b64: e081a003 add sl, r1, r3 <== NOT EXECUTED 30005b68: e20aa00f and sl, sl, #15 <== NOT EXECUTED 30005b6c: e063a00a rsb sl, r3, sl <== NOT EXECUTED
max = length - mod;
30005b70: e06a9001 rsb r9, sl, r1 <== NOT EXECUTED
for ( i=0 ; i<max ; i+=16 )
30005b74: e3590000 cmp r9, #0 <== NOT EXECUTED 30005b78: da00002d ble 30005c34 <rtems_print_buffer+0xec> <== NOT EXECUTED 30005b7c: e59f71f4 ldr r7, [pc, #500] ; 30005d78 <rtems_print_buffer+0x230><== NOT EXECUTED 30005b80: e3a08000 mov r8, #0 <== NOT EXECUTED 30005b84: e1a0400d mov r4, sp <== NOT EXECUTED
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30005b88: e3a03000 mov r3, #0 <== NOT EXECUTED
static inline void Dump_Line(
const unsigned char *buffer,
int length
);
void rtems_print_buffer(
30005b8c: e08b6008 add r6, fp, r8 <== NOT EXECUTED
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30005b90: e5cd3000 strb r3, [sp] <== NOT EXECUTED
for( i=0 ; i<length ; i++ )
30005b94: e3a05000 mov r5, #0 <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
30005b98: e7d63005 ldrb r3, [r6, r5] <== NOT EXECUTED 30005b9c: e1a0000d mov r0, sp <== NOT EXECUTED 30005ba0: e59f11d4 ldr r1, [pc, #468] ; 30005d7c <rtems_print_buffer+0x234><== NOT EXECUTED 30005ba4: e1a0200d mov r2, sp <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30005ba8: e2855001 add r5, r5, #1 <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
30005bac: eb003445 bl 30012cc8 <sprintf> <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30005bb0: e3550010 cmp r5, #16 <== NOT EXECUTED 30005bb4: 1afffff7 bne 30005b98 <rtems_print_buffer+0x50> <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
30005bb8: e1a0000d mov r0, sp <== NOT EXECUTED 30005bbc: eb003578 bl 300131a4 <strlen> <== NOT EXECUTED 30005bc0: e59f11b8 ldr r1, [pc, #440] ; 30005d80 <rtems_print_buffer+0x238><== NOT EXECUTED 30005bc4: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005bc8: e3a02002 mov r2, #2 <== NOT EXECUTED 30005bcc: eb0033ac bl 30012a84 <memcpy> <== NOT EXECUTED
for( i=0 ; i<length ; i++ )
30005bd0: e3a05000 mov r5, #0 <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005bd4: e7d63005 ldrb r3, [r6, r5] <== NOT EXECUTED 30005bd8: 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,
30005bdc: e1a0000d mov r0, sp <== NOT EXECUTED
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005be0: e0822003 add r2, r2, r3 <== NOT EXECUTED 30005be4: 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,
30005be8: e59f1194 ldr r1, [pc, #404] ; 30005d84 <rtems_print_buffer+0x23c><== NOT EXECUTED 30005bec: e3120097 tst r2, #151 ; 0x97 <== NOT EXECUTED 30005bf0: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED 30005bf4: e1a0200d mov r2, sp <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30005bf8: e2855001 add r5, r5, #1 <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
30005bfc: eb003431 bl 30012cc8 <sprintf> <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30005c00: e3550010 cmp r5, #16 <== NOT EXECUTED 30005c04: 1afffff2 bne 30005bd4 <rtems_print_buffer+0x8c> <== NOT EXECUTED
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
30005c08: e1a0000d mov r0, sp <== NOT EXECUTED 30005c0c: eb003564 bl 300131a4 <strlen> <== NOT EXECUTED 30005c10: e59f1170 ldr r1, [pc, #368] ; 30005d88 <rtems_print_buffer+0x240><== NOT EXECUTED 30005c14: e3a02003 mov r2, #3 <== NOT EXECUTED 30005c18: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005c1c: eb003398 bl 30012a84 <memcpy> <== NOT EXECUTED
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
30005c20: e2888010 add r8, r8, #16 <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
printk( line_buffer );
30005c24: e1a0000d mov r0, sp <== NOT EXECUTED 30005c28: eb000643 bl 3000753c <printk> <== NOT EXECUTED
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
30005c2c: e1590008 cmp r9, r8 <== NOT EXECUTED 30005c30: caffffd4 bgt 30005b88 <rtems_print_buffer+0x40> <== NOT EXECUTED
Dump_Line( &buffer[ i ], 16 );
if ( mod )
30005c34: e35a0000 cmp sl, #0 <== NOT EXECUTED 30005c38: 1a000001 bne 30005c44 <rtems_print_buffer+0xfc> <== NOT EXECUTED
Dump_Line( &buffer[ max ], mod );
}
30005c3c: e28dd078 add sp, sp, #120 ; 0x78 <== NOT EXECUTED
30005c40: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30005c44: e3a05000 mov r5, #0 <== NOT EXECUTED
for ( i=0 ; i<max ; i+=16 )
Dump_Line( &buffer[ i ], 16 );
if ( mod )
Dump_Line( &buffer[ max ], mod );
30005c48: e08b9009 add r9, fp, r9 <== NOT EXECUTED
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30005c4c: e5cd5000 strb r5, [sp] <== NOT EXECUTED 30005c50: d1a0400d movle r4, sp <== NOT EXECUTED
for( i=0 ; i<length ; i++ )
30005c54: da00000b ble 30005c88 <rtems_print_buffer+0x140> <== NOT EXECUTED 30005c58: e1a0400d mov r4, sp <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
30005c5c: e7d93005 ldrb r3, [r9, r5] <== NOT EXECUTED 30005c60: e1a0000d mov r0, sp <== NOT EXECUTED 30005c64: e59f1110 ldr r1, [pc, #272] ; 30005d7c <rtems_print_buffer+0x234><== NOT EXECUTED 30005c68: e1a0200d mov r2, sp <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30005c6c: e2855001 add r5, r5, #1 <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
30005c70: eb003414 bl 30012cc8 <sprintf> <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30005c74: e15a0005 cmp sl, r5 <== NOT EXECUTED 30005c78: cafffff7 bgt 30005c5c <rtems_print_buffer+0x114> <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
30005c7c: e35a000f cmp sl, #15 <== NOT EXECUTED 30005c80: d1a0500a movle r5, sl <== NOT EXECUTED 30005c84: ca000034 bgt 30005d5c <rtems_print_buffer+0x214> <== NOT EXECUTED
strcat( line_buffer, " " );
30005c88: e1a0000d mov r0, sp <== NOT EXECUTED 30005c8c: eb003544 bl 300131a4 <strlen> <== 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++ )
30005c90: e2855001 add r5, r5, #1 <== NOT EXECUTED
strcat( line_buffer, " " );
30005c94: e59f10f0 ldr r1, [pc, #240] ; 30005d8c <rtems_print_buffer+0x244><== NOT EXECUTED 30005c98: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005c9c: e3a02004 mov r2, #4 <== NOT EXECUTED 30005ca0: eb003377 bl 30012a84 <memcpy> <== 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++ )
30005ca4: e355000f cmp r5, #15 <== NOT EXECUTED 30005ca8: dafffff6 ble 30005c88 <rtems_print_buffer+0x140> <== NOT EXECUTED
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
30005cac: e1a0000d mov r0, sp <== NOT EXECUTED 30005cb0: eb00353b bl 300131a4 <strlen> <== NOT EXECUTED 30005cb4: e59f10c4 ldr r1, [pc, #196] ; 30005d80 <rtems_print_buffer+0x238><== NOT EXECUTED 30005cb8: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005cbc: e3a02002 mov r2, #2 <== NOT EXECUTED 30005cc0: eb00336f bl 30012a84 <memcpy> <== NOT EXECUTED
for( i=0 ; i<length ; i++ )
30005cc4: e35a0000 cmp sl, #0 <== NOT EXECUTED 30005cc8: d3a0a000 movle sl, #0 <== NOT EXECUTED 30005ccc: da000010 ble 30005d14 <rtems_print_buffer+0x1cc> <== NOT EXECUTED 30005cd0: e59f70a0 ldr r7, [pc, #160] ; 30005d78 <rtems_print_buffer+0x230><== NOT EXECUTED 30005cd4: e3a05000 mov r5, #0 <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005cd8: e7d93005 ldrb r3, [r9, r5] <== NOT EXECUTED 30005cdc: 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,
30005ce0: e1a0000d mov r0, sp <== NOT EXECUTED
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005ce4: e0822003 add r2, r2, r3 <== NOT EXECUTED 30005ce8: 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,
30005cec: e59f1090 ldr r1, [pc, #144] ; 30005d84 <rtems_print_buffer+0x23c><== NOT EXECUTED 30005cf0: e3120097 tst r2, #151 ; 0x97 <== NOT EXECUTED 30005cf4: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED 30005cf8: e1a0200d mov r2, sp <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30005cfc: e2855001 add r5, r5, #1 <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
30005d00: eb0033f0 bl 30012cc8 <sprintf> <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30005d04: e15a0005 cmp sl, r5 <== NOT EXECUTED 30005d08: cafffff2 bgt 30005cd8 <rtems_print_buffer+0x190> <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
30005d0c: e35a000f cmp sl, #15 <== NOT EXECUTED 30005d10: ca000008 bgt 30005d38 <rtems_print_buffer+0x1f0> <== NOT EXECUTED
strcat( line_buffer, " " );
30005d14: e1a0000d mov r0, sp <== NOT EXECUTED 30005d18: eb003521 bl 300131a4 <strlen> <== 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++ )
30005d1c: e28aa001 add sl, sl, #1 <== NOT EXECUTED
strcat( line_buffer, " " );
30005d20: e59f1068 ldr r1, [pc, #104] ; 30005d90 <rtems_print_buffer+0x248><== NOT EXECUTED 30005d24: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005d28: e3a02002 mov r2, #2 <== NOT EXECUTED 30005d2c: eb003354 bl 30012a84 <memcpy> <== 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++ )
30005d30: e35a000f cmp sl, #15 <== NOT EXECUTED 30005d34: dafffff6 ble 30005d14 <rtems_print_buffer+0x1cc> <== NOT EXECUTED
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
30005d38: e1a0000d mov r0, sp <== NOT EXECUTED 30005d3c: eb003518 bl 300131a4 <strlen> <== NOT EXECUTED 30005d40: e59f1040 ldr r1, [pc, #64] ; 30005d88 <rtems_print_buffer+0x240><== NOT EXECUTED 30005d44: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005d48: e3a02003 mov r2, #3 <== NOT EXECUTED 30005d4c: eb00334c bl 30012a84 <memcpy> <== NOT EXECUTED
printk( line_buffer );
30005d50: e1a0000d mov r0, sp <== NOT EXECUTED 30005d54: eb0005f8 bl 3000753c <printk> <== NOT EXECUTED 30005d58: eaffffb7 b 30005c3c <rtems_print_buffer+0xf4> <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
30005d5c: e1a0000d mov r0, sp <== NOT EXECUTED 30005d60: eb00350f bl 300131a4 <strlen> <== NOT EXECUTED 30005d64: e59f1014 ldr r1, [pc, #20] ; 30005d80 <rtems_print_buffer+0x238><== NOT EXECUTED 30005d68: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005d6c: e3a02002 mov r2, #2 <== NOT EXECUTED 30005d70: eb003343 bl 30012a84 <memcpy> <== NOT EXECUTED 30005d74: eaffffd5 b 30005cd0 <rtems_print_buffer+0x188> <== NOT EXECUTED
300181b8 <rtems_rate_monotonic_cancel>:
*/
rtems_status_code rtems_rate_monotonic_cancel(
rtems_id id
)
{
300181b8: e92d4030 push {r4, r5, lr}
300181bc: e24dd004 sub sp, sp, #4
300181c0: e1a01000 mov r1, r0
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
300181c4: e1a0200d mov r2, sp 300181c8: e59f0050 ldr r0, [pc, #80] ; 30018220 <rtems_rate_monotonic_cancel+0x68> 300181cc: eb00135e bl 3001cf4c <_Objects_Get>
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300181d0: e59d4000 ldr r4, [sp] 300181d4: e1a05000 mov r5, r0 300181d8: e3540000 cmp r4, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300181dc: 13a00004 movne r0, #4
{
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300181e0: 1a000006 bne 30018200 <rtems_rate_monotonic_cancel+0x48>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
300181e4: e59f3038 ldr r3, [pc, #56] ; 30018224 <rtems_rate_monotonic_cancel+0x6c> 300181e8: e5952040 ldr r2, [r5, #64] ; 0x40 300181ec: e5933004 ldr r3, [r3, #4] 300181f0: e1520003 cmp r2, r3
300181f4: 0a000003 beq 30018208 <rtems_rate_monotonic_cancel+0x50>
_Thread_Enable_dispatch();
300181f8: eb0016ae bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
300181fc: e3a00017 mov r0, #23 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018200: e28dd004 add sp, sp, #4
30018204: e8bd8030 pop {r4, r5, pc}
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
(void) _Watchdog_Remove( &the_period->Timer );
30018208: e2850010 add r0, r5, #16 3001820c: eb001b7f bl 3001f010 <_Watchdog_Remove>
the_period->state = RATE_MONOTONIC_INACTIVE;
30018210: e5854038 str r4, [r5, #56] ; 0x38
_Thread_Enable_dispatch();
30018214: eb0016a7 bl 3001dcb8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30018218: e1a00004 mov r0, r4 3001821c: eafffff7 b 30018200 <rtems_rate_monotonic_cancel+0x48>
3000a944 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000a944: e92d4070 push {r4, r5, r6, lr}
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000a948: e2504000 subs r4, r0, #0
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000a94c: e1a05001 mov r5, r1
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000a950: 03a00003 moveq r0, #3
rtems_id *id
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000a954: 08bd8070 popeq {r4, r5, r6, pc}
return RTEMS_INVALID_NAME;
if ( !id )
3000a958: e3510000 cmp r1, #0
3000a95c: 0a00002c beq 3000aa14 <rtems_rate_monotonic_create+0xd0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000a960: e59f30b4 ldr r3, [pc, #180] ; 3000aa1c <rtems_rate_monotonic_create+0xd8> 3000a964: e5932000 ldr r2, [r3] 3000a968: e2822001 add r2, r2, #1 3000a96c: 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 );
3000a970: e59f60a8 ldr r6, [pc, #168] ; 3000aa20 <rtems_rate_monotonic_create+0xdc> 3000a974: e1a00006 mov r0, r6 3000a978: eb00081b bl 3000c9ec <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
3000a97c: e3500000 cmp r0, #0
3000a980: 0a000020 beq 3000aa08 <rtems_rate_monotonic_create+0xc4>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000a984: e59f3098 ldr r3, [pc, #152] ; 3000aa24 <rtems_rate_monotonic_create+0xe0>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000a988: e5902008 ldr r2, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a98c: e596101c ldr r1, [r6, #28] 3000a990: e593e004 ldr lr, [r3, #4]
the_period->state = RATE_MONOTONIC_INACTIVE;
3000a994: e3a06000 mov r6, #0
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000a998: e3e03102 mvn r3, #-2147483648 ; 0x80000000
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000a99c: e1a0c802 lsl ip, r2, #16
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000a9a0: e580e040 str lr, [r0, #64] ; 0x40
the_period->state = RATE_MONOTONIC_INACTIVE;
3000a9a4: e5806038 str r6, [r0, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a9a8: e5806018 str r6, [r0, #24]
the_watchdog->routine = routine;
3000a9ac: e580602c str r6, [r0, #44] ; 0x2c
the_watchdog->id = id;
3000a9b0: e5806030 str r6, [r0, #48] ; 0x30
the_watchdog->user_data = user_data;
3000a9b4: e5806034 str r6, [r0, #52] ; 0x34
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000a9b8: e5806054 str r6, [r0, #84] ; 0x54 3000a9bc: e5806058 str r6, [r0, #88] ; 0x58 3000a9c0: e5806064 str r6, [r0, #100] ; 0x64 3000a9c4: e5806068 str r6, [r0, #104] ; 0x68 3000a9c8: e580606c str r6, [r0, #108] ; 0x6c 3000a9cc: e5806070 str r6, [r0, #112] ; 0x70 3000a9d0: e580607c str r6, [r0, #124] ; 0x7c 3000a9d4: e5806080 str r6, [r0, #128] ; 0x80 3000a9d8: e5806084 str r6, [r0, #132] ; 0x84 3000a9dc: e5806088 str r6, [r0, #136] ; 0x88 3000a9e0: e580305c str r3, [r0, #92] ; 0x5c 3000a9e4: e5803060 str r3, [r0, #96] ; 0x60 3000a9e8: e5803074 str r3, [r0, #116] ; 0x74 3000a9ec: e5803078 str r3, [r0, #120] ; 0x78
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a9f0: e781072c str r0, [r1, ip, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000a9f4: e580400c str r4, [r0, #12]
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
3000a9f8: e5852000 str r2, [r5]
_Thread_Enable_dispatch();
3000a9fc: eb000cd1 bl 3000dd48 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000aa00: e1a00006 mov r0, r6
3000aa04: e8bd8070 pop {r4, r5, r6, pc}
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
_Thread_Enable_dispatch();
3000aa08: eb000cce bl 3000dd48 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000aa0c: e3a00005 mov r0, #5 <== NOT EXECUTED
3000aa10: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000aa14: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000aa18: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30011584 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
30011584: e92d4bf0 push {r4, r5, r6, r7, r8, r9, fp, lr} <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
30011588: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
3001158c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30011590: e1a01000 mov r1, r0 <== NOT EXECUTED
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
30011594: 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 )
30011598: 0a000024 beq 30011630 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED 3001159c: e59f0094 ldr r0, [pc, #148] ; 30011638 <rtems_rate_monotonic_get_statistics+0xb4><== NOT EXECUTED 300115a0: e1a0200d mov r2, sp <== NOT EXECUTED 300115a4: ebffee8c bl 3000cfdc <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300115a8: e59d5000 ldr r5, [sp] <== NOT EXECUTED 300115ac: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300115b0: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300115b4: 1a00001d bne 30011630 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
300115b8: e590e054 ldr lr, [r0, #84] ; 0x54 <== NOT EXECUTED
dst->missed_count = src->missed_count;
300115bc: e5901058 ldr r1, [r0, #88] ; 0x58 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
300115c0: e2803074 add r3, r0, #116 ; 0x74 <== NOT EXECUTED
300115c4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
dst->missed_count = src->missed_count;
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
300115c8: e280905c add r9, r0, #92 ; 0x5c <== NOT EXECUTED
300115cc: e8990300 ldm r9, {r8, r9} <== NOT EXECUTED
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
300115d0: e2807064 add r7, r0, #100 ; 0x64 <== NOT EXECUTED
300115d4: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
300115d8: e280c06c add ip, r0, #108 ; 0x6c <== NOT EXECUTED
300115dc: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
300115e0: e5842020 str r2, [r4, #32] <== NOT EXECUTED 300115e4: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
300115e8: e280307c add r3, r0, #124 ; 0x7c <== NOT EXECUTED
300115ec: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
300115f0: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED
300115f4: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
300115f8: e2803084 add r3, r0, #132 ; 0x84 <== NOT EXECUTED
300115fc: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
switch ( location ) {
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
30011600: e584e000 str lr, [r4] <== NOT EXECUTED
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
30011604: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED 30011608: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
dst->missed_count = src->missed_count;
3001160c: e5841004 str r1, [r4, #4] <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
30011610: e5848008 str r8, [r4, #8] <== NOT EXECUTED 30011614: e584900c str r9, [r4, #12] <== NOT EXECUTED
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
30011618: e5846010 str r6, [r4, #16] <== NOT EXECUTED 3001161c: e5847014 str r7, [r4, #20] <== NOT EXECUTED
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
30011620: e584b018 str fp, [r4, #24] <== NOT EXECUTED 30011624: e584c01c str ip, [r4, #28] <== 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();
30011628: ebfff1c6 bl 3000dd48 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001162c: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30011630: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30011634: e8bd8bf0 pop {r4, r5, r6, r7, r8, r9, fp, pc} <== NOT EXECUTED
3001163c <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
3001163c: 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 )
30011640: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
30011644: e24dd014 sub sp, sp, #20 <== NOT EXECUTED 30011648: e1a01000 mov r1, r0 <== NOT EXECUTED
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
return RTEMS_INVALID_ADDRESS;
3001164c: 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 )
30011650: 0a000013 beq 300116a4 <rtems_rate_monotonic_get_status+0x68><== NOT EXECUTED 30011654: e28d2010 add r2, sp, #16 <== NOT EXECUTED 30011658: e59f008c ldr r0, [pc, #140] ; 300116ec <rtems_rate_monotonic_get_status+0xb0><== NOT EXECUTED 3001165c: ebffee5e bl 3000cfdc <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30011660: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 30011664: e1a03000 mov r3, r0 <== NOT EXECUTED 30011668: e3520000 cmp r2, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001166c: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !status )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30011670: 1a00000b bne 300116a4 <rtems_rate_monotonic_get_status+0x68><== NOT EXECUTED
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
30011674: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED
status->state = the_period->state;
30011678: 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;
3001167c: 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 ) {
30011680: 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;
30011684: e884000c stm r4, {r2, r3} <== NOT EXECUTED
status->state = the_period->state;
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
30011688: 1a000007 bne 300116ac <rtems_rate_monotonic_get_status+0x70><== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
3001168c: e5843008 str r3, [r4, #8] <== NOT EXECUTED 30011690: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Timespec_Set_to_zero( &status->executed_since_last_period );
30011694: e5843010 str r3, [r4, #16] <== NOT EXECUTED 30011698: e5843014 str r3, [r4, #20] <== NOT EXECUTED
status->since_last_period = since_last_period;
status->executed_since_last_period = executed;
#endif
}
_Thread_Enable_dispatch();
3001169c: ebfff1a9 bl 3000dd48 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300116a0: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300116a4: e28dd014 add sp, sp, #20 <== NOT EXECUTED
300116a8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
} else {
/*
* Grab the current status.
*/
valid_status =
300116ac: e1a0100d mov r1, sp <== NOT EXECUTED 300116b0: e28d2008 add r2, sp, #8 <== NOT EXECUTED 300116b4: ebffe4e7 bl 3000aa58 <_Rate_monotonic_Get_status> <== NOT EXECUTED
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
300116b8: e3500000 cmp r0, #0 <== NOT EXECUTED 300116bc: 0a000007 beq 300116e0 <rtems_rate_monotonic_get_status+0xa4><== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
300116c0: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
300116c4: e5842008 str r2, [r4, #8] <== NOT EXECUTED
300116c8: e584300c str r3, [r4, #12] <== NOT EXECUTED
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
300116cc: e28d3008 add r3, sp, #8 <== NOT EXECUTED
300116d0: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
300116d4: e5842010 str r2, [r4, #16] <== NOT EXECUTED
300116d8: e5843014 str r3, [r4, #20] <== NOT EXECUTED
300116dc: eaffffee b 3001169c <rtems_rate_monotonic_get_status+0x60> <== NOT EXECUTED
valid_status =
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
_Thread_Enable_dispatch();
300116e0: ebfff198 bl 3000dd48 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
300116e4: e3a0000b mov r0, #11 <== NOT EXECUTED 300116e8: eaffffed b 300116a4 <rtems_rate_monotonic_get_status+0x68> <== NOT EXECUTED
3000ac84 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
3000ac84: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000ac88: e1a04000 mov r4, r0
3000ac8c: e24dd008 sub sp, sp, #8
3000ac90: e1a05001 mov r5, r1
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
3000ac94: e59f017c ldr r0, [pc, #380] ; 3000ae18 <rtems_rate_monotonic_period+0x194> 3000ac98: e1a01004 mov r1, r4 3000ac9c: e28d2004 add r2, sp, #4 3000aca0: eb0008cd bl 3000cfdc <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000aca4: e59d3004 ldr r3, [sp, #4] 3000aca8: e1a06000 mov r6, r0 3000acac: e3530000 cmp r3, #0
3000acb0: 1a000008 bne 3000acd8 <rtems_rate_monotonic_period+0x54>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000acb4: e59f7160 ldr r7, [pc, #352] ; 3000ae1c <rtems_rate_monotonic_period+0x198>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
3000acb8: e5902040 ldr r2, [r0, #64] ; 0x40 3000acbc: e5973004 ldr r3, [r7, #4] 3000acc0: e1520003 cmp r2, r3
3000acc4: 0a000005 beq 3000ace0 <rtems_rate_monotonic_period+0x5c>
_Thread_Enable_dispatch();
3000acc8: eb000c1e bl 3000dd48 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
3000accc: e3a00017 mov r0, #23 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000acd0: e28dd008 add sp, sp, #8
3000acd4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000acd8: e3a00004 mov r0, #4 <== NOT EXECUTED 3000acdc: eafffffb b 3000acd0 <rtems_rate_monotonic_period+0x4c> <== NOT EXECUTED
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
3000ace0: e3550000 cmp r5, #0
3000ace4: 1a000008 bne 3000ad0c <rtems_rate_monotonic_period+0x88>
switch ( the_period->state ) {
3000ace8: e5903038 ldr r3, [r0, #56] ; 0x38 3000acec: e3530004 cmp r3, #4 3000acf0: 959f2128 ldrls r2, [pc, #296] ; 3000ae20 <rtems_rate_monotonic_period+0x19c> 3000acf4: 81a00005 movhi r0, r5 3000acf8: 97920103 ldrls r0, [r2, r3, lsl #2]
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
3000acfc: e58d0000 str r0, [sp] 3000ad00: eb000c10 bl 3000dd48 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
3000ad04: e59d0000 ldr r0, [sp] 3000ad08: eafffff0 b 3000acd0 <rtems_rate_monotonic_period+0x4c>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ad0c: e10f8000 mrs r8, CPSR 3000ad10: e3883080 orr r3, r8, #128 ; 0x80 3000ad14: e129f003 msr CPSR_fc, r3
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
3000ad18: e5903038 ldr r3, [r0, #56] ; 0x38 3000ad1c: e3530000 cmp r3, #0
3000ad20: 0a00000e beq 3000ad60 <rtems_rate_monotonic_period+0xdc>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
3000ad24: e3530002 cmp r3, #2
3000ad28: 0a00001f beq 3000adac <rtems_rate_monotonic_period+0x128>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
3000ad2c: e3530004 cmp r3, #4 <== NOT EXECUTED 3000ad30: 1affffe8 bne 3000acd8 <rtems_rate_monotonic_period+0x54> <== NOT EXECUTED
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
3000ad34: ebffff97 bl 3000ab98 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ad38: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
3000ad3c: e3a03002 mov r3, #2 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ad40: e59f00dc ldr r0, [pc, #220] ; 3000ae24 <rtems_rate_monotonic_period+0x1a0><== NOT EXECUTED 3000ad44: e2861010 add r1, r6, #16 <== NOT EXECUTED 3000ad48: e5863038 str r3, [r6, #56] ; 0x38 <== NOT EXECUTED
the_period->next_length = length;
3000ad4c: e586503c str r5, [r6, #60] ; 0x3c <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000ad50: e586501c str r5, [r6, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ad54: eb000fe2 bl 3000ece4 <_Watchdog_Insert> <== NOT EXECUTED
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
3000ad58: e3a00006 mov r0, #6 <== NOT EXECUTED 3000ad5c: eaffffe6 b 3000acfc <rtems_rate_monotonic_period+0x78> <== NOT EXECUTED
3000ad60: e129f008 msr CPSR_fc, r8
_ISR_Enable( level );
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
3000ad64: ebffff6b bl 3000ab18 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
3000ad68: e3a03002 mov r3, #2 3000ad6c: e5863038 str r3, [r6, #56] ; 0x38
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000ad70: e59f30b0 ldr r3, [pc, #176] ; 3000ae28 <rtems_rate_monotonic_period+0x1a4>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000ad74: e3a07000 mov r7, #0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ad78: e59f00a4 ldr r0, [pc, #164] ; 3000ae24 <rtems_rate_monotonic_period+0x1a0> 3000ad7c: e2861010 add r1, r6, #16
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000ad80: e586302c str r3, [r6, #44] ; 0x2c
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000ad84: e5867018 str r7, [r6, #24]
the_watchdog->routine = routine; the_watchdog->id = id;
3000ad88: e5864030 str r4, [r6, #48] ; 0x30
the_watchdog->user_data = user_data;
3000ad8c: e5867034 str r7, [r6, #52] ; 0x34
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
3000ad90: e586503c str r5, [r6, #60] ; 0x3c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000ad94: e586501c str r5, [r6, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ad98: eb000fd1 bl 3000ece4 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
3000ad9c: e58d7000 str r7, [sp] 3000ada0: eb000be8 bl 3000dd48 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ada4: e59d0000 ldr r0, [sp] 3000ada8: eaffffc8 b 3000acd0 <rtems_rate_monotonic_period+0x4c>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
3000adac: ebffff79 bl 3000ab98 <_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;
3000adb0: e3a03001 mov r3, #1 3000adb4: e5863038 str r3, [r6, #56] ; 0x38
the_period->next_length = length;
3000adb8: e586503c str r5, [r6, #60] ; 0x3c 3000adbc: e129f008 msr CPSR_fc, r8
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
3000adc0: e5973004 ldr r3, [r7, #4] 3000adc4: e5962008 ldr r2, [r6, #8]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
3000adc8: e1a00003 mov r0, r3
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
3000adcc: e5832020 str r2, [r3, #32]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
3000add0: e3a01901 mov r1, #16384 ; 0x4000 3000add4: eb000e03 bl 3000e5e8 <_Thread_Set_state>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000add8: e10f2000 mrs r2, CPSR 3000addc: e3823080 orr r3, r2, #128 ; 0x80 3000ade0: 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;
3000ade4: e3a01002 mov r1, #2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
3000ade8: e5963038 ldr r3, [r6, #56] ; 0x38
the_period->state = RATE_MONOTONIC_ACTIVE;
3000adec: e5861038 str r1, [r6, #56] ; 0x38
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000adf0: 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 )
3000adf4: e3530003 cmp r3, #3
3000adf8: 0a000002 beq 3000ae08 <rtems_rate_monotonic_period+0x184>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
3000adfc: eb000bd1 bl 3000dd48 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ae00: e3a00000 mov r0, #0 <== NOT EXECUTED 3000ae04: eaffffb1 b 3000acd0 <rtems_rate_monotonic_period+0x4c> <== NOT EXECUTED
/*
* 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 )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
3000ae08: e5970004 ldr r0, [r7, #4] <== NOT EXECUTED 3000ae0c: e3a01901 mov r1, #16384 ; 0x4000 <== NOT EXECUTED 3000ae10: eb000aef bl 3000d9d4 <_Thread_Clear_state> <== NOT EXECUTED 3000ae14: eafffff8 b 3000adfc <rtems_rate_monotonic_period+0x178> <== NOT EXECUTED
3000b068 <rtems_rate_monotonic_report_statistics>:
}
}
void rtems_rate_monotonic_report_statistics( void )
{
rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin );
3000b068: e59f1004 ldr r1, [pc, #4] ; 3000b074 <rtems_rate_monotonic_report_statistics+0xc><== NOT EXECUTED 3000b06c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b070: eaffff6d b 3000ae2c <rtems_rate_monotonic_report_statistics_with_plugin><== NOT EXECUTED
3000ae2c <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000ae2c: 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 )
3000ae30: e2515000 subs r5, r1, #0 <== NOT EXECUTED
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000ae34: e24dd078 sub sp, sp, #120 ; 0x78 <== NOT EXECUTED 3000ae38: e1a08000 mov r8, 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 )
3000ae3c: 0a000047 beq 3000af60 <rtems_rate_monotonic_report_statistics_with_plugin+0x134><== NOT EXECUTED
return;
(*print)( context, "Period information by period\n" );
3000ae40: e59f11f4 ldr r1, [pc, #500] ; 3000b03c <rtems_rate_monotonic_report_statistics_with_plugin+0x210><== NOT EXECUTED 3000ae44: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ae48: e12fff15 bx r5 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
3000ae4c: e59f11ec ldr r1, [pc, #492] ; 3000b040 <rtems_rate_monotonic_report_statistics_with_plugin+0x214><== NOT EXECUTED 3000ae50: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ae54: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ae58: e12fff15 bx r5 <== NOT EXECUTED
(*print)( context, "--- Wall times are in seconds ---\n" );
3000ae5c: e59f11e0 ldr r1, [pc, #480] ; 3000b044 <rtems_rate_monotonic_report_statistics_with_plugin+0x218><== NOT EXECUTED 3000ae60: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ae64: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ae68: e12fff15 bx r5 <== 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 ;
3000ae6c: e59f61d4 ldr r6, [pc, #468] ; 3000b048 <rtems_rate_monotonic_report_statistics_with_plugin+0x21c><== NOT EXECUTED
Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED "
3000ae70: e59f11d4 ldr r1, [pc, #468] ; 3000b04c <rtems_rate_monotonic_report_statistics_with_plugin+0x220><== NOT EXECUTED 3000ae74: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ae78: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ae7c: e12fff15 bx r5 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
3000ae80: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ae84: e59f11c4 ldr r1, [pc, #452] ; 3000b050 <rtems_rate_monotonic_report_statistics_with_plugin+0x224><== NOT EXECUTED 3000ae88: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ae8c: e12fff15 bx r5 <== 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 ;
3000ae90: e5964008 ldr r4, [r6, #8] <== NOT EXECUTED 3000ae94: e596300c ldr r3, [r6, #12] <== NOT EXECUTED 3000ae98: e1540003 cmp r4, r3 <== NOT EXECUTED 3000ae9c: 8a00002f bhi 3000af60 <rtems_rate_monotonic_report_statistics_with_plugin+0x134><== NOT EXECUTED 3000aea0: e28d7018 add r7, sp, #24 <== 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;
3000aea4: e2870018 add r0, r7, #24 <== 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;
3000aea8: e2871030 add r1, r7, #48 ; 0x30 <== NOT EXECUTED
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 );
(*print)( context,
3000aeac: e59fa1a0 ldr sl, [pc, #416] ; 3000b054 <rtems_rate_monotonic_report_statistics_with_plugin+0x228><== NOT EXECUTED
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
3000aeb0: e28d9070 add r9, sp, #112 ; 0x70 <== 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;
3000aeb4: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
3000aeb8: e28db068 add fp, 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;
3000aebc: e58d1014 str r1, [sp, #20] <== NOT EXECUTED 3000aec0: ea000003 b 3000aed4 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8><== 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 ;
3000aec4: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3000aec8: e2844001 add r4, r4, #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 ;
3000aecc: e1530004 cmp r3, r4 <== NOT EXECUTED 3000aed0: 3a000022 bcc 3000af60 <rtems_rate_monotonic_report_statistics_with_plugin+0x134><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
3000aed4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aed8: e1a01007 mov r1, r7 <== NOT EXECUTED 3000aedc: eb0019a8 bl 30011584 <rtems_rate_monotonic_get_statistics> <== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL )
3000aee0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000aee4: 1afffff6 bne 3000aec4 <rtems_rate_monotonic_report_statistics_with_plugin+0x98><== 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 );
3000aee8: e28d1050 add r1, sp, #80 ; 0x50 <== NOT EXECUTED 3000aeec: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aef0: eb0019d1 bl 3001163c <rtems_rate_monotonic_get_status> <== NOT EXECUTED
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
3000aef4: e1a02009 mov r2, r9 <== NOT EXECUTED 3000aef8: e3a01005 mov r1, #5 <== NOT EXECUTED 3000aefc: e59d0050 ldr r0, [sp, #80] ; 0x50 <== NOT EXECUTED 3000af00: eb0000bd bl 3000b1fc <rtems_object_get_name> <== NOT EXECUTED
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
3000af04: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3000af08: e59f1148 ldr r1, [pc, #328] ; 3000b058 <rtems_rate_monotonic_report_statistics_with_plugin+0x22c><== NOT EXECUTED 3000af0c: e58d3000 str r3, [sp] <== NOT EXECUTED 3000af10: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 3000af14: e1a02004 mov r2, r4 <== NOT EXECUTED 3000af18: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000af1c: e1a00008 mov r0, r8 <== NOT EXECUTED 3000af20: e1a03009 mov r3, r9 <== NOT EXECUTED 3000af24: e1a0e00f mov lr, pc <== NOT EXECUTED 3000af28: e12fff15 bx r5 <== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
3000af2c: e59d3018 ldr r3, [sp, #24] <== 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 );
3000af30: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
3000af34: e3530000 cmp r3, #0 <== 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 );
3000af38: e1a0200b mov r2, fp <== NOT EXECUTED
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
3000af3c: e59f1118 ldr r1, [pc, #280] ; 3000b05c <rtems_rate_monotonic_report_statistics_with_plugin+0x230><== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
3000af40: 1a000008 bne 3000af68 <rtems_rate_monotonic_report_statistics_with_plugin+0x13c><== NOT EXECUTED
(*print)( context, "\n" );
3000af44: e1a00008 mov r0, r8 <== NOT EXECUTED 3000af48: e1a0e00f mov lr, pc <== NOT EXECUTED 3000af4c: e12fff15 bx r5 <== 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 ;
3000af50: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3000af54: e2844001 add r4, r4, #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 ;
3000af58: e1530004 cmp r3, r4 <== NOT EXECUTED 3000af5c: 2affffdc bcs 3000aed4 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8><== NOT EXECUTED
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
3000af60: e28dd078 add sp, sp, #120 ; 0x78 <== NOT EXECUTED
3000af64: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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 );
3000af68: e1a01003 mov r1, r3 <== NOT EXECUTED 3000af6c: eb000e5e bl 3000e8ec <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
3000af70: e59d102c ldr r1, [sp, #44] ; 0x2c <== NOT EXECUTED 3000af74: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED 3000af78: e0c0e19a smull lr, r0, sl, r1 <== NOT EXECUTED 3000af7c: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000af80: e1a01fc1 asr r1, r1, #31 <== NOT EXECUTED 3000af84: e0611340 rsb r1, r1, r0, asr #6 <== NOT EXECUTED 3000af88: e58d3000 str r3, [sp] <== NOT EXECUTED 3000af8c: e58d1004 str r1, [sp, #4] <== NOT EXECUTED 3000af90: e0c3c29a smull ip, r3, sl, r2 <== NOT EXECUTED 3000af94: e1a01fc2 asr r1, r2, #31 <== NOT EXECUTED 3000af98: e59d2068 ldr r2, [sp, #104] ; 0x68 <== NOT EXECUTED 3000af9c: e0613343 rsb r3, r1, r3, asr #6 <== NOT EXECUTED 3000afa0: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 3000afa4: e59d206c ldr r2, [sp, #108] ; 0x6c <== NOT EXECUTED 3000afa8: e0c1029a smull r0, r1, sl, r2 <== NOT EXECUTED 3000afac: e1a02fc2 asr r2, r2, #31 <== NOT EXECUTED 3000afb0: e0622341 rsb r2, r2, r1, asr #6 <== NOT EXECUTED 3000afb4: e58d200c str r2, [sp, #12] <== NOT EXECUTED 3000afb8: e59f10a0 ldr r1, [pc, #160] ; 3000b060 <rtems_rate_monotonic_report_statistics_with_plugin+0x234><== NOT EXECUTED 3000afbc: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000afc0: e1a00008 mov r0, r8 <== NOT EXECUTED 3000afc4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000afc8: e12fff15 bx r5 <== 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);
3000afcc: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 3000afd0: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED 3000afd4: e1a0200b mov r2, fp <== NOT EXECUTED 3000afd8: eb000e43 bl 3000e8ec <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
3000afdc: e59d2040 ldr r2, [sp, #64] ; 0x40 <== NOT EXECUTED 3000afe0: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED 3000afe4: e58d2000 str r2, [sp] <== NOT EXECUTED 3000afe8: e59d2044 ldr r2, [sp, #68] ; 0x44 <== NOT EXECUTED 3000afec: e0c0139a smull r1, r0, sl, r3 <== NOT EXECUTED 3000aff0: e0c1c29a smull ip, r1, sl, r2 <== NOT EXECUTED 3000aff4: e1a02fc2 asr r2, r2, #31 <== NOT EXECUTED 3000aff8: e0622341 rsb r2, r2, r1, asr #6 <== NOT EXECUTED 3000affc: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000b000: e59d2068 ldr r2, [sp, #104] ; 0x68 <== NOT EXECUTED 3000b004: e1a03fc3 asr r3, r3, #31 <== NOT EXECUTED 3000b008: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 3000b00c: e59d206c ldr r2, [sp, #108] ; 0x6c <== NOT EXECUTED 3000b010: e0633340 rsb r3, r3, r0, asr #6 <== NOT EXECUTED 3000b014: e0cce29a smull lr, ip, sl, r2 <== NOT EXECUTED 3000b018: e1a02fc2 asr r2, r2, #31 <== NOT EXECUTED 3000b01c: e062234c rsb r2, r2, ip, asr #6 <== NOT EXECUTED 3000b020: e58d200c str r2, [sp, #12] <== NOT EXECUTED 3000b024: e59f1038 ldr r1, [pc, #56] ; 3000b064 <rtems_rate_monotonic_report_statistics_with_plugin+0x238><== NOT EXECUTED 3000b028: e1a00008 mov r0, r8 <== NOT EXECUTED 3000b02c: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 3000b030: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b034: e12fff15 bx r5 <== NOT EXECUTED 3000b038: eaffffa1 b 3000aec4 <rtems_rate_monotonic_report_statistics_with_plugin+0x98><== NOT EXECUTED
3000b078 <rtems_rate_monotonic_reset_all_statistics>:
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b078: e59f3040 ldr r3, [pc, #64] ; 3000b0c0 <rtems_rate_monotonic_reset_all_statistics+0x48><== NOT EXECUTED
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
3000b07c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000b080: e5932000 ldr r2, [r3] <== NOT EXECUTED
3000b084: e2822001 add r2, r2, #1 <== NOT EXECUTED
3000b088: 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 ;
3000b08c: e59f5030 ldr r5, [pc, #48] ; 3000b0c4 <rtems_rate_monotonic_reset_all_statistics+0x4c><== NOT EXECUTED 3000b090: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED 3000b094: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000b098: e1540003 cmp r4, r3 <== NOT EXECUTED 3000b09c: 8a000005 bhi 3000b0b8 <rtems_rate_monotonic_reset_all_statistics+0x40><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
3000b0a0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b0a4: eb000007 bl 3000b0c8 <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 ;
3000b0a8: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3000b0ac: 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 ;
3000b0b0: e1530004 cmp r3, r4 <== NOT EXECUTED 3000b0b4: 2afffff9 bcs 3000b0a0 <rtems_rate_monotonic_reset_all_statistics+0x28><== NOT EXECUTED
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
3000b0b8: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
3000b0bc: ea000b21 b 3000dd48 <_Thread_Enable_dispatch> <== NOT EXECUTED
3000b0c8 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
3000b0c8: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b0cc: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000b0d0: e1a01000 mov r1, r0 <== NOT EXECUTED
3000b0d4: e1a0200d mov r2, sp <== NOT EXECUTED
3000b0d8: e59f005c ldr r0, [pc, #92] ; 3000b13c <rtems_rate_monotonic_reset_statistics+0x74><== NOT EXECUTED
3000b0dc: eb0007be bl 3000cfdc <_Objects_Get> <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000b0e0: e59d4000 ldr r4, [sp] <== NOT EXECUTED 3000b0e4: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000b0e8: 13a00004 movne r0, #4 <== NOT EXECUTED
{
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000b0ec: 1a000010 bne 3000b134 <rtems_rate_monotonic_reset_statistics+0x6c><== NOT EXECUTED
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
3000b0f0: e3e03102 mvn r3, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000b0f4: e5804054 str r4, [r0, #84] ; 0x54 <== NOT EXECUTED 3000b0f8: e5804058 str r4, [r0, #88] ; 0x58 <== NOT EXECUTED 3000b0fc: e5804064 str r4, [r0, #100] ; 0x64 <== NOT EXECUTED 3000b100: e5804068 str r4, [r0, #104] ; 0x68 <== NOT EXECUTED 3000b104: e580406c str r4, [r0, #108] ; 0x6c <== NOT EXECUTED 3000b108: e5804070 str r4, [r0, #112] ; 0x70 <== NOT EXECUTED 3000b10c: e580407c str r4, [r0, #124] ; 0x7c <== NOT EXECUTED 3000b110: e5804080 str r4, [r0, #128] ; 0x80 <== NOT EXECUTED 3000b114: e5804084 str r4, [r0, #132] ; 0x84 <== NOT EXECUTED 3000b118: e5804088 str r4, [r0, #136] ; 0x88 <== NOT EXECUTED 3000b11c: e580305c str r3, [r0, #92] ; 0x5c <== NOT EXECUTED 3000b120: e5803060 str r3, [r0, #96] ; 0x60 <== NOT EXECUTED 3000b124: e5803074 str r3, [r0, #116] ; 0x74 <== NOT EXECUTED 3000b128: e5803078 str r3, [r0, #120] ; 0x78 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b12c: eb000b05 bl 3000dd48 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b130: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000b134: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b138: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3001899c <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3001899c: 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 ) )
300189a0: e2509000 subs r9, r0, #0
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
300189a4: e24dd004 sub sp, sp, #4 300189a8: e1a05001 mov r5, r1 300189ac: e1a07002 mov r7, r2 300189b0: e1a06003 mov r6, r3 300189b4: e59db02c ldr fp, [sp, #44] ; 0x2c
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
300189b8: 03a05003 moveq r5, #3
)
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
300189bc: 0a00001a beq 30018a2c <rtems_region_create+0x90>
return RTEMS_INVALID_NAME;
if ( !starting_address )
300189c0: e3550000 cmp r5, #0
300189c4: 0a000035 beq 30018aa0 <rtems_region_create+0x104>
return RTEMS_INVALID_ADDRESS;
if ( !id )
300189c8: e35b0000 cmp fp, #0
300189cc: 0a000033 beq 30018aa0 <rtems_region_create+0x104>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
300189d0: e59f80d0 ldr r8, [pc, #208] ; 30018aa8 <rtems_region_create+0x10c>
* 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 );
300189d4: e59fa0d0 ldr sl, [pc, #208] ; 30018aac <rtems_region_create+0x110> 300189d8: e5980000 ldr r0, [r8] 300189dc: eb0009b4 bl 3001b0b4 <_API_Mutex_Lock> 300189e0: e1a0000a mov r0, sl 300189e4: eb001017 bl 3001ca48 <_Objects_Allocate>
the_region = _Region_Allocate();
if ( !the_region )
300189e8: e2504000 subs r4, r0, #0
return_status = RTEMS_TOO_MANY;
300189ec: 03a05005 moveq r5, #5
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Allocate();
if ( !the_region )
300189f0: 0a00000b beq 30018a24 <rtems_region_create+0x88>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
300189f4: e2840068 add r0, r4, #104 ; 0x68 300189f8: e1a01005 mov r1, r5 300189fc: e1a02007 mov r2, r7 30018a00: e1a03006 mov r3, r6 30018a04: eb000eed bl 3001c5c0 <_Heap_Initialize>
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
30018a08: e3500000 cmp r0, #0
if ( !the_region )
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
30018a0c: e584005c str r0, [r4, #92] ; 0x5c
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
30018a10: 1a000008 bne 30018a38 <rtems_region_create+0x9c>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
30018a14: e1a0000a mov r0, sl <== NOT EXECUTED 30018a18: e1a01004 mov r1, r4 <== NOT EXECUTED 30018a1c: eb0010e3 bl 3001cdb0 <_Objects_Free> <== NOT EXECUTED
_Region_Free( the_region );
return_status = RTEMS_INVALID_SIZE;
30018a20: e3a05008 mov r5, #8 <== NOT EXECUTED
*id = the_region->Object.id;
return_status = RTEMS_SUCCESSFUL;
}
}
_RTEMS_Unlock_allocator();
30018a24: e5980000 ldr r0, [r8] 30018a28: eb0009bd bl 3001b124 <_API_Mutex_Unlock>
return return_status; }
30018a2c: e1a00005 mov r0, r5
30018a30: e28dd004 add sp, sp, #4
30018a34: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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(
30018a38: e59d3028 ldr r3, [sp, #40] ; 0x28
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;
30018a3c: e3a0c000 mov ip, #0
_Thread_queue_Initialize(
30018a40: e3130004 tst r3, #4
return_status = RTEMS_INVALID_SIZE;
}
else {
the_region->starting_address = starting_address;
30018a44: e5845050 str r5, [r4, #80] ; 0x50
the_region->length = length;
the_region->page_size = page_size;
the_region->attribute_set = attribute_set;
30018a48: e5843060 str r3, [r4, #96] ; 0x60
the_region->number_of_used_blocks = 0;
30018a4c: e584c064 str ip, [r4, #100] ; 0x64
}
else {
the_region->starting_address = starting_address;
the_region->length = length;
30018a50: e5847054 str r7, [r4, #84] ; 0x54
the_region->page_size = page_size;
30018a54: e5846058 str r6, [r4, #88] ; 0x58
the_region->attribute_set = attribute_set;
the_region->number_of_used_blocks = 0;
_Thread_queue_Initialize(
30018a58: e2840010 add r0, r4, #16 30018a5c: 03a01000 moveq r1, #0 30018a60: 13a01001 movne r1, #1 30018a64: e3a02040 mov r2, #64 ; 0x40 30018a68: e3a03006 mov r3, #6 30018a6c: e58dc000 str ip, [sp] 30018a70: eb00166a bl 3001e420 <_Thread_queue_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30018a74: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30018a78: e59a201c ldr r2, [sl, #28]
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
return_status = RTEMS_SUCCESSFUL;
30018a7c: e59dc000 ldr ip, [sp]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30018a80: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30018a84: e7824721 str r4, [r2, r1, lsr #14]
}
}
_RTEMS_Unlock_allocator();
30018a88: e5980000 ldr r0, [r8]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30018a8c: e584900c str r9, [r4, #12]
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
30018a90: e58b3000 str r3, [fp]
return_status = RTEMS_SUCCESSFUL;
30018a94: e1a0500c mov r5, ip
}
}
_RTEMS_Unlock_allocator();
30018a98: eb0009a1 bl 3001b124 <_API_Mutex_Unlock> 30018a9c: eaffffe2 b 30018a2c <rtems_region_create+0x90>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
30018aa0: e3a05009 mov r5, #9 <== NOT EXECUTED 30018aa4: eaffffe0 b 30018a2c <rtems_region_create+0x90> <== NOT EXECUTED
30018b34 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
30018b34: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
30018b38: e2518000 subs r8, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
30018b3c: e1a05000 mov r5, r0 <== NOT EXECUTED 30018b40: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30018b44: e1a07002 mov r7, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
30018b48: 03a05009 moveq r5, #9 <== NOT EXECUTED
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
30018b4c: 0a00000d beq 30018b88 <rtems_region_extend+0x54> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
30018b50: e59f407c ldr r4, [pc, #124] ; 30018bd4 <rtems_region_extend+0xa0><== NOT EXECUTED 30018b54: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018b58: eb000955 bl 3001b0b4 <_API_Mutex_Lock> <== NOT EXECUTED
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
30018b5c: e1a01005 mov r1, r5 <== NOT EXECUTED 30018b60: e59f0070 ldr r0, [pc, #112] ; 30018bd8 <rtems_region_extend+0xa4><== NOT EXECUTED 30018b64: e1a0200d mov r2, sp <== NOT EXECUTED 30018b68: eb0010e7 bl 3001cf0c <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30018b6c: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30018b70: e1a06000 mov r6, r0 <== NOT EXECUTED 30018b74: e3550000 cmp r5, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30018b78: 13a05004 movne r5, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Get( id, &location );
switch ( location ) {
30018b7c: 0a000004 beq 30018b94 <rtems_region_extend+0x60> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018b80: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018b84: eb000966 bl 3001b124 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30018b88: e1a00005 mov r0, r5 <== NOT EXECUTED
30018b8c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30018b90: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
extend_ok = _Heap_Extend(
30018b94: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30018b98: e1a01008 mov r1, r8 <== NOT EXECUTED 30018b9c: e1a02007 mov r2, r7 <== NOT EXECUTED 30018ba0: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30018ba4: eb000cc5 bl 3001bec0 <_Heap_Extend> <== NOT EXECUTED
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
30018ba8: 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;
30018bac: 03a05009 moveq r5, #9 <== NOT EXECUTED
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
30018bb0: 0afffff2 beq 30018b80 <rtems_region_extend+0x4c> <== NOT EXECUTED
the_region->length += amount_extended;
30018bb4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30018bb8: e5962054 ldr r2, [r6, #84] ; 0x54 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
30018bbc: e596105c ldr r1, [r6, #92] ; 0x5c <== NOT EXECUTED
length,
&amount_extended
);
if ( extend_ok ) {
the_region->length += amount_extended;
30018bc0: e0822003 add r2, r2, r3 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
30018bc4: e0813003 add r3, r1, r3 <== NOT EXECUTED
length,
&amount_extended
);
if ( extend_ok ) {
the_region->length += amount_extended;
30018bc8: e5862054 str r2, [r6, #84] ; 0x54 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
30018bcc: e586305c str r3, [r6, #92] ; 0x5c <== NOT EXECUTED 30018bd0: eaffffea b 30018b80 <rtems_region_extend+0x4c> <== NOT EXECUTED
30018bdc <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30018bdc: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30018be0: e2515000 subs r5, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30018be4: e1a06000 mov r6, r0 <== NOT EXECUTED 30018be8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
30018bec: 03a06009 moveq r6, #9 <== NOT EXECUTED
{
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30018bf0: 0a00000c beq 30018c28 <rtems_region_get_free_information+0x4c><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30018bf4: e59f4054 ldr r4, [pc, #84] ; 30018c50 <rtems_region_get_free_information+0x74><== NOT EXECUTED 30018bf8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018bfc: eb00092c bl 3001b0b4 <_API_Mutex_Lock> <== NOT EXECUTED 30018c00: e1a01006 mov r1, r6 <== NOT EXECUTED 30018c04: e59f0048 ldr r0, [pc, #72] ; 30018c54 <rtems_region_get_free_information+0x78><== NOT EXECUTED 30018c08: e1a0200d mov r2, sp <== NOT EXECUTED 30018c0c: eb0010be bl 3001cf0c <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30018c10: e59d6000 ldr r6, [sp] <== NOT EXECUTED 30018c14: e3560000 cmp r6, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30018c18: 13a06004 movne r6, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
30018c1c: 0a000004 beq 30018c34 <rtems_region_get_free_information+0x58><== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018c20: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018c24: eb00093e bl 3001b124 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30018c28: e1a00006 mov r0, r6 <== NOT EXECUTED
30018c2c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30018c30: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->Used.number = 0;
30018c34: e585600c str r6, [r5, #12] <== NOT EXECUTED
the_info->Used.total = 0;
30018c38: e5856014 str r6, [r5, #20] <== NOT EXECUTED
the_info->Used.largest = 0;
30018c3c: e5856010 str r6, [r5, #16] <== NOT EXECUTED
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
30018c40: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30018c44: e1a01005 mov r1, r5 <== NOT EXECUTED 30018c48: eb000dbb bl 3001c33c <_Heap_Get_free_information> <== NOT EXECUTED
return_status = RTEMS_SUCCESSFUL;
break;
30018c4c: eafffff3 b 30018c20 <rtems_region_get_free_information+0x44><== NOT EXECUTED
30018c58 <rtems_region_get_information>:
rtems_status_code rtems_region_get_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30018c58: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30018c5c: e2515000 subs r5, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30018c60: e1a06000 mov r6, r0 <== NOT EXECUTED 30018c64: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
30018c68: 03a06009 moveq r6, #9 <== NOT EXECUTED
{
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30018c6c: 0a00000c beq 30018ca4 <rtems_region_get_information+0x4c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30018c70: e59f4048 ldr r4, [pc, #72] ; 30018cc0 <rtems_region_get_information+0x68><== NOT EXECUTED 30018c74: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018c78: eb00090d bl 3001b0b4 <_API_Mutex_Lock> <== NOT EXECUTED 30018c7c: e1a01006 mov r1, r6 <== NOT EXECUTED 30018c80: e59f003c ldr r0, [pc, #60] ; 30018cc4 <rtems_region_get_information+0x6c><== NOT EXECUTED 30018c84: e1a0200d mov r2, sp <== NOT EXECUTED 30018c88: eb00109f bl 3001cf0c <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30018c8c: e59d6000 ldr r6, [sp] <== NOT EXECUTED 30018c90: e3560000 cmp r6, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30018c94: 13a06004 movne r6, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
30018c98: 0a000004 beq 30018cb0 <rtems_region_get_information+0x58> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018c9c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018ca0: eb00091f bl 3001b124 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30018ca4: e1a00006 mov r0, r6 <== NOT EXECUTED
30018ca8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30018cac: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Heap_Get_information( &the_region->Memory, the_info );
30018cb0: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30018cb4: e1a01005 mov r1, r5 <== NOT EXECUTED 30018cb8: eb000db9 bl 3001c3a4 <_Heap_Get_information> <== NOT EXECUTED
return_status = RTEMS_SUCCESSFUL;
break;
30018cbc: eafffff6 b 30018c9c <rtems_region_get_information+0x44> <== NOT EXECUTED
30018e0c <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
30018e0c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
30018e10: e2516000 subs r6, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
30018e14: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30018e18: e1a07000 mov r7, r0 <== NOT EXECUTED 30018e1c: e1a05002 mov r5, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
30018e20: 0a00001b beq 30018e94 <rtems_region_get_segment_size+0x88> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !size )
30018e24: e3520000 cmp r2, #0 <== NOT EXECUTED 30018e28: 0a000019 beq 30018e94 <rtems_region_get_segment_size+0x88> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30018e2c: e59f4068 ldr r4, [pc, #104] ; 30018e9c <rtems_region_get_segment_size+0x90><== NOT EXECUTED 30018e30: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018e34: eb00089e bl 3001b0b4 <_API_Mutex_Lock> <== NOT EXECUTED 30018e38: e59f0060 ldr r0, [pc, #96] ; 30018ea0 <rtems_region_get_segment_size+0x94><== NOT EXECUTED 30018e3c: e1a01007 mov r1, r7 <== NOT EXECUTED 30018e40: e1a0200d mov r2, sp <== NOT EXECUTED 30018e44: eb001030 bl 3001cf0c <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30018e48: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30018e4c: e3530000 cmp r3, #0 <== NOT EXECUTED 30018e50: 0a000007 beq 30018e74 <rtems_region_get_segment_size+0x68> <== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
30018e54: e3530001 cmp r3, #1 <== NOT EXECUTED 30018e58: 03a05004 moveq r5, #4 <== NOT EXECUTED 30018e5c: 13a05000 movne r5, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018e60: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018e64: eb0008ae bl 3001b124 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30018e68: e1a00005 mov r0, r5 <== NOT EXECUTED
30018e6c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30018e70: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
30018e74: e1a02005 mov r2, r5 <== NOT EXECUTED 30018e78: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30018e7c: e1a01006 mov r1, r6 <== NOT EXECUTED 30018e80: eb000eb7 bl 3001c964 <_Heap_Size_of_alloc_area> <== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
30018e84: e3500000 cmp r0, #0 <== NOT EXECUTED 30018e88: 03a05009 moveq r5, #9 <== NOT EXECUTED 30018e8c: 13a05000 movne r5, #0 <== NOT EXECUTED 30018e90: eafffff2 b 30018e60 <rtems_region_get_segment_size+0x54> <== NOT EXECUTED
if ( !segment )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
30018e94: e3a05009 mov r5, #9 <== NOT EXECUTED 30018e98: eafffff2 b 30018e68 <rtems_region_get_segment_size+0x5c> <== NOT EXECUTED
30018ed4 <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
30018ed4: e92d41f0 push {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 )
30018ed8: e2535000 subs r5, r3, #0 <== NOT EXECUTED
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
30018edc: e1a08000 mov r8, r0 <== NOT EXECUTED 30018ee0: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 30018ee4: e1a07001 mov r7, r1 <== NOT EXECUTED 30018ee8: 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;
30018eec: 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 )
30018ef0: 0a00000d beq 30018f2c <rtems_region_resize_segment+0x58> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30018ef4: e59f408c ldr r4, [pc, #140] ; 30018f88 <rtems_region_resize_segment+0xb4><== NOT EXECUTED 30018ef8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018efc: eb00086c bl 3001b0b4 <_API_Mutex_Lock> <== NOT EXECUTED 30018f00: e1a01008 mov r1, r8 <== NOT EXECUTED 30018f04: e59f0080 ldr r0, [pc, #128] ; 30018f8c <rtems_region_resize_segment+0xb8><== NOT EXECUTED 30018f08: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30018f0c: eb000ffe bl 3001cf0c <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30018f10: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30018f14: e1a08000 mov r8, r0 <== NOT EXECUTED 30018f18: e3530000 cmp r3, #0 <== NOT EXECUTED 30018f1c: 0a000004 beq 30018f34 <rtems_region_resize_segment+0x60> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018f20: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018f24: eb00087e bl 3001b124 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status;
30018f28: e3a00004 mov r0, #4 <== NOT EXECUTED
}
30018f2c: e28dd010 add sp, sp, #16 <== NOT EXECUTED
30018f30: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
30018f34: e28d300c add r3, sp, #12 <== NOT EXECUTED 30018f38: e58d3000 str r3, [sp] <== NOT EXECUTED 30018f3c: e1a02006 mov r2, r6 <== NOT EXECUTED 30018f40: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30018f44: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30018f48: e1a01007 mov r1, r7 <== NOT EXECUTED 30018f4c: eb000e36 bl 3001c82c <_Heap_Resize_block> <== NOT EXECUTED
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
30018f50: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
30018f54: e2506000 subs r6, r0, #0 <== NOT EXECUTED
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
30018f58: e5853000 str r3, [r5] <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
30018f5c: 1a000003 bne 30018f70 <rtems_region_resize_segment+0x9c> <== NOT EXECUTED
_Region_Process_queue( the_region ); /* unlocks allocator */
30018f60: e1a00008 mov r0, r8 <== NOT EXECUTED 30018f64: eb0021fc bl 3002175c <_Region_Process_queue> <== NOT EXECUTED
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
30018f68: e1a00006 mov r0, r6 <== NOT EXECUTED 30018f6c: eaffffee b 30018f2c <rtems_region_resize_segment+0x58> <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
30018f70: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018f74: eb00086a bl 3001b124 <_API_Mutex_Unlock> <== NOT EXECUTED
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
return RTEMS_UNSATISFIED;
30018f78: e3560001 cmp r6, #1 <== NOT EXECUTED 30018f7c: 13a00009 movne r0, #9 <== NOT EXECUTED 30018f80: 03a0000d moveq r0, #13 <== NOT EXECUTED 30018f84: eaffffe8 b 30018f2c <rtems_region_resize_segment+0x58> <== NOT EXECUTED
30018f90 <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30018f90: e92d40f0 push {r4, r5, r6, r7, lr}
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30018f94: e59f4078 ldr r4, [pc, #120] ; 30019014 <rtems_region_return_segment+0x84>
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30018f98: e24dd004 sub sp, sp, #4 30018f9c: e1a06000 mov r6, r0
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30018fa0: e5940000 ldr r0, [r4]
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30018fa4: e1a05001 mov r5, r1
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30018fa8: eb000841 bl 3001b0b4 <_API_Mutex_Lock> 30018fac: e1a01006 mov r1, r6 30018fb0: e59f0060 ldr r0, [pc, #96] ; 30019018 <rtems_region_return_segment+0x88> 30018fb4: e1a0200d mov r2, sp 30018fb8: eb000fd3 bl 3001cf0c <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
30018fbc: e59d6000 ldr r6, [sp] 30018fc0: e1a07000 mov r7, r0 30018fc4: e3560000 cmp r6, #0
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30018fc8: 13a06004 movne r6, #4
register Region_Control *the_region;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
30018fcc: 1a000005 bne 30018fe8 <rtems_region_return_segment+0x58>
RTEMS_INLINE_ROUTINE bool _Region_Free_segment (
Region_Control *the_region,
void *the_segment
)
{
return _Heap_Free( &the_region->Memory, the_segment );
30018fd0: e2800068 add r0, r0, #104 ; 0x68 30018fd4: e1a01005 mov r1, r5 30018fd8: eb000c65 bl 3001c174 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
30018fdc: e3500000 cmp r0, #0
return_status = RTEMS_INVALID_ADDRESS;
30018fe0: 03a06009 moveq r6, #9
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
30018fe4: 1a000004 bne 30018ffc <rtems_region_return_segment+0x6c>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018fe8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018fec: eb00084c bl 3001b124 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30018ff0: e1a00006 mov r0, r6
30018ff4: e28dd004 add sp, sp, #4
30018ff8: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
30018ffc: e5973064 ldr r3, [r7, #100] ; 0x64
_Region_Process_queue(the_region); /* unlocks allocator */
30019000: e1a00007 mov r0, r7
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
30019004: e2433001 sub r3, r3, #1 30019008: e5873064 str r3, [r7, #100] ; 0x64
_Region_Process_queue(the_region); /* unlocks allocator */
3001900c: eb0021d2 bl 3002175c <_Region_Process_queue>
return RTEMS_SUCCESSFUL;
30019010: eafffff6 b 30018ff0 <rtems_region_return_segment+0x60>
300098ec <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
300098ec: e92d41f0 push {r4, r5, r6, r7, r8, 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 ) )
300098f0: e2505000 subs r5, r0, #0
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
300098f4: e24dd020 sub sp, sp, #32 300098f8: e1a04001 mov r4, r1 300098fc: 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;
30009900: 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 ) )
30009904: 0a000008 beq 3000992c <rtems_semaphore_create+0x40>
return RTEMS_INVALID_NAME;
if ( !id )
30009908: e3560000 cmp r6, #0
return RTEMS_INVALID_ADDRESS;
3000990c: 03a00009 moveq r0, #9
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30009910: 0a000005 beq 3000992c <rtems_semaphore_create+0x40>
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
30009914: e21210c0 ands r1, r2, #192 ; 0xc0
30009918: 0a000037 beq 300099fc <rtems_semaphore_create+0x110>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
3000991c: e2028030 and r8, r2, #48 ; 0x30
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
30009920: e3580010 cmp r8, #16
30009924: 0a000002 beq 30009934 <rtems_semaphore_create+0x48>
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
30009928: e3a0000b mov r0, #11 <== NOT EXECUTED
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000992c: e28dd020 add sp, sp, #32
30009930: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
30009934: e3120004 tst r2, #4
30009938: 0afffffa beq 30009928 <rtems_semaphore_create+0x3c>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
3000993c: e35100c0 cmp r1, #192 ; 0xc0
30009940: 0afffff8 beq 30009928 <rtems_semaphore_create+0x3c>
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
30009944: e3540001 cmp r4, #1
return RTEMS_INVALID_NUMBER;
30009948: 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 ) )
3000994c: 8afffff6 bhi 3000992c <rtems_semaphore_create+0x40>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009950: e59f1150 ldr r1, [pc, #336] ; 30009aa8 <rtems_semaphore_create+0x1bc> 30009954: e5910000 ldr r0, [r1] 30009958: e2800001 add r0, r0, #1 3000995c: e5810000 str r0, [r1]
* 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 );
30009960: e59f0144 ldr r0, [pc, #324] ; 30009aac <rtems_semaphore_create+0x1c0> 30009964: e58d2004 str r2, [sp, #4] 30009968: e58d3000 str r3, [sp] 3000996c: eb000557 bl 3000aed0 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
30009970: e2507000 subs r7, r0, #0 30009974: e59d2004 ldr r2, [sp, #4] 30009978: e59d3000 ldr r3, [sp]
3000997c: 0a00002f beq 30009a40 <rtems_semaphore_create+0x154>
the_semaphore->attribute_set = attribute_set;
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
30009980: e3580000 cmp r8, #0
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
30009984: e5872010 str r2, [r7, #16]
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
30009988: 0a00001e beq 30009a08 <rtems_semaphore_create+0x11c>
} 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 ) )
3000998c: e2121004 ands r1, r2, #4
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
30009990: 13a01001 movne r1, #1 30009994: 158d1010 strne r1, [sp, #16]
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
30009998: 058d1010 streq r1, [sp, #16]
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
3000999c: e3580010 cmp r8, #16
300099a0: 0a000029 beq 30009a4c <rtems_semaphore_create+0x160>
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;
300099a4: e3a03002 mov r3, #2 300099a8: e58d3008 str r3, [sp, #8]
the_mutex_attr.only_owner_release = false;
300099ac: e3a03000 mov r3, #0 300099b0: e5cd300c strb r3, [sp, #12]
}
mutex_status = _CORE_mutex_Initialize(
300099b4: e3540001 cmp r4, #1 300099b8: 13a02000 movne r2, #0 300099bc: 03a02001 moveq r2, #1 300099c0: e2870014 add r0, r7, #20 300099c4: e28d1008 add r1, sp, #8 300099c8: eb0002f5 bl 3000a5a4 <_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 ) {
300099cc: e3500006 cmp r0, #6
300099d0: 0a00002e beq 30009a90 <rtems_semaphore_create+0x1a4>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300099d4: e59f20d0 ldr r2, [pc, #208] ; 30009aac <rtems_semaphore_create+0x1c0>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
300099d8: e5973008 ldr r3, [r7, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300099dc: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300099e0: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300099e4: e7827721 str r7, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300099e8: e587500c str r5, [r7, #12]
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
300099ec: e5863000 str r3, [r6]
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
300099f0: eb0009c2 bl 3000c100 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300099f4: e3a00000 mov r0, #0 300099f8: eaffffcb b 3000992c <rtems_semaphore_create+0x40>
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 ) )
300099fc: e2128030 ands r8, r2, #48 ; 0x30
30009a00: 1affffcf bne 30009944 <rtems_semaphore_create+0x58>
30009a04: eaffffd1 b 30009950 <rtems_semaphore_create+0x64>
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
if ( _Attributes_Is_priority( attribute_set ) )
30009a08: e3120004 tst r2, #4
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
30009a0c: e3e03000 mvn r3, #0 30009a10: e58d3018 str r3, [sp, #24]
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
30009a14: 13a03001 movne r3, #1 30009a18: 158d301c strne r3, [sp, #28]
* 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(
30009a1c: e2870014 add r0, r7, #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;
30009a20: e3a03000 mov r3, #0
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
_CORE_semaphore_Initialize(
30009a24: e28d1018 add r1, sp, #24 30009a28: 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;
30009a2c: 058d801c streq r8, [sp, #28]
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
30009a30: e58d3008 str r3, [sp, #8]
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
30009a34: e58d3014 str r3, [sp, #20]
_CORE_semaphore_Initialize(
30009a38: eb0003a3 bl 3000a8cc <_CORE_semaphore_Initialize> 30009a3c: eaffffe4 b 300099d4 <rtems_semaphore_create+0xe8>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
30009a40: eb0009ae bl 3000c100 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
30009a44: e3a00005 mov r0, #5 30009a48: eaffffb7 b 3000992c <rtems_semaphore_create+0x40>
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
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 ) {
30009a4c: e59d0010 ldr r0, [sp, #16]
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
30009a50: e3a01000 mov r1, #0
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
30009a54: e3500001 cmp r0, #1
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;
30009a58: e58d3014 str r3, [sp, #20]
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
30009a5c: e58d1008 str r1, [sp, #8]
the_mutex_attr.only_owner_release = false;
30009a60: e5cd100c strb r1, [sp, #12]
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
30009a64: 1affffd2 bne 300099b4 <rtems_semaphore_create+0xc8>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
30009a68: e3120040 tst r2, #64 ; 0x40
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
30009a6c: 13a03002 movne r3, #2 30009a70: 158d3010 strne r3, [sp, #16]
the_mutex_attr.only_owner_release = true;
30009a74: 15cd000c strbne r0, [sp, #12]
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 ) ) {
30009a78: 1affffcd bne 300099b4 <rtems_semaphore_create+0xc8>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
30009a7c: e3120080 tst r2, #128 ; 0x80
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
30009a80: 13a03003 movne r3, #3 30009a84: 158d3010 strne r3, [sp, #16]
the_mutex_attr.only_owner_release = true;
30009a88: 15cd000c strbne r0, [sp, #12] 30009a8c: eaffffc8 b 300099b4 <rtems_semaphore_create+0xc8>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
30009a90: e59f0014 ldr r0, [pc, #20] ; 30009aac <rtems_semaphore_create+0x1c0> 30009a94: e1a01007 mov r1, r7 30009a98: eb0005e6 bl 3000b238 <_Objects_Free>
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
30009a9c: eb000997 bl 3000c100 <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
30009aa0: e3a00013 mov r0, #19 30009aa4: eaffffa0 b 3000992c <rtems_semaphore_create+0x40>
30009ab0 <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
30009ab0: e92d4010 push {r4, lr}
30009ab4: e24dd004 sub sp, sp, #4
30009ab8: e1a01000 mov r1, r0
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
30009abc: e1a0200d mov r2, sp 30009ac0: e59f0088 ldr r0, [pc, #136] ; 30009b50 <rtems_semaphore_delete+0xa0> 30009ac4: eb000632 bl 3000b394 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30009ac8: e59d3000 ldr r3, [sp] 30009acc: e1a04000 mov r4, r0 30009ad0: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009ad4: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30009ad8: 1a000009 bne 30009b04 <rtems_semaphore_delete+0x54>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
30009adc: e5941010 ldr r1, [r4, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
30009ae0: e2111030 ands r1, r1, #48 ; 0x30
30009ae4: 0a000015 beq 30009b40 <rtems_semaphore_delete+0x90>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
30009ae8: e5943064 ldr r3, [r4, #100] ; 0x64 30009aec: e3530000 cmp r3, #0
30009af0: 1a000005 bne 30009b0c <rtems_semaphore_delete+0x5c>
30009af4: e3510020 cmp r1, #32
30009af8: 0a000003 beq 30009b0c <rtems_semaphore_delete+0x5c>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
30009afc: eb00097f bl 3000c100 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
30009b00: e3a0000c mov r0, #12 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30009b04: e28dd004 add sp, sp, #4
30009b08: e8bd8010 pop {r4, pc}
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
_CORE_mutex_Flush(
30009b0c: e2840014 add r0, r4, #20 30009b10: e3a01000 mov r1, #0 30009b14: e3a02004 mov r2, #4 30009b18: eb0002a0 bl 3000a5a0 <_CORE_mutex_Flush>
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
30009b1c: e1a01004 mov r1, r4 30009b20: e59f0028 ldr r0, [pc, #40] ; 30009b50 <rtems_semaphore_delete+0xa0> 30009b24: eb00050e bl 3000af64 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
30009b28: e59f0020 ldr r0, [pc, #32] ; 30009b50 <rtems_semaphore_delete+0xa0> 30009b2c: e1a01004 mov r1, r4 30009b30: eb0005c0 bl 3000b238 <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
30009b34: eb000971 bl 3000c100 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30009b38: e3a00000 mov r0, #0 30009b3c: eafffff0 b 30009b04 <rtems_semaphore_delete+0x54>
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
30009b40: e2840014 add r0, r4, #20 30009b44: e3a02002 mov r2, #2 30009b48: eb00035e bl 3000a8c8 <_CORE_semaphore_Flush> 30009b4c: eafffff2 b 30009b1c <rtems_semaphore_delete+0x6c>
30013adc <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
30013adc: e52de004 push {lr} ; (str lr, [sp, #-4]!)
30013ae0: e24dd004 sub sp, sp, #4
30013ae4: e1a01000 mov r1, r0
30013ae8: e1a0200d mov r2, sp
30013aec: e59f004c ldr r0, [pc, #76] ; 30013b40 <rtems_semaphore_flush+0x64>
30013af0: ebffe3cf bl 3000ca34 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30013af4: e59d3000 ldr r3, [sp] 30013af8: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30013afc: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30013b00: 1a000007 bne 30013b24 <rtems_semaphore_flush+0x48>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
30013b04: e5901010 ldr r1, [r0, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
30013b08: e2111030 ands r1, r1, #48 ; 0x30
30013b0c: 1a000006 bne 30013b2c <rtems_semaphore_flush+0x50>
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
30013b10: e2800014 add r0, r0, #20 <== NOT EXECUTED 30013b14: e3a02001 mov r2, #1 <== NOT EXECUTED 30013b18: ebffe112 bl 3000bf68 <_CORE_semaphore_Flush> <== NOT EXECUTED
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
30013b1c: ebffe725 bl 3000d7b8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30013b20: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30013b24: e28dd004 add sp, sp, #4
30013b28: e8bd8000 pop {pc}
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
_CORE_mutex_Flush(
30013b2c: e2800014 add r0, r0, #20 30013b30: e1a01003 mov r1, r3 30013b34: e3a02001 mov r2, #1 30013b38: ebffe040 bl 3000bc40 <_CORE_mutex_Flush> 30013b3c: eafffff6 b 30013b1c <rtems_semaphore_flush+0x40>
30009b54 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
30009b54: e92d40f0 push {r4, r5, r6, r7, lr}
30009b58: e1a04000 mov r4, r0
30009b5c: e24dd00c sub sp, sp, #12
Objects_Locations *location,
ISR_Level *level
)
{
return (Semaphore_Control *)
_Objects_Get_isr_disable( &_Semaphore_Information, id, location, level );
30009b60: e28d3004 add r3, sp, #4 30009b64: e1a05001 mov r5, r1 30009b68: e1a06002 mov r6, r2 30009b6c: e59f00f4 ldr r0, [pc, #244] ; 30009c68 <rtems_semaphore_obtain+0x114> 30009b70: e1a01004 mov r1, r4 30009b74: e28d2008 add r2, sp, #8 30009b78: eb0005e9 bl 3000b324 <_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 ) {
30009b7c: e59d3008 ldr r3, [sp, #8] 30009b80: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009b84: 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 ) {
30009b88: 1a00000e bne 30009bc8 <rtems_semaphore_obtain+0x74>
30009b8c: e5903010 ldr r3, [r0, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
30009b90: e2133030 ands r3, r3, #48 ; 0x30
30009b94: 0a00000d beq 30009bd0 <rtems_semaphore_obtain+0x7c>
_CORE_mutex_Seize(
30009b98: 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;
30009b9c: e2052001 and r2, r5, #1 30009ba0: e58d3000 str r3, [sp] 30009ba4: e2800014 add r0, r0, #20 30009ba8: e1a03006 mov r3, r6 30009bac: e2222001 eor r2, r2, #1 30009bb0: e1a01004 mov r1, r4 30009bb4: eb0002c3 bl 3000a6c8 <_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 );
30009bb8: e59f30ac ldr r3, [pc, #172] ; 30009c6c <rtems_semaphore_obtain+0x118> 30009bbc: e5933004 ldr r3, [r3, #4]
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
30009bc0: e5930034 ldr r0, [r3, #52] ; 0x34 30009bc4: eb00004c bl 30009cfc <_Semaphore_Translate_core_mutex_return_code>
break;
}
return RTEMS_INVALID_ID;
}
30009bc8: e28dd00c add sp, sp, #12
30009bcc: e8bd80f0 pop {r4, r5, r6, r7, pc}
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
30009bd0: e59f7094 ldr r7, [pc, #148] ; 30009c6c <rtems_semaphore_obtain+0x118>
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
30009bd4: e590105c ldr r1, [r0, #92] ; 0x5c
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
30009bd8: e5972004 ldr r2, [r7, #4]
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
30009bdc: e3510000 cmp r1, #0
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
30009be0: e5823034 str r3, [r2, #52] ; 0x34
if ( the_semaphore->count != 0 ) {
30009be4: 1a000009 bne 30009c10 <rtems_semaphore_obtain+0xbc>
the_semaphore->count -= 1;
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
30009be8: e3150001 tst r5, #1
30009bec: 0a00000c beq 30009c24 <rtems_semaphore_obtain+0xd0>
30009bf0: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30009bf4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( *level_p );
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
30009bf8: e3a03001 mov r3, #1 <== NOT EXECUTED 30009bfc: e5823034 str r3, [r2, #52] ; 0x34 <== NOT EXECUTED
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
_Thread_Executing->Wait.return_code );
30009c00: e5973004 ldr r3, [r7, #4]
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
30009c04: e5930034 ldr r0, [r3, #52] ; 0x34 30009c08: eb00003f bl 30009d0c <_Semaphore_Translate_core_semaphore_return_code> 30009c0c: eaffffed b 30009bc8 <rtems_semaphore_obtain+0x74>
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
the_semaphore->count -= 1;
30009c10: e2411001 sub r1, r1, #1 30009c14: e580105c str r1, [r0, #92] ; 0x5c 30009c18: e59d3004 ldr r3, [sp, #4] 30009c1c: e129f003 msr CPSR_fc, r3 30009c20: eafffff6 b 30009c00 <rtems_semaphore_obtain+0xac> 30009c24: e59f3044 ldr r3, [pc, #68] ; 30009c70 <rtems_semaphore_obtain+0x11c> 30009c28: e5931000 ldr r1, [r3] 30009c2c: e2811001 add r1, r1, #1 30009c30: e5831000 str r1, [r3]
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;
30009c34: e3a01001 mov r1, #1
return;
}
_Thread_Disable_dispatch();
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
30009c38: e2803014 add r3, r0, #20 30009c3c: e5801044 str r1, [r0, #68] ; 0x44 30009c40: e5823044 str r3, [r2, #68] ; 0x44
executing->Wait.id = id;
30009c44: e5824020 str r4, [r2, #32] 30009c48: e59d2004 ldr r2, [sp, #4] 30009c4c: e129f002 msr CPSR_fc, r2
_ISR_Enable( *level_p );
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
30009c50: e59f201c ldr r2, [pc, #28] ; 30009c74 <rtems_semaphore_obtain+0x120> 30009c54: e1a00003 mov r0, r3 30009c58: e1a01006 mov r1, r6 30009c5c: eb000a53 bl 3000c5b0 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
30009c60: eb000926 bl 3000c100 <_Thread_Enable_dispatch> 30009c64: eaffffe5 b 30009c00 <rtems_semaphore_obtain+0xac>
300194ec <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
300194ec: e92d4010 push {r4, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
300194f0: e2514000 subs r4, r1, #0
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
300194f4: e24dd004 sub sp, sp, #4
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
300194f8: 03a0000a moveq r0, #10
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
300194fc: 1a000001 bne 30019508 <rtems_signal_send+0x1c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30019500: e28dd004 add sp, sp, #4
30019504: e8bd8010 pop {r4, pc}
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
30019508: e1a0100d mov r1, sp 3001950c: eb0011f2 bl 3001dcdc <_Thread_Get>
switch ( location ) {
30019510: e59d3000 ldr r3, [sp] 30019514: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30019518: 13a00004 movne r0, #4
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3001951c: 1afffff7 bne 30019500 <rtems_signal_send+0x14>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
30019520: e59030f8 ldr r3, [r0, #248] ; 0xf8
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
30019524: e593200c ldr r2, [r3, #12] 30019528: e3520000 cmp r2, #0
3001952c: 0a00001c beq 300195a4 <rtems_signal_send+0xb8>
if ( asr->is_enabled ) {
30019530: e5d32008 ldrb r2, [r3, #8] 30019534: e3520000 cmp r2, #0
30019538: 0a00000f beq 3001957c <rtems_signal_send+0x90>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001953c: e10f2000 mrs r2, CPSR 30019540: e3821080 orr r1, r2, #128 ; 0x80 30019544: e129f001 msr CPSR_fc, r1
)
{
ISR_Level _level;
_ISR_Disable( _level );
*signal_set |= signals;
30019548: e5931014 ldr r1, [r3, #20] 3001954c: e1814004 orr r4, r1, r4 30019550: e5834014 str r4, [r3, #20]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30019554: e129f002 msr CPSR_fc, r2
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
30019558: e59f3050 ldr r3, [pc, #80] ; 300195b0 <rtems_signal_send+0xc4> 3001955c: e5932000 ldr r2, [r3] 30019560: e3520000 cmp r2, #0
30019564: 0a00000b beq 30019598 <rtems_signal_send+0xac>
30019568: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3001956c: e1500002 cmp r0, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
30019570: 03a02001 moveq r2, #1 <== NOT EXECUTED 30019574: 05c32010 strbeq r2, [r3, #16] <== NOT EXECUTED 30019578: ea000006 b 30019598 <rtems_signal_send+0xac> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001957c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 30019580: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30019584: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 30019588: e5931018 ldr r1, [r3, #24] <== NOT EXECUTED 3001958c: e1814004 orr r4, r1, r4 <== NOT EXECUTED 30019590: e5834018 str r4, [r3, #24] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30019594: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
30019598: eb0011c6 bl 3001dcb8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3001959c: e3a00000 mov r0, #0 300195a0: eaffffd6 b 30019500 <rtems_signal_send+0x14>
}
_Thread_Enable_dispatch();
300195a4: eb0011c3 bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
300195a8: e3a0000b mov r0, #11 <== NOT EXECUTED 300195ac: eaffffd3 b 30019500 <rtems_signal_send+0x14> <== NOT EXECUTED
3000670c <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
3000670c: e92d4830 push {r4, r5, fp, lr}
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
30006710: e59f4074 ldr r4, [pc, #116] ; 3000678c <rtems_stack_checker_is_blown+0x80>
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
30006714: e28db00c add fp, sp, #12
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
30006718: e5943004 ldr r3, [r4, #4]
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
3000671c: e59300bc ldr r0, [r3, #188] ; 0xbc 30006720: e15b0000 cmp fp, r0
return false;
30006724: 33a05000 movcc r5, #0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30006728: 3a000004 bcc 30006740 <rtems_stack_checker_is_blown+0x34>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
3000672c: e59350b8 ldr r5, [r3, #184] ; 0xb8 30006730: e0805005 add r5, r0, r5
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
30006734: e15b0005 cmp fp, r5 30006738: 83a05000 movhi r5, #0 3000673c: 93a05001 movls r5, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
30006740: e59f3048 ldr r3, [pc, #72] ; 30006790 <rtems_stack_checker_is_blown+0x84> 30006744: e5933008 ldr r3, [r3, #8] 30006748: 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;
3000674c: 03a01001 moveq r1, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
30006750: 0a000005 beq 3000676c <rtems_stack_checker_is_blown+0x60>
pattern_ok = (!memcmp(
30006754: e59f1038 ldr r1, [pc, #56] ; 30006794 <rtems_stack_checker_is_blown+0x88> 30006758: e2800008 add r0, r0, #8 3000675c: e3a02010 mov r2, #16 30006760: eb003b93 bl 300155b4 <memcmp> 30006764: e2701001 rsbs r1, r0, #1 30006768: 33a01000 movcc r1, #0
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
3000676c: e3550000 cmp r5, #0
30006770: 0a000003 beq 30006784 <rtems_stack_checker_is_blown+0x78>
30006774: e3510000 cmp r1, #0
30006778: 0a000001 beq 30006784 <rtems_stack_checker_is_blown+0x78>
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
3000677c: e3a00000 mov r0, #0
30006780: e8bd8830 pop {r4, r5, fp, pc}
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
30006784: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30006788: ebffff98 bl 300065f0 <Stack_check_report_blown_task> <== NOT EXECUTED
300067f8 <rtems_stack_checker_report_usage>:
}
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
300067f8: e59f1004 ldr r1, [pc, #4] ; 30006804 <rtems_stack_checker_report_usage+0xc><== NOT EXECUTED 300067fc: e3a00000 mov r0, #0 <== NOT EXECUTED 30006800: eaffffe4 b 30006798 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
30006798 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30006798: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if ( !print )
3000679c: e2515000 subs r5, r1, #0 <== NOT EXECUTED
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
300067a0: e1a06000 mov r6, r0 <== NOT EXECUTED
if ( !print )
300067a4: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return;
print_context = context;
300067a8: e59f4038 ldr r4, [pc, #56] ; 300067e8 <rtems_stack_checker_report_usage_with_plugin+0x50><== NOT EXECUTED
print_handler = print;
(*print)( context, "Stack usage by thread\n");
300067ac: e59f1038 ldr r1, [pc, #56] ; 300067ec <rtems_stack_checker_report_usage_with_plugin+0x54><== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
300067b0: e5840004 str r0, [r4, #4] <== NOT EXECUTED
print_handler = print;
300067b4: e5845000 str r5, [r4] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
300067b8: e1a0e00f mov lr, pc <== NOT EXECUTED 300067bc: e12fff15 bx r5 <== NOT EXECUTED
(*print)( context,
300067c0: e59f1028 ldr r1, [pc, #40] ; 300067f0 <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED 300067c4: e1a00006 mov r0, r6 <== NOT EXECUTED 300067c8: e1a0e00f mov lr, pc <== NOT EXECUTED 300067cc: 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 );
300067d0: e59f001c ldr r0, [pc, #28] ; 300067f4 <rtems_stack_checker_report_usage_with_plugin+0x5c><== NOT EXECUTED 300067d4: eb001cd1 bl 3000db20 <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;
300067d8: e3a03000 mov r3, #0 <== NOT EXECUTED 300067dc: e5843004 str r3, [r4, #4] <== NOT EXECUTED
print_handler = NULL;
300067e0: e5843000 str r3, [r4] <== NOT EXECUTED
300067e4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300066a4 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
300066a4: e92d4810 push {r4, 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);
300066a8: e59030bc ldr r3, [r0, #188] ; 0xbc <== NOT EXECUTED
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
300066ac: e28db008 add fp, sp, #8 <== NOT EXECUTED
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
300066b0: e15b0003 cmp fp, r3 <== NOT EXECUTED
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
300066b4: e1a04000 mov r4, r0 <== 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);
300066b8: e2830008 add r0, r3, #8 <== NOT EXECUTED
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
300066bc: 3a000003 bcc 300066d0 <rtems_stack_checker_switch_extension+0x2c><== NOT EXECUTED
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
300066c0: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 300066c4: e0833002 add r3, r3, r2 <== NOT EXECUTED 300066c8: e15b0003 cmp fp, r3 <== NOT EXECUTED 300066cc: 9a000006 bls 300066ec <rtems_stack_checker_switch_extension+0x48><== 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,
300066d0: e59f1030 ldr r1, [pc, #48] ; 30006708 <rtems_stack_checker_switch_extension+0x64><== NOT EXECUTED 300066d4: e3a02010 mov r2, #16 <== NOT EXECUTED 300066d8: eb003bb5 bl 300155b4 <memcmp> <== NOT EXECUTED 300066dc: e2701001 rsbs r1, r0, #1 <== NOT EXECUTED 300066e0: 33a01000 movcc r1, #0 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
300066e4: e1a00004 mov r0, r4 <== NOT EXECUTED 300066e8: ebffffc0 bl 300065f0 <Stack_check_report_blown_task> <== 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,
300066ec: e59f1014 ldr r1, [pc, #20] ; 30006708 <rtems_stack_checker_switch_extension+0x64><== NOT EXECUTED 300066f0: e3a02010 mov r2, #16 <== NOT EXECUTED 300066f4: eb003bae bl 300155b4 <memcmp> <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
300066f8: e3500000 cmp r0, #0 <== NOT EXECUTED
300066fc: 08bd8810 popeq {r4, fp, pc} <== NOT EXECUTED
30006700: e3a01000 mov r1, #0 <== NOT EXECUTED
30006704: eafffff6 b 300066e4 <rtems_stack_checker_switch_extension+0x40><== NOT EXECUTED
3000af34 <rtems_status_text>:
const char *rtems_status_text(
rtems_status_code status
)
{
3000af34: e1a01000 mov r1, r0 <== NOT EXECUTED
return rtems_assoc_name_by_local(rtems_status_assoc, status);
3000af38: e59f0000 ldr r0, [pc, #0] ; 3000af40 <rtems_status_text+0xc><== NOT EXECUTED 3000af3c: ea002324 b 30013bd4 <rtems_assoc_name_by_local> <== NOT EXECUTED
30010638 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
30010638: e92d41f0 push {r4, r5, r6, r7, r8, lr}
double result;
char *end;
if ( !n )
3001063c: e2514000 subs r4, r1, #0
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
30010640: e1a07000 mov r7, r0 30010644: e24dd004 sub sp, sp, #4 30010648: e1a08002 mov r8, r2
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3001064c: 03a00009 moveq r0, #9
)
{
double result;
char *end;
if ( !n )
30010650: 0a000017 beq 300106b4 <rtems_string_to_double+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
30010654: eb000c70 bl 3001381c <__errno> 30010658: e3a03000 mov r3, #0 3001065c: e5803000 str r3, [r0]
*n = 0;
30010660: e3a02000 mov r2, #0
30010664: e3a03000 mov r3, #0
30010668: e884000c stm r4, {r2, r3}
result = strtod( s, &end );
3001066c: e1a00007 mov r0, r7 30010670: e1a0100d mov r1, sp 30010674: eb0017df bl 300165f8 <strtod>
if ( endptr )
30010678: e3580000 cmp r8, #0
*endptr = end;
3001067c: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtod( s, &end );
if ( endptr )
30010680: 059d3000 ldreq r3, [sp]
*endptr = end;
30010684: 15883000 strne r3, [r8]
if ( end == s )
30010688: e1570003 cmp r7, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
3001068c: e1a05000 mov r5, r0 30010690: e1a06001 mov r6, r1
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
30010694: 03a0000b moveq r0, #11
result = strtod( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
30010698: 0a000005 beq 300106b4 <rtems_string_to_double+0x7c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3001069c: eb000c5e bl 3001381c <__errno> 300106a0: e5903000 ldr r3, [r0] 300106a4: e3530022 cmp r3, #34 ; 0x22
300106a8: 0a000003 beq 300106bc <rtems_string_to_double+0x84>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
300106ac: e8840060 stm r4, {r5, r6}
return RTEMS_SUCCESSFUL;
300106b0: e3a00000 mov r0, #0
}
300106b4: e28dd004 add sp, sp, #4
300106b8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
300106bc: e1a00005 mov r0, r5 300106c0: e1a01006 mov r1, r6 300106c4: e3a02000 mov r2, #0 300106c8: e3a03000 mov r3, #0 300106cc: ebffdbff bl 300076d0 <__cmpdf2> 300106d0: e3500000 cmp r0, #0
300106d4: 0a00000d beq 30010710 <rtems_string_to_double+0xd8>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
300106d8: e1a00005 mov r0, r5 300106dc: e1a01006 mov r1, r6 300106e0: e3e02000 mvn r2, #0 300106e4: e59f302c ldr r3, [pc, #44] ; 30010718 <rtems_string_to_double+0xe0> 300106e8: ebffdbf4 bl 300076c0 <__gedf2> 300106ec: e3500000 cmp r0, #0
300106f0: ca000006 bgt 30010710 <rtems_string_to_double+0xd8>
300106f4: e1a00005 mov r0, r5 <== NOT EXECUTED 300106f8: e1a01006 mov r1, r6 <== NOT EXECUTED 300106fc: e3e02000 mvn r2, #0 <== NOT EXECUTED 30010700: e3e03601 mvn r3, #1048576 ; 0x100000 <== NOT EXECUTED 30010704: ebffdbef bl 300076c8 <__ledf2> <== NOT EXECUTED 30010708: e3500000 cmp r0, #0 <== NOT EXECUTED 3001070c: aaffffe6 bge 300106ac <rtems_string_to_double+0x74> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
30010710: e3a0000a mov r0, #10 30010714: eaffffe6 b 300106b4 <rtems_string_to_double+0x7c>
3001071c <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
3001071c: e92d40f0 push {r4, r5, r6, r7, lr}
float result;
char *end;
if ( !n )
30010720: e2515000 subs r5, r1, #0
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
30010724: e1a04000 mov r4, r0 30010728: e24dd004 sub sp, sp, #4 3001072c: e1a06002 mov r6, r2
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
30010730: 03a00009 moveq r0, #9
)
{
float result;
char *end;
if ( !n )
30010734: 0a000015 beq 30010790 <rtems_string_to_float+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
30010738: eb000c37 bl 3001381c <__errno> 3001073c: e3a03000 mov r3, #0 30010740: e5803000 str r3, [r0]
*n = 0;
30010744: e3a03000 mov r3, #0 30010748: e5853000 str r3, [r5]
result = strtof( s, &end );
3001074c: e1a00004 mov r0, r4 30010750: e1a0100d mov r1, sp 30010754: eb0017ae bl 30016614 <strtof>
if ( endptr )
30010758: e3560000 cmp r6, #0
*endptr = end;
3001075c: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtof( s, &end );
if ( endptr )
30010760: 059d3000 ldreq r3, [sp]
*endptr = end;
30010764: 15863000 strne r3, [r6]
if ( end == s )
30010768: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
3001076c: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
30010770: 03a0000b moveq r0, #11
result = strtof( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
30010774: 0a000005 beq 30010790 <rtems_string_to_float+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010778: eb000c27 bl 3001381c <__errno> 3001077c: e5903000 ldr r3, [r0] 30010780: e3530022 cmp r3, #34 ; 0x22
30010784: 0a000003 beq 30010798 <rtems_string_to_float+0x7c>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
30010788: e5857000 str r7, [r5]
return RTEMS_SUCCESSFUL;
3001078c: e3a00000 mov r0, #0
}
30010790: e28dd004 add sp, sp, #4
30010794: e8bd80f0 pop {r4, r5, r6, r7, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010798: e1a00007 mov r0, r7 3001079c: e3a01000 mov r1, #0 300107a0: ebffdc15 bl 300077fc <__cmpsf2> 300107a4: e3500000 cmp r0, #0
300107a8: 0a000009 beq 300107d4 <rtems_string_to_float+0xb8>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
300107ac: e1a00007 mov r0, r7 300107b0: e59f1024 ldr r1, [pc, #36] ; 300107dc <rtems_string_to_float+0xc0> 300107b4: ebffdc0c bl 300077ec <__gesf2> 300107b8: e3500000 cmp r0, #0
300107bc: ca000004 bgt 300107d4 <rtems_string_to_float+0xb8>
300107c0: e1a00007 mov r0, r7 <== NOT EXECUTED 300107c4: e3e01502 mvn r1, #8388608 ; 0x800000 <== NOT EXECUTED 300107c8: ebffdc09 bl 300077f4 <__lesf2> <== NOT EXECUTED 300107cc: e3500000 cmp r0, #0 <== NOT EXECUTED 300107d0: aaffffec bge 30010788 <rtems_string_to_float+0x6c> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
300107d4: e3a0000a mov r0, #10 300107d8: eaffffec b 30010790 <rtems_string_to_float+0x74>
300107e0 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
300107e0: e92d40f0 push {r4, r5, r6, r7, lr}
long result;
char *end;
if ( !n )
300107e4: e2516000 subs r6, r1, #0
const char *s,
int *n,
char **endptr,
int base
)
{
300107e8: e1a04000 mov r4, r0 300107ec: e24dd004 sub sp, sp, #4 300107f0: e1a05002 mov r5, r2 300107f4: e1a07003 mov r7, r3
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
300107f8: 03a00009 moveq r0, #9
)
{
long result;
char *end;
if ( !n )
300107fc: 0a000015 beq 30010858 <rtems_string_to_int+0x78>
return RTEMS_INVALID_ADDRESS;
errno = 0;
30010800: eb000c05 bl 3001381c <__errno> 30010804: e3a03000 mov r3, #0 30010808: e5803000 str r3, [r0]
*n = 0;
result = strtol( s, &end, base );
3001080c: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
30010810: e5863000 str r3, [r6]
result = strtol( s, &end, base );
30010814: e1a00004 mov r0, r4 30010818: e1a0100d mov r1, sp 3001081c: eb0017fe bl 3001681c <strtol>
if ( endptr )
30010820: e3550000 cmp r5, #0
*endptr = end;
30010824: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
30010828: 059d3000 ldreq r3, [sp]
*endptr = end;
3001082c: 15853000 strne r3, [r5]
if ( end == s )
30010830: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
30010834: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
30010838: 03a0000b moveq r0, #11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
3001083c: 0a000005 beq 30010858 <rtems_string_to_int+0x78>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010840: eb000bf5 bl 3001381c <__errno> 30010844: e5903000 ldr r3, [r0] 30010848: e3530022 cmp r3, #34 ; 0x22
3001084c: 0a000003 beq 30010860 <rtems_string_to_int+0x80>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
30010850: e5867000 str r7, [r6]
return RTEMS_SUCCESSFUL;
30010854: e3a00000 mov r0, #0
}
30010858: e28dd004 add sp, sp, #4
3001085c: e8bd80f0 pop {r4, r5, r6, r7, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010860: e3770106 cmn r7, #-2147483647 ; 0x80000001 30010864: 13570000 cmpne r7, #0
30010868: 0a000001 beq 30010874 <rtems_string_to_int+0x94>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
3001086c: e3570102 cmp r7, #-2147483648 ; 0x80000000 <== NOT EXECUTED 30010870: 1afffff6 bne 30010850 <rtems_string_to_int+0x70> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
30010874: e3a0000a mov r0, #10 30010878: eafffff6 b 30010858 <rtems_string_to_int+0x78>
300109f0 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
300109f0: e92d40f0 push {r4, r5, r6, r7, lr}
unsigned long result;
char *end;
if ( !n )
300109f4: e2516000 subs r6, r1, #0
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
300109f8: e1a04000 mov r4, r0 300109fc: e24dd004 sub sp, sp, #4 30010a00: e1a05002 mov r5, r2 30010a04: e1a07003 mov r7, r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
30010a08: 03a00009 moveq r0, #9
)
{
unsigned long result;
char *end;
if ( !n )
30010a0c: 0a000017 beq 30010a70 <rtems_string_to_unsigned_char+0x80>
return RTEMS_INVALID_ADDRESS;
errno = 0;
30010a10: eb000b81 bl 3001381c <__errno> 30010a14: e3a03000 mov r3, #0 30010a18: e5803000 str r3, [r0]
*n = 0;
result = strtoul( s, &end, base );
30010a1c: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
30010a20: e5c63000 strb r3, [r6]
result = strtoul( s, &end, base );
30010a24: e1a00004 mov r0, r4 30010a28: e1a0100d mov r1, sp 30010a2c: eb0018a9 bl 30016cd8 <strtoul>
if ( endptr )
30010a30: e3550000 cmp r5, #0
*endptr = end;
30010a34: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
30010a38: 059d3000 ldreq r3, [sp]
*endptr = end;
30010a3c: 15853000 strne r3, [r5]
if ( end == s )
30010a40: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
30010a44: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
30010a48: 03a0000b moveq r0, #11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
30010a4c: 0a000007 beq 30010a70 <rtems_string_to_unsigned_char+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010a50: eb000b71 bl 3001381c <__errno> 30010a54: e5903000 ldr r3, [r0] 30010a58: e3530022 cmp r3, #34 ; 0x22
30010a5c: 0a000005 beq 30010a78 <rtems_string_to_unsigned_char+0x88>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
30010a60: e35700ff cmp r7, #255 ; 0xff
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
30010a64: 95c67000 strbls r7, [r6]
return RTEMS_SUCCESSFUL;
30010a68: 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 ) {
30010a6c: 8a000009 bhi 30010a98 <rtems_string_to_unsigned_char+0xa8>
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
30010a70: e28dd004 add sp, sp, #4
30010a74: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
30010a78: e2473001 sub r3, r7, #1 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010a7c: e3730003 cmn r3, #3 <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
30010a80: 83a0000a movhi r0, #10 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010a84: 8afffff9 bhi 30010a70 <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
30010a88: e35700ff cmp r7, #255 ; 0xff <== NOT EXECUTED
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
30010a8c: 95c67000 strbls r7, [r6] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30010a90: 93a00000 movls r0, #0 <== NOT EXECUTED
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
30010a94: 9afffff5 bls 30010a70 <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
errno = ERANGE;
30010a98: eb000b5f bl 3001381c <__errno> <== NOT EXECUTED 30010a9c: e3a03022 mov r3, #34 ; 0x22 <== NOT EXECUTED 30010aa0: e5803000 str r3, [r0] <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
30010aa4: e3a0000a mov r0, #10 <== NOT EXECUTED 30010aa8: eafffff0 b 30010a70 <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
30006240 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
30006240: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30006244: e24ddf6a sub sp, sp, #424 ; 0x1a8
30006248: e1a06001 mov r6, r1
3000624c: e1a07002 mov r7, r2
30006250: e58d0014 str r0, [sp, #20]
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
30006254: eb00442a bl 30017304 <strlen> 30006258: e28d2e19 add r2, sp, #400 ; 0x190 3000625c: e1a01000 mov r1, r0 30006260: e58d2008 str r2, [sp, #8] 30006264: e59d0014 ldr r0, [sp, #20] 30006268: e3a02000 mov r2, #0 3000626c: e28d3e19 add r3, sp, #400 ; 0x190 30006270: e58d2000 str r2, [sp] 30006274: eb0002bd bl 30006d70 <rtems_filesystem_evaluate_path>
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
30006278: e3500000 cmp r0, #0
return -1;
3000627c: 13e02000 mvnne r2, #0
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
30006280: e58d0010 str r0, [sp, #16]
return -1;
30006284: 158d2010 strne r2, [sp, #16]
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
30006288: 1a000032 bne 30006358 <rtems_tarfs_load+0x118>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
3000628c: e59d319c ldr r3, [sp, #412] ; 0x19c 30006290: e59f21d0 ldr r2, [pc, #464] ; 30006468 <rtems_tarfs_load+0x228> 30006294: e1530002 cmp r3, r2 30006298: 059da010 ldreq sl, [sp, #16]
3000629c: 1a00006a bne 3000644c <rtems_tarfs_load+0x20c>
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
300062a0: e28a4c02 add r4, sl, #512 ; 0x200
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
300062a4: e28d3f5f add r3, sp, #380 ; 0x17c
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
300062a8: e1540007 cmp r4, r7
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
300062ac: e28d5f46 add r5, sp, #280 ; 0x118
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
300062b0: e58d3004 str r3, [sp, #4]
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
300062b4: 8a000027 bhi 30006358 <rtems_tarfs_load+0x118>
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
300062b8: e086a00a add sl, r6, sl
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
300062bc: e28a0c01 add r0, sl, #256 ; 0x100 300062c0: e2800001 add r0, r0, #1 300062c4: e59f11a0 ldr r1, [pc, #416] ; 3000646c <rtems_tarfs_load+0x22c> 300062c8: e3a02005 mov r2, #5 300062cc: eb004424 bl 30017364 <strncmp> 300062d0: e2508000 subs r8, r0, #0
300062d4: 1a00001f bne 30006358 <rtems_tarfs_load+0x118>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
300062d8: e3a02063 mov r2, #99 ; 0x63 300062dc: e1a0100a mov r1, sl 300062e0: e1a00005 mov r0, r5 300062e4: eb00447f bl 300174e8 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
300062e8: e5cd817b strb r8, [sp, #379] ; 0x17b
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
300062ec: e3a01008 mov r1, #8 300062f0: e28a0064 add r0, sl, #100 ; 0x64
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
300062f4: e5dab09c ldrb fp, [sl, #156] ; 0x9c
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
300062f8: eb0020a6 bl 3000e598 <_rtems_octal2ulong>
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
300062fc: 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);
30006300: e1a09000 mov r9, r0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
30006304: e28a007c add r0, sl, #124 ; 0x7c 30006308: eb0020a2 bl 3000e598 <_rtems_octal2ulong>
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
3000630c: 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);
30006310: e1a08000 mov r8, r0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
30006314: e28a0094 add r0, sl, #148 ; 0x94 30006318: eb00209e bl 3000e598 <_rtems_octal2ulong> 3000631c: e1a03000 mov r3, r0
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
30006320: e1a0000a mov r0, sl 30006324: e58d300c str r3, [sp, #12] 30006328: eb0021a7 bl 3000e9cc <_rtems_tar_header_checksum> 3000632c: e59d300c ldr r3, [sp, #12] 30006330: e1500003 cmp r0, r3
30006334: 1a000007 bne 30006358 <rtems_tarfs_load+0x118>
* 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) {
30006338: e35b0035 cmp fp, #53 ; 0x35
3000633c: 0a00001a beq 300063ac <rtems_tarfs_load+0x16c>
* 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) {
30006340: e35b0030 cmp fp, #48 ; 0x30
30006344: 0a000006 beq 30006364 <rtems_tarfs_load+0x124>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
30006348: e1a0a004 mov sl, r4
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
3000634c: e28a4c02 add r4, sl, #512 ; 0x200 30006350: e1540007 cmp r4, r7
30006354: 9affffd7 bls 300062b8 <rtems_tarfs_load+0x78>
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
30006358: e59d0010 ldr r0, [sp, #16]
3000635c: e28ddf6a add sp, sp, #424 ; 0x1a8
30006360: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
30006364: e59dc008 ldr ip, [sp, #8]
30006368: e59de004 ldr lr, [sp, #4]
3000636c: e8bc000f ldm ip!, {r0, r1, r2, r3}
30006370: e8ae000f stmia lr!, {r0, r1, r2, r3}
30006374: e59cc000 ldr ip, [ip]
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
30006378: e1a00005 mov r0, r5 3000637c: e28d1f5f add r1, sp, #380 ; 0x17c 30006380: e28d2f69 add r2, sp, #420 ; 0x1a4
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
30006384: e58ec000 str ip, [lr]
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
30006388: eb0023c2 bl 3000f298 <IMFS_evaluate_for_make> 3000638c: e250a000 subs sl, r0, #0
30006390: 0a00001c beq 30006408 <rtems_tarfs_load+0x1c8>
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
30006394: e2888f7f add r8, r8, #508 ; 0x1fc <== NOT EXECUTED 30006398: e2888003 add r8, r8, #3 <== NOT EXECUTED 3000639c: e1a084a8 lsr r8, r8, #9 <== NOT EXECUTED
offset += 512 * nblocks;
300063a0: e0844488 add r4, r4, r8, lsl #9 <== NOT EXECUTED
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
300063a4: e1a0a004 mov sl, r4 300063a8: eaffffe7 b 3000634c <rtems_tarfs_load+0x10c>
* - 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);
300063ac: e59d1014 ldr r1, [sp, #20] 300063b0: e28d0018 add r0, sp, #24 300063b4: eb00420e bl 30016bf4 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
300063b8: e28d0018 add r0, sp, #24 300063bc: eb0043d0 bl 30017304 <strlen> 300063c0: e28def6a add lr, sp, #424 ; 0x1a8 300063c4: e08e3000 add r3, lr, r0 300063c8: e5533191 ldrb r3, [r3, #-401] ; 0x191 300063cc: e353002f cmp r3, #47 ; 0x2f
300063d0: 0a000004 beq 300063e8 <rtems_tarfs_load+0x1a8>
strcat(full_filename, "/");
300063d4: e28d2018 add r2, sp, #24 <== NOT EXECUTED 300063d8: e0820000 add r0, r2, r0 <== NOT EXECUTED 300063dc: e59f108c ldr r1, [pc, #140] ; 30006470 <rtems_tarfs_load+0x230><== NOT EXECUTED 300063e0: e3a02002 mov r2, #2 <== NOT EXECUTED 300063e4: eb003eeb bl 30015f98 <memcpy> <== NOT EXECUTED
strcat(full_filename, filename);
300063e8: e1a01005 mov r1, r5 300063ec: e28d0018 add r0, sp, #24 300063f0: eb004148 bl 30016918 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
300063f4: e28d0018 add r0, sp, #24 300063f8: e59f1074 ldr r1, [pc, #116] ; 30006474 <rtems_tarfs_load+0x234> 300063fc: eb0004be bl 300076fc <mkdir>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
30006400: e1a0a004 mov sl, r4 30006404: eaffffd0 b 3000634c <rtems_tarfs_load+0x10c>
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
30006408: e1a03b89 lsl r3, r9, #23 3000640c: 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(
30006410: e3833902 orr r3, r3, #32768 ; 0x8000 30006414: e3a01006 mov r1, #6 30006418: e28d0f5f add r0, sp, #380 ; 0x17c 3000641c: e59d21a4 ldr r2, [sp, #420] ; 0x1a4 30006420: e58da000 str sl, [sp] 30006424: eb0021ec bl 3000ebdc <IMFS_create_node>
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
30006428: e5808050 str r8, [r0, #80] ; 0x50
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
3000642c: e2888f7f add r8, r8, #508 ; 0x1fc 30006430: e2888003 add r8, r8, #3
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];
30006434: e0863004 add r3, r6, r4
}
nblocks = (((file_size) + 511) & ~511) / 512;
30006438: e1a084a8 lsr r8, r8, #9
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
3000643c: e580a054 str sl, [r0, #84] ; 0x54
node->info.linearfile.direct = &tar_image[offset];
30006440: e5803058 str r3, [r0, #88] ; 0x58
}
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
30006444: e0844488 add r4, r4, r8, lsl #9 30006448: eaffffd5 b 300063a4 <rtems_tarfs_load+0x164>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
3000644c: e59f2024 ldr r2, [pc, #36] ; 30006478 <rtems_tarfs_load+0x238><== NOT EXECUTED 30006450: e1530002 cmp r3, r2 <== NOT EXECUTED 30006454: 01a0a000 moveq sl, r0 <== NOT EXECUTED 30006458: 0affff90 beq 300062a0 <rtems_tarfs_load+0x60> <== NOT EXECUTED
return -1;
3000645c: e3e03000 mvn r3, #0 <== NOT EXECUTED 30006460: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 30006464: eaffffbb b 30006358 <rtems_tarfs_load+0x118> <== NOT EXECUTED
30009d20 <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
30009d20: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30009d24: e24dd01c sub sp, sp, #28
30009d28: e59d9044 ldr r9, [sp, #68] ; 0x44
30009d2c: e1a04000 mov r4, r0
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
30009d30: e3590000 cmp r9, #0
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
30009d34: e1a0a001 mov sl, r1 30009d38: e1a06002 mov r6, r2 30009d3c: e1a05003 mov r5, r3
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
return RTEMS_INVALID_ADDRESS;
30009d40: 03a00009 moveq r0, #9
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
30009d44: 0a000031 beq 30009e10 <rtems_task_create+0xf0>
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
30009d48: e3540000 cmp r4, #0
return RTEMS_INVALID_NAME;
30009d4c: 03a00003 moveq r0, #3
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
30009d50: 0a00002e beq 30009e10 <rtems_task_create+0xf0>
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
30009d54: e59d3040 ldr r3, [sp, #64] ; 0x40 30009d58: e3130902 tst r3, #32768 ; 0x8000
30009d5c: 1a000005 bne 30009d78 <rtems_task_create+0x58>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
30009d60: e3510000 cmp r1, #0
30009d64: 0a00002b beq 30009e18 <rtems_task_create+0xf8>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
30009d68: e59f30e0 ldr r3, [pc, #224] ; 30009e50 <rtems_task_create+0x130> 30009d6c: e5d33000 ldrb r3, [r3]
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
30009d70: e1510003 cmp r1, r3
30009d74: 8a000027 bhi 30009e18 <rtems_task_create+0xf8>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
30009d78: e59fb0d4 ldr fp, [pc, #212] ; 30009e54 <rtems_task_create+0x134> 30009d7c: e59b0000 ldr r0, [fp] 30009d80: eb0001bd bl 3000a47c <_API_Mutex_Lock>
* This function allocates a task control block from
* the inactive chain of free task control blocks.
*/
RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information );
30009d84: e59f00cc ldr r0, [pc, #204] ; 30009e58 <rtems_task_create+0x138> 30009d88: eb000450 bl 3000aed0 <_Objects_Allocate>
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
30009d8c: e2507000 subs r7, r0, #0
30009d90: 0a00002a beq 30009e40 <rtems_task_create+0x120>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
30009d94: e3150c01 tst r5, #256 ; 0x100 30009d98: 13a01000 movne r1, #0 30009d9c: 03a01001 moveq r1, #1 30009da0: e3150c02 tst r5, #512 ; 0x200
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false;
30009da4: e3a08000 mov r8, #0 30009da8: 03a02000 moveq r2, #0 30009dac: 13a02001 movne r2, #1
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
30009db0: e2053080 and r3, r5, #128 ; 0x80
30009db4: e58d1008 str r1, [sp, #8]
30009db8: e58d200c str r2, [sp, #12]
30009dbc: e58d3014 str r3, [sp, #20]
30009dc0: e59f0090 ldr r0, [pc, #144] ; 30009e58 <rtems_task_create+0x138>
30009dc4: e1a01007 mov r1, r7
30009dc8: e1a02008 mov r2, r8
30009dcc: e1a03006 mov r3, r6
30009dd0: e88d0500 stm sp, {r8, sl}
30009dd4: e58d8010 str r8, [sp, #16]
30009dd8: e58d4018 str r4, [sp, #24]
30009ddc: eb0008f5 bl 3000c1b8 <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
30009de0: e1500008 cmp r0, r8
30009de4: 0a00000d beq 30009e20 <rtems_task_create+0x100>
_RTEMS_Unlock_allocator();
return RTEMS_UNSATISFIED;
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
30009de8: e59720f8 ldr r2, [r7, #248] ; 0xf8
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
*id = the_thread->Object.id;
30009dec: e5973008 ldr r3, [r7, #8]
* id - thread id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_task_create(
30009df0: e3150b01 tst r5, #1024 ; 0x400 30009df4: 13a01000 movne r1, #0 30009df8: 03a01001 moveq r1, #1
);
}
#endif
_RTEMS_Unlock_allocator();
30009dfc: e59b0000 ldr r0, [fp]
* id - thread id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_task_create(
30009e00: e5c21008 strb r1, [r2, #8]
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
*id = the_thread->Object.id;
30009e04: e5893000 str r3, [r9]
);
}
#endif
_RTEMS_Unlock_allocator();
30009e08: eb0001b7 bl 3000a4ec <_API_Mutex_Unlock>
return RTEMS_SUCCESSFUL;
30009e0c: e1a00008 mov r0, r8
}
30009e10: e28dd01c add sp, sp, #28
30009e14: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )
return RTEMS_INVALID_PRIORITY;
30009e18: e3a00013 mov r0, #19 <== NOT EXECUTED 30009e1c: eafffffb b 30009e10 <rtems_task_create+0xf0> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
Thread_Control *the_task
)
{
_Objects_Free(
30009e20: e5970008 ldr r0, [r7, #8] 30009e24: eb000520 bl 3000b2ac <_Objects_Get_information_id> 30009e28: e1a01007 mov r1, r7 30009e2c: eb000501 bl 3000b238 <_Objects_Free>
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global )
_Objects_MP_Free_global_object( the_global_object );
#endif
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
30009e30: e59b0000 ldr r0, [fp] 30009e34: eb0001ac bl 3000a4ec <_API_Mutex_Unlock>
return RTEMS_UNSATISFIED;
30009e38: e3a0000d mov r0, #13 30009e3c: eafffff3 b 30009e10 <rtems_task_create+0xf0>
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
30009e40: e59b0000 ldr r0, [fp] 30009e44: eb0001a8 bl 3000a4ec <_API_Mutex_Unlock>
return RTEMS_TOO_MANY;
30009e48: e3a00005 mov r0, #5 30009e4c: eaffffef b 30009e10 <rtems_task_create+0xf0>
30009e5c <rtems_task_delete>:
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
30009e5c: e92d4070 push {r4, r5, r6, lr}
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
30009e60: e59f4070 ldr r4, [pc, #112] ; 30009ed8 <rtems_task_delete+0x7c>
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
30009e64: e24dd004 sub sp, sp, #4 30009e68: e1a05000 mov r5, r0
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
30009e6c: e5940000 ldr r0, [r4] 30009e70: eb000181 bl 3000a47c <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
30009e74: e1a00005 mov r0, r5 30009e78: e1a0100d mov r1, sp 30009e7c: eb0008a8 bl 3000c124 <_Thread_Get>
switch ( location ) {
30009e80: e59d5000 ldr r5, [sp]
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
the_thread = _Thread_Get( id, &location );
30009e84: e1a06000 mov r6, r0
switch ( location ) {
30009e88: e3550000 cmp r5, #0
30009e8c: 1a00000d bne 30009ec8 <rtems_task_delete+0x6c>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
30009e90: e5900008 ldr r0, [r0, #8] 30009e94: eb000504 bl 3000b2ac <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
30009e98: e1a01006 mov r1, r6 30009e9c: eb0007cd bl 3000bdd8 <_Thread_Close> 30009ea0: e5960008 ldr r0, [r6, #8] 30009ea4: eb000500 bl 3000b2ac <_Objects_Get_information_id> 30009ea8: e1a01006 mov r1, r6 30009eac: eb0004e1 bl 3000b238 <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
30009eb0: e5940000 ldr r0, [r4] 30009eb4: eb00018c bl 3000a4ec <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
30009eb8: eb000890 bl 3000c100 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30009ebc: e1a00005 mov r0, r5
break;
}
_RTEMS_Unlock_allocator();
return RTEMS_INVALID_ID;
}
30009ec0: e28dd004 add sp, sp, #4
30009ec4: e8bd8070 pop {r4, r5, r6, pc}
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
30009ec8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30009ecc: eb000186 bl 3000a4ec <_API_Mutex_Unlock> <== NOT EXECUTED
return RTEMS_INVALID_ID;
30009ed0: e3a00004 mov r0, #4 <== NOT EXECUTED 30009ed4: eafffff9 b 30009ec0 <rtems_task_delete+0x64> <== NOT EXECUTED
3000c128 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c128: e92d4030 push {r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c12c: e59f30a8 ldr r3, [pc, #168] ; 3000c1dc <rtems_task_get_note+0xb4>
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c130: e1a0c000 mov ip, r0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c134: e5d33004 ldrb r3, [r3, #4]
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c138: e24dd008 sub sp, sp, #8
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c13c: e3530000 cmp r3, #0
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c140: e1a04001 mov r4, r1
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
3000c144: 03a00016 moveq r0, #22
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c148: 0a000019 beq 3000c1b4 <rtems_task_get_note+0x8c>
return RTEMS_NOT_CONFIGURED;
if ( !note )
3000c14c: e3520000 cmp r2, #0
return RTEMS_INVALID_ADDRESS;
3000c150: 03a00009 moveq r0, #9
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
3000c154: 0a000016 beq 3000c1b4 <rtems_task_get_note+0x8c>
/*
* 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 )
3000c158: e351000f cmp r1, #15
return RTEMS_INVALID_NUMBER;
3000c15c: 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 )
3000c160: 8a000013 bhi 3000c1b4 <rtems_task_get_note+0x8c>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c164: e35c0000 cmp ip, #0
3000c168: 0a000013 beq 3000c1bc <rtems_task_get_note+0x94>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
3000c16c: e59f306c ldr r3, [pc, #108] ; 3000c1e0 <rtems_task_get_note+0xb8> 3000c170: e5933004 ldr r3, [r3, #4]
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c174: e5931008 ldr r1, [r3, #8] 3000c178: e15c0001 cmp ip, r1
3000c17c: 0a000010 beq 3000c1c4 <rtems_task_get_note+0x9c>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
3000c180: e28d1004 add r1, sp, #4 3000c184: e58d2000 str r2, [sp] 3000c188: eb000969 bl 3000e734 <_Thread_Get>
switch ( location ) {
3000c18c: e89d0024 ldm sp, {r2, r5}
3000c190: e3550000 cmp r5, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000c194: 13a00004 movne r0, #4
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000c198: 1a000005 bne 3000c1b4 <rtems_task_get_note+0x8c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
3000c19c: e59030f8 ldr r3, [r0, #248] ; 0xf8 3000c1a0: e2844008 add r4, r4, #8 3000c1a4: e7933104 ldr r3, [r3, r4, lsl #2] 3000c1a8: e5823000 str r3, [r2]
_Thread_Enable_dispatch();
3000c1ac: eb000957 bl 3000e710 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000c1b0: e1a00005 mov r0, r5
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000c1b4: e28dd008 add sp, sp, #8
3000c1b8: e8bd8030 pop {r4, r5, pc}
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c1bc: e59f301c ldr r3, [pc, #28] ; 3000c1e0 <rtems_task_get_note+0xb8><== NOT EXECUTED 3000c1c0: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
3000c1c4: e59330f8 ldr r3, [r3, #248] ; 0xf8 <== NOT EXECUTED 3000c1c8: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000c1cc: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c1d0: 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 ];
3000c1d4: e5823000 str r3, [r2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c1d8: eafffff5 b 3000c1b4 <rtems_task_get_note+0x8c> <== NOT EXECUTED
30009edc <rtems_task_ident>:
rtems_id *id
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
30009edc: e2523000 subs r3, r2, #0
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
rtems_id *id
)
{
30009ee0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
30009ee4: e1a0c000 mov ip, r0
30009ee8: e1a02001 mov r2, r1
Objects_Name_or_id_lookup_errors status;
if ( !id )
30009eec: 0a00000c beq 30009f24 <rtems_task_ident+0x48>
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
30009ef0: e3500000 cmp r0, #0
30009ef4: 1a000004 bne 30009f0c <rtems_task_ident+0x30>
*id = _Thread_Executing->Object.id;
30009ef8: e59f202c ldr r2, [pc, #44] ; 30009f2c <rtems_task_ident+0x50><== NOT EXECUTED 30009efc: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 30009f00: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 30009f04: e5832000 str r2, [r3] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30009f08: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
30009f0c: e59f001c ldr r0, [pc, #28] ; 30009f30 <rtems_task_ident+0x54> 30009f10: e1a0100c mov r1, ip 30009f14: eb00057e bl 3000b514 <_Objects_Name_to_id_u32>
return _Status_Object_name_errors_to_status[ status ];
30009f18: e59f3014 ldr r3, [pc, #20] ; 30009f34 <rtems_task_ident+0x58>
30009f1c: e7930100 ldr r0, [r3, r0, lsl #2]
30009f20: e49df004 pop {pc} ; (ldr pc, [sp], #4)
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
return RTEMS_INVALID_ADDRESS;
30009f24: 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 ];
}
30009f28: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30019918 <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
rtems_id id
)
{
30019918: e92d4010 push {r4, lr} <== NOT EXECUTED
3001991c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
30019920: e1a0100d mov r1, sp <== NOT EXECUTED 30019924: eb0010ec bl 3001dcdc <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30019928: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3001992c: e3530000 cmp r3, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30019930: 13a00004 movne r0, #4 <== NOT EXECUTED
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
30019934: 1a000004 bne 3001994c <rtems_task_is_suspended+0x34> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
30019938: e5904010 ldr r4, [r0, #16] <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
3001993c: e2144002 ands r4, r4, #2 <== NOT EXECUTED 30019940: 0a000003 beq 30019954 <rtems_task_is_suspended+0x3c> <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
30019944: eb0010db bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_ALREADY_SUSPENDED;
30019948: e3a0000f mov r0, #15 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001994c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30019950: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Enable_dispatch();
30019954: eb0010d7 bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30019958: e1a00004 mov r0, r4 <== NOT EXECUTED 3001995c: eafffffa b 3001994c <rtems_task_is_suspended+0x34> <== NOT EXECUTED
30011b48 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
30011b48: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
30011b4c: e2525000 subs r5, r2, #0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
30011b50: e1a04000 mov r4, r0 30011b54: e1a06001 mov r6, r1
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
30011b58: 03a00009 moveq r0, #9
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
30011b5c: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
30011b60: e59f9148 ldr r9, [pc, #328] ; 30011cb0 <rtems_task_mode+0x168> 30011b64: e5997004 ldr r7, [r9, #4]
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
30011b68: e5d7a074 ldrb sl, [r7, #116] ; 0x74
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
30011b6c: e59780f8 ldr r8, [r7, #248] ; 0xf8
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
30011b70: e597307c ldr r3, [r7, #124] ; 0x7c
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
30011b74: e35a0000 cmp sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
30011b78: e5d8b008 ldrb fp, [r8, #8]
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
30011b7c: 03a0ac01 moveq sl, #256 ; 0x100 30011b80: 13a0a000 movne sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
30011b84: e3530000 cmp r3, #0
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
30011b88: 138aac02 orrne sl, sl, #512 ; 0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
30011b8c: e35b0000 cmp fp, #0 30011b90: 03a0bb01 moveq fp, #1024 ; 0x400 30011b94: 13a0b000 movne fp, #0
old_mode |= _ISR_Get_level();
30011b98: ebffeec9 bl 3000d6c4 <_CPU_ISR_Get_level>
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
30011b9c: e18bb000 orr fp, fp, r0
old_mode |= _ISR_Get_level();
30011ba0: e18ba00a orr sl, fp, sl
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
30011ba4: e3160c01 tst r6, #256 ; 0x100
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
30011ba8: e585a000 str sl, [r5]
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
30011bac: 0a000003 beq 30011bc0 <rtems_task_mode+0x78>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
30011bb0: e3140c01 tst r4, #256 ; 0x100 30011bb4: 13a03000 movne r3, #0 30011bb8: 03a03001 moveq r3, #1 30011bbc: e5c73074 strb r3, [r7, #116] ; 0x74
if ( mask & RTEMS_TIMESLICE_MASK ) {
30011bc0: e3160c02 tst r6, #512 ; 0x200
30011bc4: 1a000028 bne 30011c6c <rtems_task_mode+0x124>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
30011bc8: e3160080 tst r6, #128 ; 0x80
30011bcc: 1a00002f bne 30011c90 <rtems_task_mode+0x148>
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
30011bd0: e2166b01 ands r6, r6, #1024 ; 0x400
30011bd4: 0a000012 beq 30011c24 <rtems_task_mode+0xdc>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
30011bd8: e3140b01 tst r4, #1024 ; 0x400
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
30011bdc: e5d82008 ldrb r2, [r8, #8]
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
30011be0: 13a03000 movne r3, #0 30011be4: 03a03001 moveq r3, #1
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
30011be8: e1520003 cmp r2, r3
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
30011bec: 03a06000 moveq r6, #0
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
30011bf0: 0a00000b beq 30011c24 <rtems_task_mode+0xdc>
asr->is_enabled = is_asr_enabled;
30011bf4: e5c83008 strb r3, [r8, #8]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30011bf8: e10f3000 mrs r3, CPSR 30011bfc: e3832080 orr r2, r3, #128 ; 0x80 30011c00: e129f002 msr CPSR_fc, r2
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
30011c04: e5981018 ldr r1, [r8, #24]
information->signals_pending = information->signals_posted;
30011c08: e5982014 ldr r2, [r8, #20]
information->signals_posted = _signals;
30011c0c: e5881014 str r1, [r8, #20]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
30011c10: e5882018 str r2, [r8, #24]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30011c14: e129f003 msr CPSR_fc, r3
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
30011c18: e5986014 ldr r6, [r8, #20] 30011c1c: e3560000 cmp r6, #0
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
30011c20: 13a06001 movne r6, #1
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
30011c24: e59f3088 ldr r3, [pc, #136] ; 30011cb4 <rtems_task_mode+0x16c> 30011c28: e5933000 ldr r3, [r3] 30011c2c: e3530003 cmp r3, #3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
30011c30: 13a00000 movne r0, #0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
30011c34: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
30011c38: e3560000 cmp r6, #0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
30011c3c: e5993004 ldr r3, [r9, #4]
if ( are_signals_pending ||
30011c40: 1a000015 bne 30011c9c <rtems_task_mode+0x154>
30011c44: e59f2064 ldr r2, [pc, #100] ; 30011cb0 <rtems_task_mode+0x168> 30011c48: e5922008 ldr r2, [r2, #8] 30011c4c: e1530002 cmp r3, r2
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
30011c50: 01a00006 moveq r0, r6
30011c54: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
30011c58: e5d33074 ldrb r3, [r3, #116] ; 0x74 30011c5c: e3530000 cmp r3, #0
30011c60: 1a00000d bne 30011c9c <rtems_task_mode+0x154>
30011c64: e1a00006 mov r0, r6 <== NOT EXECUTED
}
30011c68: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
*/
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
30011c6c: e2143c02 ands r3, r4, #512 ; 0x200
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
30011c70: 159f3040 ldrne r3, [pc, #64] ; 30011cb8 <rtems_task_mode+0x170>
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
30011c74: 13a02001 movne r2, #1
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
30011c78: 15933000 ldrne r3, [r3]
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
30011c7c: 1587207c strne r2, [r7, #124] ; 0x7c
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
30011c80: 15873078 strne r3, [r7, #120] ; 0x78
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
30011c84: 0587307c streq r3, [r7, #124] ; 0x7c
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
30011c88: e3160080 tst r6, #128 ; 0x80
30011c8c: 0affffcf beq 30011bd0 <rtems_task_mode+0x88>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
30011c90: e2040080 and r0, r4, #128 ; 0x80 30011c94: ebffee85 bl 3000d6b0 <_CPU_ISR_Set_level> 30011c98: eaffffcc b 30011bd0 <rtems_task_mode+0x88>
_Thread_Dispatch_necessary = true;
30011c9c: e3a03001 mov r3, #1 30011ca0: e5c93010 strb r3, [r9, #16]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
30011ca4: ebffe8bf bl 3000bfa8 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
30011ca8: e3a00000 mov r0, #0
30011cac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000ac40 <rtems_task_restart>:
rtems_status_code rtems_task_restart(
rtems_id id,
uint32_t argument
)
{
3000ac40: e92d4030 push {r4, r5, lr}
3000ac44: e24dd004 sub sp, sp, #4
3000ac48: e1a05001 mov r5, r1
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000ac4c: e1a0100d mov r1, sp 3000ac50: eb000878 bl 3000ce38 <_Thread_Get>
switch ( location ) {
3000ac54: e59d4000 ldr r4, [sp] 3000ac58: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000ac5c: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000ac60: 1a000006 bne 3000ac80 <rtems_task_restart+0x40>
case OBJECTS_LOCAL:
if ( _Thread_Restart( the_thread, NULL, argument ) ) {
3000ac64: e1a01004 mov r1, r4 3000ac68: e1a02005 mov r2, r5 3000ac6c: eb000a89 bl 3000d698 <_Thread_Restart> 3000ac70: e3500000 cmp r0, #0
3000ac74: 1a000003 bne 3000ac88 <rtems_task_restart+0x48>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000ac78: eb000865 bl 3000ce14 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000ac7c: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000ac80: e28dd004 add sp, sp, #4
3000ac84: e8bd8030 pop {r4, r5, pc}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Restart( the_thread, NULL, argument ) ) {
_Thread_Enable_dispatch();
3000ac88: eb000861 bl 3000ce14 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ac8c: e1a00004 mov r0, r4 3000ac90: eafffffa b 3000ac80 <rtems_task_restart+0x40>
3000d68c <rtems_task_resume>:
*/
rtems_status_code rtems_task_resume(
rtems_id id
)
{
3000d68c: e92d4010 push {r4, lr}
3000d690: e24dd004 sub sp, sp, #4
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d694: e1a0100d mov r1, sp 3000d698: eb000890 bl 3000f8e0 <_Thread_Get>
switch ( location ) {
3000d69c: e59d4000 ldr r4, [sp]
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d6a0: e1a03000 mov r3, r0
switch ( location ) {
3000d6a4: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000d6a8: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000d6ac: 1a000004 bne 3000d6c4 <rtems_task_resume+0x38>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3000d6b0: e5933010 ldr r3, [r3, #16]
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
3000d6b4: e3130002 tst r3, #2
3000d6b8: 1a000003 bne 3000d6cc <rtems_task_resume+0x40>
_Thread_Resume( the_thread, true );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000d6bc: eb00087e bl 3000f8bc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000d6c0: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000d6c4: e28dd004 add sp, sp, #4
3000d6c8: e8bd8010 pop {r4, pc}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
_Thread_Resume( the_thread, true );
3000d6cc: e3a01001 mov r1, #1 3000d6d0: eb000a9a bl 30010140 <_Thread_Resume>
_Thread_Enable_dispatch();
3000d6d4: eb000878 bl 3000f8bc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000d6d8: e1a00004 mov r0, r4 3000d6dc: eafffff8 b 3000d6c4 <rtems_task_resume+0x38>
3000c2dc <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c2dc: e92d4030 push {r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c2e0: e59f3094 ldr r3, [pc, #148] ; 3000c37c <rtems_task_set_note+0xa0>
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c2e4: e1a0c000 mov ip, r0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c2e8: e5d33004 ldrb r3, [r3, #4]
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c2ec: e24dd008 sub sp, sp, #8
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c2f0: e3530000 cmp r3, #0
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c2f4: e1a04001 mov r4, r1
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
3000c2f8: 03a00016 moveq r0, #22
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c2fc: 0a000015 beq 3000c358 <rtems_task_set_note+0x7c>
/*
* 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 )
3000c300: e351000f cmp r1, #15
return RTEMS_INVALID_NUMBER;
3000c304: 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 )
3000c308: 8a000012 bhi 3000c358 <rtems_task_set_note+0x7c>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c30c: e35c0000 cmp ip, #0
3000c310: 0a000012 beq 3000c360 <rtems_task_set_note+0x84>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
3000c314: e59f3064 ldr r3, [pc, #100] ; 3000c380 <rtems_task_set_note+0xa4> 3000c318: e5933004 ldr r3, [r3, #4]
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c31c: e5931008 ldr r1, [r3, #8] 3000c320: e15c0001 cmp ip, r1
3000c324: 0a00000f beq 3000c368 <rtems_task_set_note+0x8c>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
3000c328: e28d1004 add r1, sp, #4 3000c32c: e58d2000 str r2, [sp] 3000c330: eb0008ff bl 3000e734 <_Thread_Get>
switch ( location ) {
3000c334: e89d0024 ldm sp, {r2, r5}
3000c338: e3550000 cmp r5, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000c33c: 13a00004 movne r0, #4
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000c340: 1a000004 bne 3000c358 <rtems_task_set_note+0x7c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
3000c344: e59030f8 ldr r3, [r0, #248] ; 0xf8 3000c348: e2844008 add r4, r4, #8 3000c34c: e7832104 str r2, [r3, r4, lsl #2]
_Thread_Enable_dispatch();
3000c350: eb0008ee bl 3000e710 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000c354: e1a00005 mov r0, r5
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000c358: e28dd008 add sp, sp, #8
3000c35c: e8bd8030 pop {r4, r5, pc}
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c360: e59f3018 ldr r3, [pc, #24] ; 3000c380 <rtems_task_set_note+0xa4><== NOT EXECUTED 3000c364: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
3000c368: e59330f8 ldr r3, [r3, #248] ; 0xf8 <== NOT EXECUTED 3000c36c: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000c370: e7832104 str r2, [r3, r4, lsl #2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c374: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c378: eafffff6 b 3000c358 <rtems_task_set_note+0x7c> <== NOT EXECUTED
3000e550 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
3000e550: e92d4030 push {r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000e554: 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
)
{
3000e558: e24dd004 sub sp, sp, #4 3000e55c: e1a05002 mov r5, r2
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000e560: 0a000004 beq 3000e578 <rtems_task_set_priority+0x28>
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 ) );
3000e564: e59f3078 ldr r3, [pc, #120] ; 3000e5e4 <rtems_task_set_priority+0x94> 3000e568: e5d33000 ldrb r3, [r3]
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
3000e56c: e1540003 cmp r4, r3
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
3000e570: 83a00013 movhi r0, #19
3000e574: 8a000018 bhi 3000e5dc <rtems_task_set_priority+0x8c>
if ( !old_priority )
3000e578: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3000e57c: 03a00009 moveq r0, #9
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
3000e580: 0a000015 beq 3000e5dc <rtems_task_set_priority+0x8c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
3000e584: e1a0100d mov r1, sp 3000e588: eb0008eb bl 3001093c <_Thread_Get>
switch ( location ) {
3000e58c: e59d3000 ldr r3, [sp] 3000e590: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000e594: 13a00004 movne r0, #4
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000e598: 1a00000f bne 3000e5dc <rtems_task_set_priority+0x8c>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
3000e59c: e5903014 ldr r3, [r0, #20]
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
3000e5a0: 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;
3000e5a4: e5853000 str r3, [r5]
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
3000e5a8: 0a000009 beq 3000e5d4 <rtems_task_set_priority+0x84>
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
3000e5ac: 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;
3000e5b0: e5804018 str r4, [r0, #24]
if ( the_thread->resource_count == 0 ||
3000e5b4: e3530000 cmp r3, #0
3000e5b8: 0a000002 beq 3000e5c8 <rtems_task_set_priority+0x78>
3000e5bc: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000e5c0: e1540003 cmp r4, r3 <== NOT EXECUTED 3000e5c4: 2a000002 bcs 3000e5d4 <rtems_task_set_priority+0x84> <== NOT EXECUTED
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
3000e5c8: e1a01004 mov r1, r4 3000e5cc: e3a02000 mov r2, #0 3000e5d0: eb0007b3 bl 300104a4 <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
3000e5d4: eb0008cf bl 30010918 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000e5d8: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000e5dc: e28dd004 add sp, sp, #4
3000e5e0: e8bd8030 pop {r4, r5, pc}
30009fc8 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
30009fc8: e92d4070 push {r4, r5, r6, lr}
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
30009fcc: e2515000 subs r5, r1, #0
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
30009fd0: e24dd008 sub sp, sp, #8 30009fd4: e1a06002 mov r6, r2
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
30009fd8: 03a00009 moveq r0, #9
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
30009fdc: 0a00000e beq 3000a01c <rtems_task_start+0x54>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
30009fe0: e28d1004 add r1, sp, #4 30009fe4: eb00084e bl 3000c124 <_Thread_Get>
switch ( location ) {
30009fe8: e59d4004 ldr r4, [sp, #4] 30009fec: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009ff0: 13a00004 movne r0, #4
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
30009ff4: 1a000008 bne 3000a01c <rtems_task_start+0x54>
case OBJECTS_LOCAL:
if ( _Thread_Start(
30009ff8: e1a01004 mov r1, r4 30009ffc: e1a02005 mov r2, r5 3000a000: e1a03004 mov r3, r4 3000a004: e58d6000 str r6, [sp] 3000a008: eb000ac0 bl 3000cb10 <_Thread_Start> 3000a00c: e3500000 cmp r0, #0
3000a010: 1a000003 bne 3000a024 <rtems_task_start+0x5c>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000a014: eb000839 bl 3000c100 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000a018: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000a01c: e28dd008 add sp, sp, #8
3000a020: e8bd8070 pop {r4, r5, r6, pc}
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Start(
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
3000a024: eb000835 bl 3000c100 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a028: e1a00004 mov r0, r4 3000a02c: eafffffa b 3000a01c <rtems_task_start+0x54>
3000d930 <rtems_task_suspend>:
*/
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
3000d930: e92d4010 push {r4, lr}
3000d934: e24dd004 sub sp, sp, #4
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d938: e1a0100d mov r1, sp 3000d93c: eb00085c bl 3000fab4 <_Thread_Get>
switch ( location ) {
3000d940: e59d3000 ldr r3, [sp]
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d944: e1a02000 mov r2, r0
switch ( location ) {
3000d948: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000d94c: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000d950: 1a000004 bne 3000d968 <rtems_task_suspend+0x38>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3000d954: e5924010 ldr r4, [r2, #16]
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
3000d958: e2144002 ands r4, r4, #2
3000d95c: 0a000003 beq 3000d970 <rtems_task_suspend+0x40>
_Thread_Suspend( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000d960: eb00084a bl 3000fa90 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_ALREADY_SUSPENDED;
3000d964: e3a0000f mov r0, #15 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000d968: e28dd004 add sp, sp, #4
3000d96c: e8bd8010 pop {r4, pc}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Suspend( the_thread );
3000d970: eb000add bl 300104ec <_Thread_Suspend>
_Thread_Enable_dispatch();
3000d974: eb000845 bl 3000fa90 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000d978: e1a00004 mov r0, r4 3000d97c: eafffff9 b 3000d968 <rtems_task_suspend+0x38>
3000addc <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
3000addc: e92d4070 push {r4, r5, r6, lr}
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
3000ade0: e2514000 subs r4, r1, #0
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
3000ade4: e24dd004 sub sp, sp, #4 3000ade8: e1a05002 mov r5, r2
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
3000adec: 03a00009 moveq r0, #9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
3000adf0: 0a000016 beq 3000ae50 <rtems_task_variable_add+0x74>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
3000adf4: e1a0100d mov r1, sp 3000adf8: eb000899 bl 3000d064 <_Thread_Get>
switch (location) {
3000adfc: e59d3000 ldr r3, [sp]
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
3000ae00: e1a06000 mov r6, r0
switch (location) {
3000ae04: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000ae08: 13a00004 movne r0, #4
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
3000ae0c: 1a00000f bne 3000ae50 <rtems_task_variable_add+0x74>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
3000ae10: e5963104 ldr r3, [r6, #260] ; 0x104
while (tvp) {
3000ae14: e3530000 cmp r3, #0
3000ae18: 1a000011 bne 3000ae64 <rtems_task_variable_add+0x88>
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
3000ae1c: e3a00014 mov r0, #20 3000ae20: eb000cfb bl 3000e214 <_Workspace_Allocate>
if (new == NULL) {
3000ae24: e3500000 cmp r0, #0
3000ae28: 0a000014 beq 3000ae80 <rtems_task_variable_add+0xa4>
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
3000ae2c: e5942000 ldr r2, [r4]
new->ptr = ptr;
new->dtor = dtor;
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
3000ae30: e5963104 ldr r3, [r6, #260] ; 0x104
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
3000ae34: e5802008 str r2, [r0, #8]
new->ptr = ptr;
3000ae38: e5804004 str r4, [r0, #4]
new->dtor = dtor;
3000ae3c: e5805010 str r5, [r0, #16]
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
3000ae40: e5803000 str r3, [r0]
the_thread->task_variables = new;
3000ae44: e5860104 str r0, [r6, #260] ; 0x104
_Thread_Enable_dispatch();
3000ae48: eb00087c bl 3000d040 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ae4c: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000ae50: e28dd004 add sp, sp, #4
3000ae54: e8bd8070 pop {r4, r5, r6, pc}
if (tvp->ptr == ptr) {
tvp->dtor = dtor;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
3000ae58: e5933000 ldr r3, [r3] <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
3000ae5c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ae60: 0affffed beq 3000ae1c <rtems_task_variable_add+0x40> <== NOT EXECUTED
if (tvp->ptr == ptr) {
3000ae64: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000ae68: e1520004 cmp r2, r4 <== NOT EXECUTED 3000ae6c: 1afffff9 bne 3000ae58 <rtems_task_variable_add+0x7c> <== NOT EXECUTED
tvp->dtor = dtor;
3000ae70: e5835010 str r5, [r3, #16] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000ae74: eb000871 bl 3000d040 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000ae78: e3a00000 mov r0, #0 <== NOT EXECUTED 3000ae7c: eafffff3 b 3000ae50 <rtems_task_variable_add+0x74> <== NOT EXECUTED
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
3000ae80: eb00086e bl 3000d040 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
3000ae84: e3a0001a mov r0, #26 <== NOT EXECUTED 3000ae88: eafffff0 b 3000ae50 <rtems_task_variable_add+0x74> <== NOT EXECUTED
3000ae8c <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
3000ae8c: e92d4010 push {r4, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
3000ae90: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
3000ae94: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
3000ae98: 03a00009 moveq r0, #9 <== NOT EXECUTED
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
3000ae9c: 0a000015 beq 3000aef8 <rtems_task_variable_delete+0x6c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
3000aea0: e1a0100d mov r1, sp <== NOT EXECUTED 3000aea4: eb00086e bl 3000d064 <_Thread_Get> <== NOT EXECUTED
switch (location) {
3000aea8: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000aeac: e3530000 cmp r3, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000aeb0: 13a00004 movne r0, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
switch (location) {
3000aeb4: 1a00000f bne 3000aef8 <rtems_task_variable_delete+0x6c> <== NOT EXECUTED
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
3000aeb8: e5903104 ldr r3, [r0, #260] ; 0x104 <== NOT EXECUTED
while (tvp) {
3000aebc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000aec0: 0a00000a beq 3000aef0 <rtems_task_variable_delete+0x64> <== NOT EXECUTED
if (tvp->ptr == ptr) {
3000aec4: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000aec8: e1520004 cmp r2, r4 <== NOT EXECUTED 3000aecc: 1a000004 bne 3000aee4 <rtems_task_variable_delete+0x58> <== NOT EXECUTED 3000aed0: ea000010 b 3000af18 <rtems_task_variable_delete+0x8c> <== NOT EXECUTED 3000aed4: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED 3000aed8: e1520004 cmp r2, r4 <== NOT EXECUTED 3000aedc: 0a000007 beq 3000af00 <rtems_task_variable_delete+0x74> <== NOT EXECUTED 3000aee0: e1a03001 mov r3, r1 <== NOT EXECUTED
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
3000aee4: e5931000 ldr r1, [r3] <== NOT EXECUTED
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
3000aee8: e3510000 cmp r1, #0 <== NOT EXECUTED 3000aeec: 1afffff8 bne 3000aed4 <rtems_task_variable_delete+0x48> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
3000aef0: eb000852 bl 3000d040 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000aef4: e3a00009 mov r0, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000aef8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000aefc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
3000af00: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000af04: e5832000 str r2, [r3] <== NOT EXECUTED
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
3000af08: eb000028 bl 3000afb0 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
_Thread_Enable_dispatch();
3000af0c: eb00084b bl 3000d040 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000af10: e3a00000 mov r0, #0 <== NOT EXECUTED 3000af14: eafffff7 b 3000aef8 <rtems_task_variable_delete+0x6c> <== NOT EXECUTED
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
3000af18: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000af1c: e1a01003 mov r1, r3 <== NOT EXECUTED 3000af20: e5802104 str r2, [r0, #260] ; 0x104 <== NOT EXECUTED 3000af24: eafffff7 b 3000af08 <rtems_task_variable_delete+0x7c> <== NOT EXECUTED
3000af28 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
3000af28: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
3000af2c: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
3000af30: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000af34: e1a05002 mov r5, r2 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
3000af38: 0a000017 beq 3000af9c <rtems_task_variable_get+0x74> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !result )
3000af3c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000af40: 0a000015 beq 3000af9c <rtems_task_variable_get+0x74> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
3000af44: e1a0100d mov r1, sp <== NOT EXECUTED 3000af48: eb000845 bl 3000d064 <_Thread_Get> <== NOT EXECUTED
switch (location) {
3000af4c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000af50: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000af54: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !result )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
3000af58: 1a00000d bne 3000af94 <rtems_task_variable_get+0x6c> <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
3000af5c: e5903104 ldr r3, [r0, #260] ; 0x104 <== NOT EXECUTED
while (tvp) {
3000af60: e3530000 cmp r3, #0 <== NOT EXECUTED 3000af64: 1a000003 bne 3000af78 <rtems_task_variable_get+0x50> <== NOT EXECUTED 3000af68: ea00000d b 3000afa4 <rtems_task_variable_get+0x7c> <== NOT EXECUTED
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
3000af6c: 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) {
3000af70: e3530000 cmp r3, #0 <== NOT EXECUTED 3000af74: 0a00000a beq 3000afa4 <rtems_task_variable_get+0x7c> <== NOT EXECUTED
if (tvp->ptr == ptr) {
3000af78: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000af7c: e1520004 cmp r2, r4 <== NOT EXECUTED 3000af80: 1afffff9 bne 3000af6c <rtems_task_variable_get+0x44> <== NOT EXECUTED
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
3000af84: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 3000af88: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000af8c: eb00082b bl 3000d040 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000af90: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000af94: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000af98: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
3000af9c: e3a00009 mov r0, #9 <== NOT EXECUTED 3000afa0: eafffffb b 3000af94 <rtems_task_variable_get+0x6c> <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
3000afa4: eb000825 bl 3000d040 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000afa8: e3a00009 mov r0, #9 <== NOT EXECUTED 3000afac: eafffff8 b 3000af94 <rtems_task_variable_get+0x6c> <== NOT EXECUTED
3000a030 <rtems_task_wake_after>:
3000a030: e59f307c ldr r3, [pc, #124] ; 3000a0b4 <rtems_task_wake_after+0x84>
*/
rtems_status_code rtems_task_wake_after(
rtems_interval ticks
)
{
3000a034: e92d4030 push {r4, r5, lr}
3000a038: e5932000 ldr r2, [r3]
3000a03c: e1a04000 mov r4, r0
3000a040: e2822001 add r2, r2, #1
3000a044: e5832000 str r2, [r3]
_Thread_Disable_dispatch();
if ( ticks == 0 ) {
3000a048: e3500000 cmp r0, #0
3000a04c: 0a000012 beq 3000a09c <rtems_task_wake_after+0x6c>
_Scheduler_Yield();
} else {
_Thread_Set_state( _Thread_Executing, STATES_DELAYING );
3000a050: e59f5060 ldr r5, [pc, #96] ; 3000a0b8 <rtems_task_wake_after+0x88><== NOT EXECUTED 3000a054: e3a01008 mov r1, #8 <== NOT EXECUTED 3000a058: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 3000a05c: eb000a4f bl 3000c9a0 <_Thread_Set_state> <== NOT EXECUTED
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3000a060: e5951004 ldr r1, [r5, #4] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000a064: e59f0050 ldr r0, [pc, #80] ; 3000a0bc <rtems_task_wake_after+0x8c><== NOT EXECUTED
_Thread_Disable_dispatch();
if ( ticks == 0 ) {
_Scheduler_Yield();
} else {
_Thread_Set_state( _Thread_Executing, STATES_DELAYING );
_Watchdog_Initialize(
3000a068: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a06c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a070: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id;
3000a074: e5812068 str r2, [r1, #104] ; 0x68 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000a078: e581306c str r3, [r1, #108] ; 0x6c <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000a07c: e5810064 str r0, [r1, #100] ; 0x64 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a080: e5814054 str r4, [r1, #84] ; 0x54 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a084: e59f0034 ldr r0, [pc, #52] ; 3000a0c0 <rtems_task_wake_after+0x90><== NOT EXECUTED 3000a088: e2811048 add r1, r1, #72 ; 0x48 <== NOT EXECUTED 3000a08c: eb000bb5 bl 3000cf68 <_Watchdog_Insert> <== NOT EXECUTED
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
}
_Thread_Enable_dispatch();
3000a090: eb00081a bl 3000c100 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL; }
3000a094: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a098: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
3000a09c: e59f3020 ldr r3, [pc, #32] ; 3000a0c4 <rtems_task_wake_after+0x94> 3000a0a0: e1a0e00f mov lr, pc 3000a0a4: e593f00c ldr pc, [r3, #12]
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
}
_Thread_Enable_dispatch();
3000a0a8: eb000814 bl 3000c100 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL; }
3000a0ac: e3a00000 mov r0, #0
3000a0b0: e8bd8030 pop {r4, r5, pc}
3000b0ec <rtems_task_wake_when>:
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000b0ec: e59f30bc ldr r3, [pc, #188] ; 3000b1b0 <rtems_task_wake_when+0xc4>
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
3000b0f0: e92d40f0 push {r4, r5, r6, r7, lr}
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000b0f4: e5d33000 ldrb r3, [r3]
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
3000b0f8: e1a05000 mov r5, r0
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000b0fc: e3530000 cmp r3, #0
return RTEMS_NOT_DEFINED;
3000b100: 03a0000b moveq r0, #11
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000b104: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
3000b108: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3000b10c: 03a00009 moveq r0, #9
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
3000b110: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
3000b114: e3a04000 mov r4, #0 3000b118: e5854018 str r4, [r5, #24]
if ( !_TOD_Validate( time_buffer ) )
3000b11c: ebfffcfa bl 3000a50c <_TOD_Validate> 3000b120: e1500004 cmp r0, r4
return RTEMS_INVALID_CLOCK;
3000b124: 03a00014 moveq r0, #20
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
3000b128: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
3000b12c: e1a00005 mov r0, r5 3000b130: ebfffcca bl 3000a460 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
3000b134: e59f6078 ldr r6, [pc, #120] ; 3000b1b4 <rtems_task_wake_when+0xc8>
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
3000b138: e1a05000 mov r5, r0
if ( seconds <= _TOD_Seconds_since_epoch() )
3000b13c: e5963000 ldr r3, [r6] 3000b140: e1500003 cmp r0, r3
3000b144: 8a000001 bhi 3000b150 <rtems_task_wake_when+0x64>
return RTEMS_INVALID_CLOCK;
3000b148: e3a00014 mov r0, #20 <== NOT EXECUTED
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000b14c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000b150: e59f3060 ldr r3, [pc, #96] ; 3000b1b8 <rtems_task_wake_when+0xcc> 3000b154: e5932000 ldr r2, [r3] 3000b158: e2822001 add r2, r2, #1 3000b15c: e5832000 str r2, [r3]
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
3000b160: e59f7054 ldr r7, [pc, #84] ; 3000b1bc <rtems_task_wake_when+0xd0> 3000b164: e3a01010 mov r1, #16 3000b168: e5970004 ldr r0, [r7, #4] 3000b16c: eb000a57 bl 3000dad0 <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3000b170: e5971004 ldr r1, [r7, #4]
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
3000b174: e5962000 ldr r2, [r6]
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
_Watchdog_Initialize(
3000b178: e5913008 ldr r3, [r1, #8]
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
3000b17c: e0625005 rsb r5, r2, r5
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000b180: e59f2038 ldr r2, [pc, #56] ; 3000b1c0 <rtems_task_wake_when+0xd4>
the_watchdog->id = id;
3000b184: e5813068 str r3, [r1, #104] ; 0x68
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000b188: e5812064 str r2, [r1, #100] ; 0x64
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000b18c: e59f0030 ldr r0, [pc, #48] ; 3000b1c4 <rtems_task_wake_when+0xd8>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000b190: e5814050 str r4, [r1, #80] ; 0x50
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3000b194: e581406c str r4, [r1, #108] ; 0x6c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000b198: e5815054 str r5, [r1, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000b19c: e2811048 add r1, r1, #72 ; 0x48 3000b1a0: eb000bed bl 3000e15c <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
3000b1a4: eb000821 bl 3000d230 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b1a8: e1a00004 mov r0, r4 <== NOT EXECUTED
3000b1ac: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30009448 <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30009448: e3500009 cmp r0, #9 <== NOT EXECUTED 3000944c: 012fff1e bxeq lr <== NOT EXECUTED 30009450: da000010 ble 30009498 <rtems_termios_baud_to_index+0x50> <== NOT EXECUTED 30009454: e350000e cmp r0, #14 <== NOT EXECUTED 30009458: 012fff1e bxeq lr <== NOT EXECUTED 3000945c: da000018 ble 300094c4 <rtems_termios_baud_to_index+0x7c> <== NOT EXECUTED 30009460: e59f30d0 ldr r3, [pc, #208] ; 30009538 <rtems_termios_baud_to_index+0xf0><== NOT EXECUTED 30009464: 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;
30009468: 03a00011 moveq r0, #17 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
3000946c: 012fff1e bxeq lr <== NOT EXECUTED 30009470: da000026 ble 30009510 <rtems_termios_baud_to_index+0xc8> <== NOT EXECUTED 30009474: e59f30c0 ldr r3, [pc, #192] ; 3000953c <rtems_termios_baud_to_index+0xf4><== NOT EXECUTED 30009478: 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;
3000947c: 03a00012 moveq r0, #18 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30009480: 012fff1e bxeq lr <== NOT EXECUTED 30009484: e2833001 add r3, r3, #1 <== NOT EXECUTED 30009488: e1500003 cmp r0, r3 <== NOT EXECUTED 3000948c: 1a00001d bne 30009508 <rtems_termios_baud_to_index+0xc0> <== NOT EXECUTED
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;
case B460800: baud_index = 19; break;
30009490: e3a00013 mov r0, #19 <== NOT EXECUTED 30009494: e12fff1e bx lr <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30009498: e3500004 cmp r0, #4 <== NOT EXECUTED 3000949c: 012fff1e bxeq lr <== NOT EXECUTED 300094a0: ca000010 bgt 300094e8 <rtems_termios_baud_to_index+0xa0> <== NOT EXECUTED 300094a4: e3500001 cmp r0, #1 <== NOT EXECUTED 300094a8: 012fff1e bxeq lr <== NOT EXECUTED 300094ac: da00001e ble 3000952c <rtems_termios_baud_to_index+0xe4> <== NOT EXECUTED 300094b0: e3500002 cmp r0, #2 <== NOT EXECUTED 300094b4: 012fff1e bxeq lr <== NOT EXECUTED 300094b8: e3500003 cmp r0, #3 <== NOT EXECUTED 300094bc: 1a000011 bne 30009508 <rtems_termios_baud_to_index+0xc0> <== NOT EXECUTED 300094c0: e12fff1e bx lr <== NOT EXECUTED 300094c4: e350000b cmp r0, #11 <== NOT EXECUTED 300094c8: 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;
300094cc: b3a0000a movlt r0, #10 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
300094d0: b12fff1e bxlt lr <== NOT EXECUTED 300094d4: e350000c cmp r0, #12 <== NOT EXECUTED 300094d8: 012fff1e bxeq lr <== NOT EXECUTED 300094dc: e350000d cmp r0, #13 <== NOT EXECUTED 300094e0: 1a000008 bne 30009508 <rtems_termios_baud_to_index+0xc0> <== NOT EXECUTED 300094e4: e12fff1e bx lr <== NOT EXECUTED 300094e8: e3500006 cmp r0, #6 <== NOT EXECUTED 300094ec: 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;
300094f0: b3a00005 movlt r0, #5 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
300094f4: b12fff1e bxlt lr <== NOT EXECUTED 300094f8: e3500007 cmp r0, #7 <== NOT EXECUTED 300094fc: 012fff1e bxeq lr <== NOT EXECUTED 30009500: e3500008 cmp r0, #8 <== NOT EXECUTED 30009504: 012fff1e bxeq lr <== NOT EXECUTED
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
30009508: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return baud_index;
}
3000950c: e12fff1e bx lr <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30009510: e350000f cmp r0, #15 <== NOT EXECUTED 30009514: 012fff1e bxeq lr <== NOT EXECUTED 30009518: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000951c: e1500003 cmp r0, r3 <== NOT EXECUTED 30009520: 1afffff8 bne 30009508 <rtems_termios_baud_to_index+0xc0> <== 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;
30009524: e3a00010 mov r0, #16 <== NOT EXECUTED 30009528: e12fff1e bx lr <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
3000952c: e3500000 cmp r0, #0 <== NOT EXECUTED 30009530: 012fff1e bxeq lr <== NOT EXECUTED 30009534: eafffff3 b 30009508 <rtems_termios_baud_to_index+0xc0> <== NOT EXECUTED
30009540 <rtems_termios_baud_to_number>:
extern rtems_assoc_t termios_assoc_table[];
int32_t rtems_termios_baud_to_number(
int termios_baud
)
{
30009540: e92d4010 push {r4, lr} <== NOT EXECUTED
int baud;
baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud );
30009544: e1a01000 mov r1, r0 <== NOT EXECUTED
extern rtems_assoc_t termios_assoc_table[];
int32_t rtems_termios_baud_to_number(
int termios_baud
)
{
30009548: e1a04000 mov r4, r0 <== NOT EXECUTED
int baud;
baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud );
3000954c: e59f001c ldr r0, [pc, #28] ; 30009570 <rtems_termios_baud_to_number+0x30><== NOT EXECUTED 30009550: eb001cf5 bl 3001092c <rtems_assoc_local_by_remote> <== NOT EXECUTED
if ( baud == 0 && termios_baud != 0 )
30009554: e2703001 rsbs r3, r0, #1 <== NOT EXECUTED 30009558: 33a03000 movcc r3, #0 <== NOT EXECUTED 3000955c: e3540000 cmp r4, #0 <== NOT EXECUTED 30009560: 03a03000 moveq r3, #0 <== NOT EXECUTED 30009564: e3530000 cmp r3, #0 <== NOT EXECUTED
return -1;
return baud;
}
30009568: 13e00000 mvnne r0, #0 <== NOT EXECUTED
3000956c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30007af8 <rtems_termios_bufsize>:
int cbufsize,
int raw_input,
int raw_output
)
{
rtems_termios_cbufsize = cbufsize;
30007af8: e59f300c ldr r3, [pc, #12] ; 30007b0c <rtems_termios_bufsize+0x14><== NOT EXECUTED 30007afc: e5830008 str r0, [r3, #8] <== NOT EXECUTED
rtems_termios_raw_input_size = raw_input;
30007b00: e8830006 stm r3, {r1, r2} <== NOT EXECUTED
rtems_termios_raw_output_size = raw_output; return RTEMS_SUCCESSFUL; }
30007b04: e3a00000 mov r0, #0 <== NOT EXECUTED 30007b08: e12fff1e bx lr <== NOT EXECUTED
30007938 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
30007938: e92d4070 push {r4, r5, r6, lr}
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
3000793c: e59f51a4 ldr r5, [pc, #420] ; 30007ae8 <rtems_termios_close+0x1b0>
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
30007940: e5903000 ldr r3, [r0]
rtems_status_code sc;
sc = rtems_semaphore_obtain(
30007944: e3a01000 mov r1, #0
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
30007948: e1a06000 mov r6, r0
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
3000794c: e1a02001 mov r2, r1 30007950: e5950000 ldr r0, [r5]
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
30007954: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain(
30007958: eb00087d bl 30009b54 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3000795c: e3500000 cmp r0, #0
30007960: 1a00005f bne 30007ae4 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
30007964: e5943008 ldr r3, [r4, #8] 30007968: e2433001 sub r3, r3, #1 3000796c: e3530000 cmp r3, #0 30007970: e5843008 str r3, [r4, #8]
30007974: 1a00002f bne 30007a38 <rtems_termios_close+0x100>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
30007978: e59420cc ldr r2, [r4, #204] ; 0xcc 3000797c: e59f3168 ldr r3, [pc, #360] ; 30007aec <rtems_termios_close+0x1b4> 30007980: e0833282 add r3, r3, r2, lsl #5 30007984: e5931004 ldr r1, [r3, #4] 30007988: e3510000 cmp r1, #0
3000798c: 0a00003e beq 30007a8c <rtems_termios_close+0x154>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
30007990: e1a00004 mov r0, r4 <== NOT EXECUTED 30007994: e1a0e00f mov lr, pc <== NOT EXECUTED 30007998: e12fff11 bx r1 <== NOT EXECUTED
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3000799c: e59430b4 ldr r3, [r4, #180] ; 0xb4 <== NOT EXECUTED 300079a0: e3530002 cmp r3, #2 <== NOT EXECUTED 300079a4: 0a000044 beq 30007abc <rtems_termios_close+0x184> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
300079a8: e594309c ldr r3, [r4, #156] ; 0x9c 300079ac: e3530000 cmp r3, #0
(*tty->device.lastClose)(tty->major, tty->minor, arg);
300079b0: 1594000c ldrne r0, [r4, #12] 300079b4: 15941010 ldrne r1, [r4, #16] 300079b8: 11a02006 movne r2, r6 300079bc: 11a0e00f movne lr, pc 300079c0: 112fff13 bxne r3
if (tty->forw == NULL) {
300079c4: e5943000 ldr r3, [r4] 300079c8: e3530000 cmp r3, #0
300079cc: 0a000026 beq 30007a6c <rtems_termios_close+0x134>
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
300079d0: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 300079d4: e5832004 str r2, [r3, #4] <== NOT EXECUTED 300079d8: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED
}
if (tty->back == NULL) {
300079dc: e3520000 cmp r2, #0 <== NOT EXECUTED 300079e0: 0a00001b beq 30007a54 <rtems_termios_close+0x11c> <== NOT EXECUTED
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
300079e4: e5823000 str r3, [r2] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
300079e8: e5940014 ldr r0, [r4, #20] 300079ec: eb00082f bl 30009ab0 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
300079f0: e5940018 ldr r0, [r4, #24] 300079f4: eb00082d bl 30009ab0 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
300079f8: e594008c ldr r0, [r4, #140] ; 0x8c 300079fc: eb00082b bl 30009ab0 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
30007a00: e59430a0 ldr r3, [r4, #160] ; 0xa0 30007a04: e3530000 cmp r3, #0
30007a08: 0a00000e beq 30007a48 <rtems_termios_close+0x110>
30007a0c: e59430b4 ldr r3, [r4, #180] ; 0xb4 30007a10: e3530002 cmp r3, #2
30007a14: 0a00000b beq 30007a48 <rtems_termios_close+0x110>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
30007a18: e5940058 ldr r0, [r4, #88] ; 0x58 30007a1c: ebfffa9d bl 30006498 <free>
free (tty->rawOutBuf.theBuf);
30007a20: e594007c ldr r0, [r4, #124] ; 0x7c 30007a24: ebfffa9b bl 30006498 <free>
free (tty->cbuf);
30007a28: e594001c ldr r0, [r4, #28] 30007a2c: ebfffa99 bl 30006498 <free>
free (tty);
30007a30: e1a00004 mov r0, r4 30007a34: ebfffa97 bl 30006498 <free>
} rtems_semaphore_release (rtems_termios_ttyMutex);
30007a38: e5950000 ldr r0, [r5] 30007a3c: eb00088d bl 30009c78 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
30007a40: e3a00000 mov r0, #0
30007a44: e8bd8070 pop {r4, r5, r6, pc}
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
30007a48: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED 30007a4c: eb000817 bl 30009ab0 <rtems_semaphore_delete> <== NOT EXECUTED 30007a50: eafffff0 b 30007a18 <rtems_termios_close+0xe0> <== NOT EXECUTED
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
30007a54: e59f2094 ldr r2, [pc, #148] ; 30007af0 <rtems_termios_close+0x1b8>
if ( rtems_termios_ttyHead != NULL ) {
30007a58: e3530000 cmp r3, #0
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
30007a5c: e5823000 str r3, [r2]
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
30007a60: 13a02000 movne r2, #0 30007a64: 15832004 strne r2, [r3, #4] 30007a68: eaffffde b 300079e8 <rtems_termios_close+0xb0>
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
30007a6c: e5942004 ldr r2, [r4, #4] 30007a70: e59f107c ldr r1, [pc, #124] ; 30007af4 <rtems_termios_close+0x1bc>
if ( rtems_termios_ttyTail != NULL ) {
30007a74: e3520000 cmp r2, #0
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
30007a78: e5812000 str r2, [r1]
if ( rtems_termios_ttyTail != NULL ) {
30007a7c: 0afffff4 beq 30007a54 <rtems_termios_close+0x11c>
rtems_termios_ttyTail->forw = NULL;
30007a80: e5823000 str r3, [r2] <== NOT EXECUTED 30007a84: e5943000 ldr r3, [r4] <== NOT EXECUTED 30007a88: eaffffd5 b 300079e4 <rtems_termios_close+0xac> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30007a8c: e5940018 ldr r0, [r4, #24] 30007a90: e1a02001 mov r2, r1 30007a94: eb00082e bl 30009b54 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
30007a98: e3500000 cmp r0, #0
30007a9c: 1a000010 bne 30007ae4 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
30007aa0: e1a00004 mov r0, r4 30007aa4: ebfffe57 bl 30007408 <drainOutput>
rtems_semaphore_release (tty->osem);
30007aa8: e5940018 ldr r0, [r4, #24] 30007aac: eb000871 bl 30009c78 <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30007ab0: e59430b4 ldr r3, [r4, #180] ; 0xb4 30007ab4: e3530002 cmp r3, #2
30007ab8: 1affffba bne 300079a8 <rtems_termios_close+0x70>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
30007abc: e59400c4 ldr r0, [r4, #196] ; 0xc4 <== NOT EXECUTED 30007ac0: e3a01001 mov r1, #1 <== NOT EXECUTED 30007ac4: eb0006ff bl 300096c8 <rtems_event_send> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
30007ac8: e3500000 cmp r0, #0 <== NOT EXECUTED 30007acc: 1a000004 bne 30007ae4 <rtems_termios_close+0x1ac> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
30007ad0: e59400c8 ldr r0, [r4, #200] ; 0xc8 <== NOT EXECUTED 30007ad4: e3a01001 mov r1, #1 <== NOT EXECUTED 30007ad8: eb0006fa bl 300096c8 <rtems_event_send> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
30007adc: e3500000 cmp r0, #0 <== NOT EXECUTED 30007ae0: 0affffb0 beq 300079a8 <rtems_termios_close+0x70> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
30007ae4: eb0009c2 bl 3000a1f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
300090cc <rtems_termios_dequeue_characters>:
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
300090cc: e590c090 ldr ip, [r0, #144] ; 0x90 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
300090d0: e59020b4 ldr r2, [r0, #180] ; 0xb4 <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
300090d4: e08c1001 add r1, ip, r1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
300090d8: e3520002 cmp r2, #2 <== NOT EXECUTED
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
300090dc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
300090e0: e5801090 str r1, [r0, #144] ; 0x90 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
300090e4: 0a00000c beq 3000911c <rtems_termios_dequeue_characters+0x50><== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
300090e8: e59030cc ldr r3, [r0, #204] ; 0xcc <== NOT EXECUTED 300090ec: e3530005 cmp r3, #5 <== NOT EXECUTED 300090f0: 0a000001 beq 300090fc <rtems_termios_dequeue_characters+0x30><== NOT EXECUTED
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
300090f4: 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);
300090f8: eaffff55 b 30008e54 <rtems_termios_refill_transmitter> <== NOT EXECUTED
if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
300090fc: e59f303c ldr r3, [pc, #60] ; 30009140 <rtems_termios_dequeue_characters+0x74><== NOT EXECUTED 30009100: e59330b4 ldr r3, [r3, #180] ; 0xb4 <== NOT EXECUTED 30009104: e3530000 cmp r3, #0 <== NOT EXECUTED 30009108: 0a00000a beq 30009138 <rtems_termios_dequeue_characters+0x6c><== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
3000910c: e1a0e00f mov lr, pc <== NOT EXECUTED 30009110: e12fff13 bx r3 <== NOT EXECUTED
}
return 0; /* nothing to output in IRQ... */
30009114: e3a00000 mov r0, #0 <== NOT EXECUTED
30009118: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
3000911c: e59000c8 ldr r0, [r0, #200] ; 0xc8 <== NOT EXECUTED 30009120: e1a01002 mov r1, r2 <== NOT EXECUTED 30009124: eb000167 bl 300096c8 <rtems_event_send> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
30009128: e2503000 subs r3, r0, #0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
3000912c: 01a00003 moveq r0, r3 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
30009130: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
30009134: eb00042e bl 3000a1f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
30009138: e1a00003 mov r0, r3 <== NOT EXECUTED
}
return rtems_termios_refill_transmitter(tty);
}
3000913c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30008ad8 <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)
{
30008ad8: e92d4ff0 push {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) {
30008adc: e59030cc ldr r3, [r0, #204] ; 0xcc <== NOT EXECUTED 30008ae0: e59f72d8 ldr r7, [pc, #728] ; 30008dc0 <rtems_termios_enqueue_raw_characters+0x2e8><== 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)
{
30008ae4: e24dd008 sub sp, sp, #8 <== 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) {
30008ae8: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED 30008aec: 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)
{
30008af0: 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) {
30008af4: e3590000 cmp r9, #0 <== NOT EXECUTED
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
30008af8: e1a05001 mov r5, r1 <== NOT EXECUTED 30008afc: e1a06002 mov r6, r2 <== 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) {
30008b00: 0a00001e beq 30008b80 <rtems_termios_enqueue_raw_characters+0xa8><== NOT EXECUTED
while (len--) {
30008b04: e3520000 cmp r2, #0 <== NOT EXECUTED 30008b08: 0a00000b beq 30008b3c <rtems_termios_enqueue_raw_characters+0x64><== NOT EXECUTED 30008b0c: e3a08000 mov r8, #0 <== NOT EXECUTED 30008b10: ea000002 b 30008b20 <rtems_termios_enqueue_raw_characters+0x48><== NOT EXECUTED 30008b14: e59430cc ldr r3, [r4, #204] ; 0xcc <== NOT EXECUTED 30008b18: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED 30008b1c: e5939010 ldr r9, [r3, #16] <== NOT EXECUTED
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
30008b20: e7d50008 ldrb r0, [r5, r8] <== NOT EXECUTED 30008b24: e1a01004 mov r1, r4 <== NOT EXECUTED 30008b28: e2888001 add r8, r8, #1 <== NOT EXECUTED 30008b2c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008b30: e12fff19 bx r9 <== 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--) {
30008b34: e1580006 cmp r8, r6 <== NOT EXECUTED 30008b38: 1afffff5 bne 30008b14 <rtems_termios_enqueue_raw_characters+0x3c><== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008b3c: e594a0e4 ldr sl, [r4, #228] ; 0xe4 <== NOT EXECUTED 30008b40: e35a0000 cmp sl, #0 <== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
30008b44: 13a0a000 movne sl, #0 <== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008b48: 1a000009 bne 30008b74 <rtems_termios_enqueue_raw_characters+0x9c><== NOT EXECUTED 30008b4c: e59430dc ldr r3, [r4, #220] ; 0xdc <== NOT EXECUTED 30008b50: e3530000 cmp r3, #0 <== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
30008b54: 01a0a003 moveq sl, r3 <== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008b58: 0a000005 beq 30008b74 <rtems_termios_enqueue_raw_characters+0x9c><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
30008b5c: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 30008b60: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED 30008b64: e1a0e00f mov lr, pc <== NOT EXECUTED 30008b68: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
30008b6c: e3a03001 mov r3, #1 <== NOT EXECUTED 30008b70: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
30008b74: e1a0000a mov r0, sl <== NOT EXECUTED
30008b78: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30008b7c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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);
30008b80: e2803030 add r3, r0, #48 ; 0x30 <== NOT EXECUTED 30008b84: e58d3000 str r3, [sp] <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
30008b88: e3560000 cmp r6, #0 <== 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,
30008b8c: e280304a add r3, r0, #74 ; 0x4a <== NOT EXECUTED 30008b90: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 30008b94: e1a0b009 mov fp, r9 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
30008b98: 0a000042 beq 30008ca8 <rtems_termios_enqueue_raw_characters+0x1d0><== NOT EXECUTED
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
30008b9c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
30008ba0: e4d58001 ldrb r8, [r5], #1 <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
30008ba4: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED 30008ba8: 0a000005 beq 30008bc4 <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]) {
30008bac: e5d4304a ldrb r3, [r4, #74] ; 0x4a <== NOT EXECUTED 30008bb0: e1530008 cmp r3, r8 <== NOT EXECUTED 30008bb4: 0a000056 beq 30008d14 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
30008bb8: e5d43049 ldrb r3, [r4, #73] ; 0x49 <== NOT EXECUTED 30008bbc: e1530008 cmp r3, r8 <== NOT EXECUTED 30008bc0: 0a00003f beq 30008cc4 <rtems_termios_enqueue_raw_characters+0x1ec><== NOT EXECUTED
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
30008bc4: e3590000 cmp r9, #0 <== NOT EXECUTED 30008bc8: 1a000041 bne 30008cd4 <rtems_termios_enqueue_raw_characters+0x1fc><== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
30008bcc: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 30008bd0: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED 30008bd4: e2800001 add r0, r0, #1 <== NOT EXECUTED 30008bd8: eb00332e bl 30015898 <__umodsi3> <== NOT EXECUTED 30008bdc: e1a07000 mov r7, r0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008be0: e10fa000 mrs sl, CPSR <== NOT EXECUTED 30008be4: e38a3080 orr r3, sl, #128 ; 0x80 <== NOT EXECUTED 30008be8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
30008bec: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED 30008bf0: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
% tty->rawInBuf.Size) > tty->highwater) &&
30008bf4: 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)
30008bf8: e0630000 rsb r0, r3, r0 <== NOT EXECUTED
% tty->rawInBuf.Size) > tty->highwater) &&
30008bfc: e0800007 add r0, r0, r7 <== NOT EXECUTED 30008c00: eb003324 bl 30015898 <__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)
30008c04: e59430c0 ldr r3, [r4, #192] ; 0xc0 <== NOT EXECUTED 30008c08: e1500003 cmp r0, r3 <== NOT EXECUTED 30008c0c: 9a00000e bls 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
30008c10: 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) &&
30008c14: e3130001 tst r3, #1 <== NOT EXECUTED 30008c18: 1a00000b bne 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
30008c1c: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
30008c20: e59f319c ldr r3, [pc, #412] ; 30008dc4 <rtems_termios_enqueue_raw_characters+0x2ec><== NOT EXECUTED
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
30008c24: e3822001 orr r2, r2, #1 <== NOT EXECUTED 30008c28: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
30008c2c: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008c30: e0023003 and r3, r2, r3 <== NOT EXECUTED 30008c34: e3530b01 cmp r3, #1024 ; 0x400 <== NOT EXECUTED 30008c38: 0a000047 beq 30008d5c <rtems_termios_enqueue_raw_characters+0x284><== NOT EXECUTED
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
30008c3c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008c40: e2033f41 and r3, r3, #260 ; 0x104 <== NOT EXECUTED 30008c44: e3530c01 cmp r3, #256 ; 0x100 <== NOT EXECUTED 30008c48: 0a000052 beq 30008d98 <rtems_termios_enqueue_raw_characters+0x2c0><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30008c4c: e129f00a msr CPSR_fc, sl <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
30008c50: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED 30008c54: e1530007 cmp r3, r7 <== NOT EXECUTED
dropped++;
30008c58: 028bb001 addeq fp, fp, #1 <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
30008c5c: 0a00000e beq 30008c9c <rtems_termios_enqueue_raw_characters+0x1c4><== NOT EXECUTED
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
30008c60: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED 30008c64: e7c38007 strb r8, [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 )) {
30008c68: e59430e4 ldr r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
30008c6c: 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 )) {
30008c70: e3530000 cmp r3, #0 <== NOT EXECUTED 30008c74: 1a000008 bne 30008c9c <rtems_termios_enqueue_raw_characters+0x1c4><== NOT EXECUTED 30008c78: e59430dc ldr r3, [r4, #220] ; 0xdc <== NOT EXECUTED 30008c7c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008c80: 0a000005 beq 30008c9c <rtems_termios_enqueue_raw_characters+0x1c4><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
30008c84: e59d0000 ldr r0, [sp] <== NOT EXECUTED 30008c88: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED 30008c8c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008c90: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
30008c94: e3a03001 mov r3, #1 <== NOT EXECUTED 30008c98: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED 30008c9c: e2466001 sub r6, r6, #1 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
30008ca0: e3560000 cmp r6, #0 <== NOT EXECUTED 30008ca4: 1affffbc bne 30008b9c <rtems_termios_enqueue_raw_characters+0xc4><== NOT EXECUTED
}
}
}
}
tty->rawInBufDropped += dropped;
30008ca8: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
30008cac: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
}
}
}
}
tty->rawInBufDropped += dropped;
30008cb0: e083300b add r3, r3, fp <== NOT EXECUTED 30008cb4: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED 30008cb8: e1a0a00b mov sl, fp <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
30008cbc: eb0003ed bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
return dropped;
30008cc0: eaffffab b 30008b74 <rtems_termios_enqueue_raw_characters+0x9c><== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
30008cc4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== 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--) {
30008cc8: e3a09001 mov r9, #1 <== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
30008ccc: e3c33010 bic r3, r3, #16 <== NOT EXECUTED 30008cd0: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
30008cd4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008cd8: e2033030 and r3, r3, #48 ; 0x30 <== NOT EXECUTED 30008cdc: e3530020 cmp r3, #32 <== NOT EXECUTED 30008ce0: 1affffed bne 30008c9c <rtems_termios_enqueue_raw_characters+0x1c4><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008ce4: e10f7000 mrs r7, CPSR <== NOT EXECUTED 30008ce8: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 30008cec: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30008cf0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30008cf4: e5942094 ldr r2, [r4, #148] ; 0x94 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30008cf8: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30008cfc: e3520000 cmp r2, #0 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30008d00: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30008d04: 1a00000c bne 30008d3c <rtems_termios_enqueue_raw_characters+0x264><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30008d08: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
30008d0c: e2466001 sub r6, r6, #1 <== NOT EXECUTED 30008d10: eaffffe2 b 30008ca0 <rtems_termios_enqueue_raw_characters+0x1c8><== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
30008d14: e5d42049 ldrb r2, [r4, #73] ; 0x49 <== 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--) {
30008d18: e3a09001 mov r9, #1 <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
30008d1c: e1520003 cmp r2, r3 <== NOT EXECUTED
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
30008d20: 059430b8 ldreq r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
30008d24: 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;
30008d28: 02233010 eoreq r3, r3, #16 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
30008d2c: 13833010 orrne r3, r3, #16 <== 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;
30008d30: 058430b8 streq r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
30008d34: 158430b8 strne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008d38: eaffffe5 b 30008cd4 <rtems_termios_enqueue_raw_characters+0x1fc><== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
30008d3c: 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)(
30008d40: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED 30008d44: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008d48: e0811003 add r1, r1, r3 <== NOT EXECUTED 30008d4c: e3a02001 mov r2, #1 <== NOT EXECUTED 30008d50: e1a0e00f mov lr, pc <== NOT EXECUTED 30008d54: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 30008d58: eaffffea b 30008d08 <rtems_termios_enqueue_raw_characters+0x230><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
30008d5c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008d60: e3130020 tst r3, #32 <== NOT EXECUTED 30008d64: 1a000002 bne 30008d74 <rtems_termios_enqueue_raw_characters+0x29c><== NOT EXECUTED 30008d68: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED 30008d6c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008d70: 1affffb5 bne 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== 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;
30008d74: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
30008d78: 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;
30008d7c: e3833002 orr r3, r3, #2 <== NOT EXECUTED 30008d80: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
30008d84: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 30008d88: e3a02001 mov r2, #1 <== NOT EXECUTED 30008d8c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008d90: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 30008d94: eaffffac b 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
30008d98: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
30008d9c: e59430ac ldr r3, [r4, #172] ; 0xac <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
30008da0: e3822004 orr r2, r2, #4 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
30008da4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
30008da8: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
30008dac: 0affffa6 beq 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
30008db0: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008db4: e1a0e00f mov lr, pc <== NOT EXECUTED 30008db8: e12fff13 bx r3 <== NOT EXECUTED 30008dbc: eaffffa2 b 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
30007b10 <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;
30007b10: e5902000 ldr r2, [r0]
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
30007b14: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
30007b18: e5925034 ldr r5, [r2, #52] ; 0x34
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
30007b1c: e3a03000 mov r3, #0
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
30007b20: e1a04000 mov r4, r0
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
30007b24: e580300c str r3, [r0, #12]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30007b28: e1a01003 mov r1, r3 30007b2c: e5950018 ldr r0, [r5, #24] 30007b30: e1a02003 mov r2, r3
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
30007b34: e5947008 ldr r7, [r4, #8]
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30007b38: eb000805 bl 30009b54 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
30007b3c: e2506000 subs r6, r0, #0
30007b40: 1a00000e bne 30007b80 <rtems_termios_ioctl+0x70>
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
30007b44: e5943004 ldr r3, [r4, #4] 30007b48: e3530004 cmp r3, #4
30007b4c: 0a000006 beq 30007b6c <rtems_termios_ioctl+0x5c> 30007b50: 8a00000d bhi 30007b8c <rtems_termios_ioctl+0x7c>
30007b54: e3530002 cmp r3, #2
30007b58: 0a00001e beq 30007bd8 <rtems_termios_ioctl+0xc8>
30007b5c: 9a000085 bls 30007d78 <rtems_termios_ioctl+0x268>
if (tty->device.setAttributes)
(*tty->device.setAttributes)(tty->minor, &tty->termios);
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
30007b60: e1a00005 mov r0, r5 30007b64: ebfffe27 bl 30007408 <drainOutput>
break;
30007b68: ea000002 b 30007b78 <rtems_termios_ioctl+0x68>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
30007b6c: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
30007b70: e58520dc str r2, [r5, #220] ; 0xdc <== NOT EXECUTED
30007b74: e58530e0 str r3, [r5, #224] ; 0xe0 <== NOT EXECUTED
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
30007b78: e5950018 ldr r0, [r5, #24] 30007b7c: eb00083d bl 30009c78 <rtems_semaphore_release>
args->ioctl_return = sc;
30007b80: e584600c str r6, [r4, #12]
return sc; }
30007b84: e1a00006 mov r0, r6
30007b88: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
30007b8c: e59f2340 ldr r2, [pc, #832] ; 30007ed4 <rtems_termios_ioctl+0x3c4><== NOT EXECUTED 30007b90: e1530002 cmp r3, r2 <== NOT EXECUTED 30007b94: 0a00006b beq 30007d48 <rtems_termios_ioctl+0x238> <== NOT EXECUTED 30007b98: 8a000082 bhi 30007da8 <rtems_termios_ioctl+0x298> <== NOT EXECUTED 30007b9c: e3530005 cmp r3, #5 <== NOT EXECUTED 30007ba0: 0a0000a1 beq 30007e2c <rtems_termios_ioctl+0x31c> <== NOT EXECUTED
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
30007ba4: e59520cc ldr r2, [r5, #204] ; 0xcc <== NOT EXECUTED 30007ba8: e59f3328 ldr r3, [pc, #808] ; 30007ed8 <rtems_termios_ioctl+0x3c8><== NOT EXECUTED 30007bac: e0833282 add r3, r3, r2, lsl #5 <== NOT EXECUTED 30007bb0: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED 30007bb4: e3530000 cmp r3, #0 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
30007bb8: 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) {
30007bbc: 0affffed beq 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
30007bc0: e1a00005 mov r0, r5 <== NOT EXECUTED 30007bc4: e1a01004 mov r1, r4 <== NOT EXECUTED 30007bc8: e1a0e00f mov lr, pc <== NOT EXECUTED 30007bcc: e12fff13 bx r3 <== NOT EXECUTED 30007bd0: e1a06000 mov r6, r0 <== NOT EXECUTED 30007bd4: eaffffe7 b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
30007bd8: e594e008 ldr lr, [r4, #8] <== NOT EXECUTED
30007bdc: e2857030 add r7, r5, #48 ; 0x30 <== NOT EXECUTED
30007be0: e1a0c007 mov ip, r7 <== NOT EXECUTED
30007be4: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007be8: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30007bec: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007bf0: e8ac000f stmia ip!, {r0, r1, r2, r3} <== 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) &&
30007bf4: e59520b8 ldr r2, [r5, #184] ; 0xb8 <== NOT EXECUTED
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
30007bf8: e59e3000 ldr r3, [lr] <== 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) &&
30007bfc: e3120c02 tst r2, #512 ; 0x200 <== NOT EXECUTED
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
30007c00: 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) &&
30007c04: 0a000012 beq 30007c54 <rtems_termios_ioctl+0x144> <== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
30007c08: e5953030 ldr r3, [r5, #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) &&
30007c0c: e3130b01 tst r3, #1024 ; 0x400 <== NOT EXECUTED 30007c10: 1a00000f bne 30007c54 <rtems_termios_ioctl+0x144> <== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
30007c14: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c18: e3c33e21 bic r3, r3, #528 ; 0x210 <== NOT EXECUTED 30007c1c: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
30007c20: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c24: e3130020 tst r3, #32 <== NOT EXECUTED 30007c28: 0a000009 beq 30007c54 <rtems_termios_ioctl+0x144> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30007c2c: e10f8000 mrs r8, CPSR <== NOT EXECUTED 30007c30: e3883080 orr r3, r8, #128 ; 0x80 <== NOT EXECUTED 30007c34: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30007c38: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30007c3c: e5952094 ldr r2, [r5, #148] ; 0x94 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30007c40: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30007c44: e3520000 cmp r2, #0 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30007c48: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30007c4c: 1a000098 bne 30007eb4 <rtems_termios_ioctl+0x3a4> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007c50: e129f008 msr CPSR_fc, r8 <== 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)) {
30007c54: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c58: e3130b01 tst r3, #1024 ; 0x400 <== NOT EXECUTED 30007c5c: 0a000008 beq 30007c84 <rtems_termios_ioctl+0x174> <== NOT EXECUTED 30007c60: e5953030 ldr r3, [r5, #48] ; 0x30 <== NOT EXECUTED 30007c64: e3130a01 tst r3, #4096 ; 0x1000 <== NOT EXECUTED 30007c68: 1a000005 bne 30007c84 <rtems_termios_ioctl+0x174> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
30007c6c: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c70: e3c33b01 bic r3, r3, #1024 ; 0x400 <== NOT EXECUTED 30007c74: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
30007c78: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c7c: e3c33002 bic r3, r3, #2 <== NOT EXECUTED 30007c80: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
30007c84: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c88: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007c8c: 05952038 ldreq r2, [r5, #56] ; 0x38 <== NOT EXECUTED 30007c90: 0a000012 beq 30007ce0 <rtems_termios_ioctl+0x1d0> <== NOT EXECUTED 30007c94: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED 30007c98: e3520000 cmp r2, #0 <== NOT EXECUTED 30007c9c: ba000078 blt 30007e84 <rtems_termios_ioctl+0x374> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
30007ca0: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007ca4: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED 30007ca8: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
30007cac: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007cb0: e3130004 tst r3, #4 <== NOT EXECUTED 30007cb4: 0a000006 beq 30007cd4 <rtems_termios_ioctl+0x1c4> <== NOT EXECUTED 30007cb8: e59530b0 ldr r3, [r5, #176] ; 0xb0 <== NOT EXECUTED 30007cbc: e3530000 cmp r3, #0 <== NOT EXECUTED 30007cc0: 0a000003 beq 30007cd4 <rtems_termios_ioctl+0x1c4> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
30007cc4: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED 30007cc8: e1a0e00f mov lr, pc <== NOT EXECUTED 30007ccc: e12fff13 bx r3 <== NOT EXECUTED 30007cd0: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
30007cd4: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007cd8: e3c33004 bic r3, r3, #4 <== NOT EXECUTED 30007cdc: e58530b8 str r3, [r5, #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) {
30007ce0: e3520000 cmp r2, #0 <== NOT EXECUTED 30007ce4: ba000066 blt 30007e84 <rtems_termios_ioctl+0x374> <== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
30007ce8: e5953030 ldr r3, [r5, #48] ; 0x30 <== 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) {
30007cec: e595803c ldr r8, [r5, #60] ; 0x3c <== NOT EXECUTED
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
30007cf0: e3130a01 tst r3, #4096 ; 0x1000 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDXOF;
30007cf4: 159520b8 ldrne r2, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007cf8: 13822b01 orrne r2, r2, #1024 ; 0x400 <== NOT EXECUTED 30007cfc: 158520b8 strne r2, [r5, #184] ; 0xb8 <== NOT EXECUTED
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
30007d00: e3130b01 tst r3, #1024 ; 0x400 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDXON;
30007d04: 159530b8 ldrne r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007d08: 13833c02 orrne r3, r3, #512 ; 0x200 <== NOT EXECUTED 30007d0c: 158530b8 strne r3, [r5, #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) {
30007d10: e2188002 ands r8, r8, #2 <== NOT EXECUTED 30007d14: 0a000048 beq 30007e3c <rtems_termios_ioctl+0x32c> <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
30007d18: e3a03000 mov r3, #0 <== NOT EXECUTED 30007d1c: e585306c str r3, [r5, #108] ; 0x6c <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
30007d20: e5853070 str r3, [r5, #112] ; 0x70 <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007d24: e5853074 str r3, [r5, #116] ; 0x74 <== NOT EXECUTED
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
30007d28: e59530a8 ldr r3, [r5, #168] ; 0xa8 <== NOT EXECUTED 30007d2c: e3530000 cmp r3, #0 <== NOT EXECUTED 30007d30: 0affff90 beq 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
(*tty->device.setAttributes)(tty->minor, &tty->termios);
30007d34: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED 30007d38: e1a01007 mov r1, r7 <== NOT EXECUTED 30007d3c: e1a0e00f mov lr, pc <== NOT EXECUTED 30007d40: e12fff13 bx r3 <== NOT EXECUTED 30007d44: eaffff8b b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
30007d48: e5952060 ldr r2, [r5, #96] ; 0x60 <== NOT EXECUTED 30007d4c: e595305c ldr r3, [r5, #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;
30007d50: e5950020 ldr r0, [r5, #32] <== NOT EXECUTED
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
30007d54: e0523003 subs r3, r2, r3 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
30007d58: 45952064 ldrmi r2, [r5, #100] ; 0x64 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
30007d5c: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
30007d60: 40833002 addmi r3, r3, r2 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
30007d64: e5952024 ldr r2, [r5, #36] ; 0x24 <== NOT EXECUTED 30007d68: e0622000 rsb r2, r2, r0 <== NOT EXECUTED 30007d6c: e0823003 add r3, r2, r3 <== NOT EXECUTED 30007d70: e5813000 str r3, [r1] <== NOT EXECUTED
}
break;
30007d74: eaffff7f b 30007b78 <rtems_termios_ioctl+0x68> <== 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) {
30007d78: e3530001 cmp r3, #1 <== NOT EXECUTED 30007d7c: 1affff88 bne 30007ba4 <rtems_termios_ioctl+0x94> <== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
30007d80: e5947008 ldr r7, [r4, #8] <== NOT EXECUTED
30007d84: e285c030 add ip, r5, #48 ; 0x30 <== NOT EXECUTED
30007d88: e1a0e007 mov lr, r7 <== NOT EXECUTED
30007d8c: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30007d90: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007d94: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30007d98: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007d9c: e59c3000 ldr r3, [ip] <== NOT EXECUTED
30007da0: e58e3000 str r3, [lr] <== NOT EXECUTED
break;
30007da4: eaffff73 b 30007b78 <rtems_termios_ioctl+0x68> <== 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) {
30007da8: e59f212c ldr r2, [pc, #300] ; 30007edc <rtems_termios_ioctl+0x3cc><== NOT EXECUTED 30007dac: e1530002 cmp r3, r2 <== NOT EXECUTED 30007db0: 0a000019 beq 30007e1c <rtems_termios_ioctl+0x30c> <== NOT EXECUTED 30007db4: e2822105 add r2, r2, #1073741825 ; 0x40000001 <== NOT EXECUTED 30007db8: e1530002 cmp r3, r2 <== NOT EXECUTED 30007dbc: 1affff78 bne 30007ba4 <rtems_termios_ioctl+0x94> <== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
30007dc0: e59f7110 ldr r7, [pc, #272] ; 30007ed8 <rtems_termios_ioctl+0x3c8><== NOT EXECUTED 30007dc4: e59530cc ldr r3, [r5, #204] ; 0xcc <== NOT EXECUTED 30007dc8: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED 30007dcc: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30007dd0: e3530000 cmp r3, #0 <== NOT EXECUTED 30007dd4: 0a000003 beq 30007de8 <rtems_termios_ioctl+0x2d8> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
30007dd8: e1a00005 mov r0, r5 <== NOT EXECUTED 30007ddc: e1a0e00f mov lr, pc <== NOT EXECUTED 30007de0: e12fff13 bx r3 <== NOT EXECUTED 30007de4: e1a06000 mov r6, r0 <== NOT EXECUTED
}
tty->t_line=*(int*)(args->buffer);
30007de8: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30007dec: e5932000 ldr r2, [r3] <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
30007df0: e3a03000 mov r3, #0 <== NOT EXECUTED 30007df4: e58530d0 str r3, [r5, #208] ; 0xd0 <== NOT EXECUTED
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
30007df8: e7973282 ldr r3, [r7, r2, lsl #5] <== 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);
30007dfc: e58520cc str r2, [r5, #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) {
30007e00: e3530000 cmp r3, #0 <== NOT EXECUTED 30007e04: 0affff5b beq 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
30007e08: e1a00005 mov r0, r5 <== NOT EXECUTED 30007e0c: e1a0e00f mov lr, pc <== NOT EXECUTED 30007e10: e12fff13 bx r3 <== NOT EXECUTED 30007e14: e1a06000 mov r6, r0 <== NOT EXECUTED 30007e18: eaffff56 b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
30007e1c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30007e20: e59520cc ldr r2, [r5, #204] ; 0xcc <== NOT EXECUTED 30007e24: e5832000 str r2, [r3] <== NOT EXECUTED
break;
30007e28: eaffff52 b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
30007e2c: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
30007e30: e58520d4 str r2, [r5, #212] ; 0xd4 <== NOT EXECUTED
30007e34: e58530d8 str r3, [r5, #216] ; 0xd8 <== NOT EXECUTED
break;
30007e38: eaffff4e b 30007b78 <rtems_termios_ioctl+0x68> <== 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] *
30007e3c: e5d5a046 ldrb sl, [r5, #70] ; 0x46 <== NOT EXECUTED
rtems_clock_get_ticks_per_second() / 10;
30007e40: eb00059b bl 300094b4 <rtems_clock_get_ticks_per_second> <== 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] *
30007e44: e000009a mul r0, sl, r0 <== NOT EXECUTED
rtems_clock_get_ticks_per_second() / 10;
30007e48: e59f3090 ldr r3, [pc, #144] ; 30007ee0 <rtems_termios_ioctl+0x3d0><== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
30007e4c: e5d52046 ldrb r2, [r5, #70] ; 0x46 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
30007e50: e0831390 umull r1, r3, r0, r3 <== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
30007e54: e3520000 cmp r2, #0 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
30007e58: e1a031a3 lsr r3, r3, #3 <== 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] *
30007e5c: e5853054 str r3, [r5, #84] ; 0x54 <== NOT EXECUTED
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
30007e60: 0a00000b beq 30007e94 <rtems_termios_ioctl+0x384> <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
30007e64: e5d52047 ldrb r2, [r5, #71] ; 0x47 <== 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;
30007e68: e585806c str r8, [r5, #108] ; 0x6c <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007e6c: e3520000 cmp r2, #0 <== NOT EXECUTED 30007e70: 01a02003 moveq r2, r3 <== NOT EXECUTED 30007e74: 13a02000 movne r2, #0 <== NOT EXECUTED
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
30007e78: e5853070 str r3, [r5, #112] ; 0x70 <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007e7c: e5852074 str r2, [r5, #116] ; 0x74 <== NOT EXECUTED 30007e80: eaffffa8 b 30007d28 <rtems_termios_ioctl+0x218> <== 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) {
tty->flow_ctrl |= FL_MDRTS;
30007e84: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007e88: e3833c01 orr r3, r3, #256 ; 0x100 <== NOT EXECUTED 30007e8c: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007e90: eaffff94 b 30007ce8 <rtems_termios_ioctl+0x1d8> <== 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]) {
30007e94: e5d53047 ldrb r3, [r5, #71] ; 0x47 <== NOT EXECUTED 30007e98: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
30007e9c: 03a03001 moveq r3, #1 <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
30007ea0: 1585206c strne r2, [r5, #108] ; 0x6c <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
30007ea4: 15852070 strne r2, [r5, #112] ; 0x70 <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007ea8: 15852074 strne r2, [r5, #116] ; 0x74 <== NOT EXECUTED
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
30007eac: 0585306c streq r3, [r5, #108] ; 0x6c <== NOT EXECUTED 30007eb0: eaffff9c b 30007d28 <rtems_termios_ioctl+0x218> <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
30007eb4: e5953084 ldr r3, [r5, #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)(
30007eb8: e595107c ldr r1, [r5, #124] ; 0x7c <== NOT EXECUTED 30007ebc: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED 30007ec0: e0811003 add r1, r1, r3 <== NOT EXECUTED 30007ec4: e3a02001 mov r2, #1 <== NOT EXECUTED 30007ec8: e1a0e00f mov lr, pc <== NOT EXECUTED 30007ecc: e595f0a4 ldr pc, [r5, #164] ; 0xa4 <== NOT EXECUTED 30007ed0: eaffff5e b 30007c50 <rtems_termios_ioctl+0x140> <== NOT EXECUTED
300095bc <rtems_termios_number_to_baud>:
extern rtems_assoc_t termios_assoc_table[];
int rtems_termios_number_to_baud(
int32_t baud
)
{
300095bc: e92d4010 push {r4, lr} <== NOT EXECUTED
int termios_baud;
termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud );
300095c0: e1a01000 mov r1, r0 <== NOT EXECUTED
extern rtems_assoc_t termios_assoc_table[];
int rtems_termios_number_to_baud(
int32_t baud
)
{
300095c4: e1a04000 mov r4, r0 <== NOT EXECUTED
int termios_baud;
termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud );
300095c8: e59f001c ldr r0, [pc, #28] ; 300095ec <rtems_termios_number_to_baud+0x30><== NOT EXECUTED 300095cc: eb001d23 bl 30010a60 <rtems_assoc_remote_by_local> <== NOT EXECUTED
if ( termios_baud == 0 && baud != 0 )
300095d0: e2703001 rsbs r3, r0, #1 <== NOT EXECUTED 300095d4: 33a03000 movcc r3, #0 <== NOT EXECUTED 300095d8: e3540000 cmp r4, #0 <== NOT EXECUTED 300095dc: 03a03000 moveq r3, #0 <== NOT EXECUTED 300095e0: e3530000 cmp r3, #0 <== NOT EXECUTED
return -1;
return termios_baud;
}
300095e4: 13e00000 mvnne r0, #0 <== NOT EXECUTED
300095e8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30007484 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
30007484: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
30007488: e59f7468 ldr r7, [pc, #1128] ; 300078f8 <rtems_termios_open+0x474>
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
3000748c: e1a06001 mov r6, r1
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
30007490: e3a01000 mov r1, #0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
30007494: e24dd018 sub sp, sp, #24 30007498: e1a05000 mov r5, r0 3000749c: e1a08002 mov r8, r2
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
300074a0: e5970000 ldr r0, [r7] 300074a4: e1a02001 mov r2, r1
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
300074a8: e58d3010 str r3, [sp, #16]
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
300074ac: eb0009a8 bl 30009b54 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
300074b0: e250a000 subs sl, r0, #0
300074b4: 1a000021 bne 30007540 <rtems_termios_open+0xbc>
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
300074b8: e59fb43c ldr fp, [pc, #1084] ; 300078fc <rtems_termios_open+0x478> 300074bc: e59b9000 ldr r9, [fp] 300074c0: e3590000 cmp r9, #0
300074c4: 0a00002d beq 30007580 <rtems_termios_open+0xfc>
300074c8: e1a04009 mov r4, r9 300074cc: ea000002 b 300074dc <rtems_termios_open+0x58>
300074d0: e5944000 ldr r4, [r4] <== NOT EXECUTED 300074d4: e3540000 cmp r4, #0 <== NOT EXECUTED 300074d8: 0a000028 beq 30007580 <rtems_termios_open+0xfc> <== NOT EXECUTED
if ((tty->major == major) && (tty->minor == minor))
300074dc: e594300c ldr r3, [r4, #12] 300074e0: e1530005 cmp r3, r5
300074e4: 1afffff9 bne 300074d0 <rtems_termios_open+0x4c>
300074e8: e5943010 ldr r3, [r4, #16] 300074ec: e1530006 cmp r3, r6
300074f0: 1afffff6 bne 300074d0 <rtems_termios_open+0x4c>
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
if (!tty->refcount++) {
300074f4: e5943008 ldr r3, [r4, #8]
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
300074f8: e5981000 ldr r1, [r8]
if (!tty->refcount++) {
300074fc: e2832001 add r2, r3, #1 30007500: e3530000 cmp r3, #0
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
30007504: e5814034 str r4, [r1, #52] ; 0x34
if (!tty->refcount++) {
30007508: e5842008 str r2, [r4, #8]
3000750c: 1a000009 bne 30007538 <rtems_termios_open+0xb4>
if (tty->device.firstOpen)
30007510: e5943098 ldr r3, [r4, #152] ; 0x98 30007514: e3530000 cmp r3, #0
(*tty->device.firstOpen)(major, minor, arg);
30007518: 11a00005 movne r0, r5 3000751c: 11a01006 movne r1, r6 30007520: 11a02008 movne r2, r8 30007524: 11a0e00f movne lr, pc 30007528: 112fff13 bxne r3
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3000752c: e59430b4 ldr r3, [r4, #180] ; 0xb4 30007530: e3530002 cmp r3, #2
30007534: 0a000004 beq 3000754c <rtems_termios_open+0xc8>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
30007538: e5970000 ldr r0, [r7] 3000753c: eb0009cd bl 30009c78 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
30007540: e1a0000a mov r0, sl
30007544: e28dd018 add sp, sp, #24
30007548: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
3000754c: e59400c4 ldr r0, [r4, #196] ; 0xc4 <== NOT EXECUTED 30007550: e59f13a8 ldr r1, [pc, #936] ; 30007900 <rtems_termios_open+0x47c><== NOT EXECUTED 30007554: e1a02004 mov r2, r4 <== NOT EXECUTED 30007558: eb000a9a bl 30009fc8 <rtems_task_start> <== NOT EXECUTED
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
3000755c: e3500000 cmp r0, #0 <== NOT EXECUTED 30007560: 1a0000ca bne 30007890 <rtems_termios_open+0x40c> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
30007564: e59400c8 ldr r0, [r4, #200] ; 0xc8 <== NOT EXECUTED 30007568: e59f1394 ldr r1, [pc, #916] ; 30007904 <rtems_termios_open+0x480><== NOT EXECUTED 3000756c: e1a02004 mov r2, r4 <== NOT EXECUTED 30007570: eb000a94 bl 30009fc8 <rtems_task_start> <== NOT EXECUTED
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
30007574: e3500000 cmp r0, #0 <== NOT EXECUTED 30007578: 0affffee beq 30007538 <rtems_termios_open+0xb4> <== NOT EXECUTED 3000757c: ea0000c3 b 30007890 <rtems_termios_open+0x40c> <== NOT EXECUTED
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
30007580: e3a00001 mov r0, #1 30007584: e3a010e8 mov r1, #232 ; 0xe8 30007588: ebfffb55 bl 300062e4 <calloc>
if (tty == NULL) {
3000758c: e3500000 cmp r0, #0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
30007590: e58d0014 str r0, [sp, #20] 30007594: e1a04000 mov r4, r0
if (tty == NULL) {
30007598: 0a0000a8 beq 30007840 <rtems_termios_open+0x3bc>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
3000759c: e59f0364 ldr r0, [pc, #868] ; 30007908 <rtems_termios_open+0x484> 300075a0: e59d1014 ldr r1, [sp, #20] 300075a4: e5903000 ldr r3, [r0] 300075a8: e5813064 str r3, [r1, #100] ; 0x64
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
300075ac: e5910064 ldr r0, [r1, #100] ; 0x64 300075b0: ebfffc92 bl 30006800 <malloc> 300075b4: e59d2014 ldr r2, [sp, #20]
if (tty->rawInBuf.theBuf == NULL) {
300075b8: e3500000 cmp r0, #0
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
300075bc: e1a03000 mov r3, r0 300075c0: e5820058 str r0, [r2, #88] ; 0x58
if (tty->rawInBuf.theBuf == NULL) {
300075c4: 0a0000a1 beq 30007850 <rtems_termios_open+0x3cc>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
300075c8: e59fe338 ldr lr, [pc, #824] ; 30007908 <rtems_termios_open+0x484> 300075cc: e59d0014 ldr r0, [sp, #20] 300075d0: e59e2004 ldr r2, [lr, #4] 300075d4: e5802088 str r2, [r0, #136] ; 0x88
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
300075d8: e5900088 ldr r0, [r0, #136] ; 0x88 300075dc: e58d3008 str r3, [sp, #8] 300075e0: ebfffc86 bl 30006800 <malloc> 300075e4: e59de014 ldr lr, [sp, #20]
if (tty->rawOutBuf.theBuf == NULL) {
300075e8: e3500000 cmp r0, #0
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
300075ec: e1a02000 mov r2, r0 300075f0: e58e007c str r0, [lr, #124] ; 0x7c
if (tty->rawOutBuf.theBuf == NULL) {
300075f4: e59d3008 ldr r3, [sp, #8]
300075f8: 0a00008c beq 30007830 <rtems_termios_open+0x3ac>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
300075fc: e59f1304 ldr r1, [pc, #772] ; 30007908 <rtems_termios_open+0x484> 30007600: e5910008 ldr r0, [r1, #8] 30007604: e58d200c str r2, [sp, #12] 30007608: e58d3008 str r3, [sp, #8] 3000760c: ebfffc7b bl 30006800 <malloc> 30007610: e59de014 ldr lr, [sp, #20]
if (tty->cbuf == NULL) {
30007614: e3500000 cmp r0, #0
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
30007618: e58e001c str r0, [lr, #28]
if (tty->cbuf == NULL) {
3000761c: e59d200c ldr r2, [sp, #12]
30007620: 0a00007f beq 30007824 <rtems_termios_open+0x3a0>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
30007624: e59d0014 ldr r0, [sp, #20] 30007628: e3a03000 mov r3, #0
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
3000762c: e5803004 str r3, [r0, #4]
if (rtems_termios_ttyHead != NULL)
30007630: e1590003 cmp r9, r3
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
30007634: e58030d4 str r3, [r0, #212] ; 0xd4
tty->tty_snd.sw_arg = NULL;
30007638: e58030d8 str r3, [r0, #216] ; 0xd8
tty->tty_rcv.sw_pfn = NULL;
3000763c: e58030dc str r3, [r0, #220] ; 0xdc
tty->tty_rcv.sw_arg = NULL;
30007640: e58030e0 str r3, [r0, #224] ; 0xe0
tty->tty_rcvwakeup = 0;
30007644: e58030e4 str r3, [r0, #228] ; 0xe4
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
30007648: e59f32bc ldr r3, [pc, #700] ; 3000790c <rtems_termios_open+0x488>
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
3000764c: 15890004 strne r0, [r9, #4]
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
30007650: e5932000 ldr r2, [r3]
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
30007654: e59d1014 ldr r1, [sp, #20]
if (rtems_termios_ttyTail == NULL)
30007658: e3520000 cmp r2, #0
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
3000765c: e59f22a4 ldr r2, [pc, #676] ; 30007908 <rtems_termios_open+0x484>
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
30007660: 05831000 streq r1, [r3]
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
30007664: e5809000 str r9, [r0]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
30007668: e5d2300c ldrb r3, [r2, #12]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
3000766c: e59de014 ldr lr, [sp, #20] 30007670: e59f0298 ldr r0, [pc, #664] ; 30007910 <rtems_termios_open+0x48c>
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
30007674: e58b1000 str r1, [fp]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
30007678: e28ec014 add ip, lr, #20 3000767c: e1830000 orr r0, r3, r0
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
30007680: e58e6010 str r6, [lr, #16]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
30007684: e3a03000 mov r3, #0
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
tty->major = major;
30007688: e58e500c str r5, [lr, #12]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
3000768c: e3a01001 mov r1, #1 30007690: e3a02054 mov r2, #84 ; 0x54 30007694: e58dc000 str ip, [sp] 30007698: eb000893 bl 300098ec <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)
3000769c: e2503000 subs r3, r0, #0
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
300076a0: e59f9260 ldr r9, [pc, #608] ; 30007908 <rtems_termios_open+0x484>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
300076a4: 1a000079 bne 30007890 <rtems_termios_open+0x40c>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
300076a8: e5d9200c ldrb r2, [r9, #12]
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
300076ac: e59d1014 ldr r1, [sp, #20] 300076b0: e59f025c ldr r0, [pc, #604] ; 30007914 <rtems_termios_open+0x490> 300076b4: e281c018 add ip, r1, #24 300076b8: e1820000 orr r0, r2, r0 300076bc: e3a01001 mov r1, #1 300076c0: e3a02054 mov r2, #84 ; 0x54 300076c4: e58dc000 str ip, [sp] 300076c8: eb000887 bl 300098ec <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)
300076cc: e2501000 subs r1, r0, #0
300076d0: 1a00006e bne 30007890 <rtems_termios_open+0x40c>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
300076d4: e5d9300c ldrb r3, [r9, #12]
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
300076d8: e59d2014 ldr r2, [sp, #20] 300076dc: e59f0234 ldr r0, [pc, #564] ; 30007918 <rtems_termios_open+0x494> 300076e0: e282c08c add ip, r2, #140 ; 0x8c 300076e4: e1830000 orr r0, r3, r0 300076e8: e3a02020 mov r2, #32 300076ec: e1a03001 mov r3, r1 300076f0: e58dc000 str ip, [sp] 300076f4: eb00087c bl 300098ec <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)
300076f8: e250b000 subs fp, r0, #0
300076fc: 1a000063 bne 30007890 <rtems_termios_open+0x40c>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
30007700: e59d3014 ldr r3, [sp, #20]
30007704: e59dc010 ldr ip, [sp, #16]
30007708: e283e098 add lr, r3, #152 ; 0x98
3000770c: e8bc000f ldm ip!, {r0, r1, r2, r3}
30007710: e8ae000f stmia lr!, {r0, r1, r2, r3}
30007714: e89c000f ldm ip, {r0, r1, r2, r3}
30007718: e88e000f stm lr, {r0, r1, r2, r3}
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3000771c: e59de014 ldr lr, [sp, #20] 30007720: e59e30b4 ldr r3, [lr, #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;
30007724: e58eb094 str fp, [lr, #148] ; 0x94
tty->device = *callbacks;
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30007728: e3530002 cmp r3, #2
3000772c: 0a000058 beq 30007894 <rtems_termios_open+0x410>
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
30007730: e59d2014 ldr r2, [sp, #20] 30007734: e59230a0 ldr r3, [r2, #160] ; 0xa0 30007738: e3530000 cmp r3, #0
3000773c: 0a000046 beq 3000785c <rtems_termios_open+0x3d8>
30007740: e59230b4 ldr r3, [r2, #180] ; 0xb4 30007744: e3530002 cmp r3, #2
30007748: 0a000043 beq 3000785c <rtems_termios_open+0x3d8>
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;
3000774c: e59de014 ldr lr, [sp, #20]
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';
30007750: 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;
30007754: e58e30b8 str r3, [lr, #184] ; 0xb8
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
30007758: e59f01a8 ldr r0, [pc, #424] ; 30007908 <rtems_termios_open+0x484>
/* 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;
3000775c: e59ec064 ldr ip, [lr, #100] ; 0x64
tty->highwater = tty->rawInBuf.Size * 3/4;
30007760: e59e1064 ldr r1, [lr, #100] ; 0x64
/*
* Bump name characer
*/
if (c++ == 'z')
30007764: e5d0200c ldrb r2, [r0, #12]
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
30007768: e0811081 add r1, r1, r1, lsl #1
/*
* Bump name characer
*/
if (c++ == 'z')
3000776c: e352007a cmp r2, #122 ; 0x7a
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
30007770: e1a00121 lsr r0, r1, #2
/*
* Bump name characer
*/
if (c++ == 'z')
30007774: e2821001 add r1, r2, #1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
30007778: e59f219c ldr r2, [pc, #412] ; 3000791c <rtems_termios_open+0x498>
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';
3000777c: e5ce304c strb r3, [lr, #76] ; 0x4c
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
30007780: e58e2030 str r2, [lr, #48] ; 0x30
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
30007784: e59f2194 ldr r2, [pc, #404] ; 30007920 <rtems_termios_open+0x49c>
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';
tty->termios.c_cc[VEOL2] = '\000';
30007788: e5ce3051 strb r3, [lr, #81] ; 0x51
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
3000778c: e58e2034 str r2, [lr, #52] ; 0x34
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
30007790: e59f218c ldr r2, [pc, #396] ; 30007924 <rtems_termios_open+0x4a0>
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';
30007794: e3a03011 mov r3, #17
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
30007798: e58e2038 str r2, [lr, #56] ; 0x38
tty->termios.c_lflag =
3000779c: e59f2184 ldr r2, [pc, #388] ; 30007928 <rtems_termios_open+0x4a4>
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';
300077a0: e5ce3049 strb r3, [lr, #73] ; 0x49
* 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 =
300077a4: e58e203c str r2, [lr, #60] ; 0x3c
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';
300077a8: e3a03013 mov r3, #19
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
300077ac: e3a02003 mov r2, #3 300077b0: e5ce2041 strb r2, [lr, #65] ; 0x41
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
300077b4: e5ce304a strb r3, [lr, #74] ; 0x4a
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
300077b8: e3a0201c mov r2, #28
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
300077bc: e3a0301a mov r3, #26
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
300077c0: e5ce2042 strb r2, [lr, #66] ; 0x42
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
300077c4: e5ce304b strb r3, [lr, #75] ; 0x4b
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
300077c8: e3a0207f mov r2, #127 ; 0x7f
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
300077cc: e3a03012 mov r3, #18
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
300077d0: e5ce2043 strb r2, [lr, #67] ; 0x43
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
300077d4: e5ce304d strb r3, [lr, #77] ; 0x4d
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
300077d8: e3a02015 mov r2, #21
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
300077dc: e3a0300f mov r3, #15
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
300077e0: e5ce2044 strb r2, [lr, #68] ; 0x44
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
300077e4: e5ce304e strb r3, [lr, #78] ; 0x4e
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
300077e8: e3a02004 mov r2, #4
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
300077ec: e3a03017 mov r3, #23
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
300077f0: e5ce2045 strb r2, [lr, #69] ; 0x45
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
300077f4: e5ce304f strb r3, [lr, #79] ; 0x4f
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
300077f8: e59f2108 ldr r2, [pc, #264] ; 30007908 <rtems_termios_open+0x484>
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';
300077fc: e3a03016 mov r3, #22 30007800: e5ce3050 strb r3, [lr, #80] ; 0x50
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
30007804: 059f30fc ldreq r3, [pc, #252] ; 30007908 <rtems_termios_open+0x484>
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
30007808: e5c2100c strb r1, [r2, #12]
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
3000780c: e1a0c0ac lsr ip, ip, #1
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
30007810: 03a02061 moveq r2, #97 ; 0x61
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
30007814: e58ec0bc str ip, [lr, #188] ; 0xbc
tty->highwater = tty->rawInBuf.Size * 3/4;
30007818: e58e00c0 str r0, [lr, #192] ; 0xc0
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
3000781c: 05c3200c strbeq r2, [r3, #12] 30007820: eaffff33 b 300074f4 <rtems_termios_open+0x70>
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
30007824: e1a00002 mov r0, r2 <== NOT EXECUTED 30007828: ebfffb1a bl 30006498 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
3000782c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30007830: e1a00003 mov r0, r3 <== NOT EXECUTED 30007834: ebfffb17 bl 30006498 <free> <== NOT EXECUTED
free(tty);
30007838: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED 3000783c: ebfffb15 bl 30006498 <free> <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
30007840: e5970000 ldr r0, [r7] <== NOT EXECUTED 30007844: eb00090b bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
30007848: e3a0a01a mov sl, #26 <== NOT EXECUTED 3000784c: eaffff3b b 30007540 <rtems_termios_open+0xbc> <== NOT EXECUTED
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
30007850: e1a00002 mov r0, r2 <== NOT EXECUTED 30007854: ebfffb0f bl 30006498 <free> <== NOT EXECUTED 30007858: eafffff8 b 30007840 <rtems_termios_open+0x3bc> <== NOT EXECUTED
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
3000785c: e59fe0a4 ldr lr, [pc, #164] ; 30007908 <rtems_termios_open+0x484><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
30007860: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
rtems_build_name ('T', 'R', 'r', c),
30007864: e5de300c ldrb r3, [lr, #12] <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
30007868: e59f00bc ldr r0, [pc, #188] ; 3000792c <rtems_termios_open+0x4a8><== NOT EXECUTED 3000786c: e3a01000 mov r1, #0 <== NOT EXECUTED 30007870: e282c068 add ip, r2, #104 ; 0x68 <== NOT EXECUTED 30007874: e1830000 orr r0, r3, r0 <== NOT EXECUTED 30007878: e3a02024 mov r2, #36 ; 0x24 <== NOT EXECUTED 3000787c: e1a03001 mov r3, r1 <== NOT EXECUTED 30007880: e58dc000 str ip, [sp] <== NOT EXECUTED 30007884: eb000818 bl 300098ec <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)
30007888: e3500000 cmp r0, #0 <== NOT EXECUTED 3000788c: 0affffae beq 3000774c <rtems_termios_open+0x2c8> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
30007890: eb000a57 bl 3000a1f4 <rtems_fatal_error_occurred>
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
30007894: e5d9300c ldrb r3, [r9, #12] <== NOT EXECUTED
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
30007898: e59f0090 ldr r0, [pc, #144] ; 30007930 <rtems_termios_open+0x4ac><== NOT EXECUTED
3000789c: e28ec0c8 add ip, lr, #200 ; 0xc8 <== NOT EXECUTED
300078a0: e1830000 orr r0, r3, r0 <== NOT EXECUTED
300078a4: e3a0100a mov r1, #10 <== NOT EXECUTED
300078a8: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED
300078ac: e3a03c05 mov r3, #1280 ; 0x500 <== NOT EXECUTED
300078b0: e88d1800 stm sp, {fp, ip} <== NOT EXECUTED
300078b4: eb000919 bl 30009d20 <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)
300078b8: e250e000 subs lr, r0, #0 <== NOT EXECUTED 300078bc: 1afffff3 bne 30007890 <rtems_termios_open+0x40c> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
300078c0: e5d9300c ldrb r3, [r9, #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 (
300078c4: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 300078c8: e59f0064 ldr r0, [pc, #100] ; 30007934 <rtems_termios_open+0x4b0><== NOT EXECUTED 300078cc: e281c0c4 add ip, r1, #196 ; 0xc4 <== NOT EXECUTED 300078d0: e1830000 orr r0, r3, r0 <== NOT EXECUTED 300078d4: e3a01009 mov r1, #9 <== NOT EXECUTED 300078d8: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED 300078dc: e3a03c05 mov r3, #1280 ; 0x500 <== NOT EXECUTED 300078e0: e58de000 str lr, [sp] <== NOT EXECUTED 300078e4: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 300078e8: eb00090c bl 30009d20 <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)
300078ec: e3500000 cmp r0, #0 <== NOT EXECUTED 300078f0: 0affff8e beq 30007730 <rtems_termios_open+0x2ac> <== NOT EXECUTED 300078f4: eaffffe5 b 30007890 <rtems_termios_open+0x40c> <== NOT EXECUTED
30007ee4 <rtems_termios_puts>:
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30007ee4: e59230b4 ldr r3, [r2, #180] ; 0xb4
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
30007ee8: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30007eec: e3530000 cmp r3, #0
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
30007ef0: e1a04002 mov r4, r2 30007ef4: e1a0a000 mov sl, r0 30007ef8: e1a08001 mov r8, r1
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30007efc: 0a000038 beq 30007fe4 <rtems_termios_puts+0x100>
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
30007f00: e3510000 cmp r1, #0 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
30007f04: e5927080 ldr r7, [r2, #128] ; 0x80 <== NOT EXECUTED
while (len) {
30007f08: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
30007f0c: e3a06002 mov r6, #2 <== 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;
30007f10: e3a09001 mov r9, #1 <== NOT EXECUTED
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
30007f14: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED 30007f18: e2870001 add r0, r7, #1 <== NOT EXECUTED 30007f1c: eb00365d bl 30015898 <__umodsi3> <== NOT EXECUTED 30007f20: e1a07000 mov r7, r0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30007f24: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30007f28: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30007f2c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
30007f30: e5945084 ldr r5, [r4, #132] ; 0x84 <== NOT EXECUTED 30007f34: e1550000 cmp r5, r0 <== NOT EXECUTED 30007f38: 1a00000d bne 30007f74 <rtems_termios_puts+0x90> <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
30007f3c: e5846094 str r6, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007f40: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
30007f44: e3a01000 mov r1, #0 <== NOT EXECUTED 30007f48: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED 30007f4c: e1a02001 mov r2, r1 <== NOT EXECUTED 30007f50: eb0006ff bl 30009b54 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
30007f54: e3500000 cmp r0, #0 <== NOT EXECUTED 30007f58: 1a000027 bne 30007ffc <rtems_termios_puts+0x118> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30007f5c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30007f60: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30007f64: e129f002 msr CPSR_fc, r2 <== 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) {
30007f68: e5942084 ldr r2, [r4, #132] ; 0x84 <== NOT EXECUTED 30007f6c: e1520005 cmp r2, r5 <== NOT EXECUTED 30007f70: 0afffff1 beq 30007f3c <rtems_termios_puts+0x58> <== 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++;
30007f74: e4da1001 ldrb r1, [sl], #1 <== NOT EXECUTED
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
30007f78: e1a05003 mov r5, r3 <== 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++;
30007f7c: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED 30007f80: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED 30007f84: e7c21003 strb r1, [r2, r3] <== NOT EXECUTED
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
30007f88: 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;
30007f8c: e5847080 str r7, [r4, #128] ; 0x80 <== NOT EXECUTED
if (tty->rawOutBufState == rob_idle) {
30007f90: e3530000 cmp r3, #0 <== NOT EXECUTED 30007f94: 1a000006 bne 30007fb4 <rtems_termios_puts+0xd0> <== NOT EXECUTED
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
30007f98: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007f9c: e3130010 tst r3, #16 <== NOT EXECUTED 30007fa0: 0a000007 beq 30007fc4 <rtems_termios_puts+0xe0> <== 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;
30007fa4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007fa8: e3833020 orr r3, r3, #32 <== NOT EXECUTED 30007fac: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
30007fb0: e5849094 str r9, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007fb4: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
30007fb8: e2588001 subs r8, r8, #1 <== NOT EXECUTED
30007fbc: 1affffd4 bne 30007f14 <rtems_termios_puts+0x30> <== NOT EXECUTED
30007fc0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
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,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
30007fc4: 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,
30007fc8: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED 30007fcc: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30007fd0: e0811003 add r1, r1, r3 <== NOT EXECUTED 30007fd4: e3a02001 mov r2, #1 <== NOT EXECUTED 30007fd8: e1a0e00f mov lr, pc <== NOT EXECUTED 30007fdc: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 30007fe0: eafffff2 b 30007fb0 <rtems_termios_puts+0xcc> <== NOT EXECUTED
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
30007fe4: e5920010 ldr r0, [r2, #16] 30007fe8: e1a0100a mov r1, sl 30007fec: e1a02008 mov r2, r8 30007ff0: e1a0e00f mov lr, pc 30007ff4: e594f0a4 ldr pc, [r4, #164] ; 0xa4
return;
30007ff8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
30007ffc: eb00087c bl 3000a1f4 <rtems_fatal_error_occurred> <== NOT EXECUTED
30008718 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
30008718: e92d4ff0 push {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;
3000871c: e5903000 ldr r3, [r0] <== 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);
30008720: 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;
30008724: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
30008728: e1a09000 mov r9, r0 <== NOT EXECUTED 3000872c: e24dd008 sub sp, sp, #8 <== 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);
30008730: e1a02001 mov r2, r1 <== NOT EXECUTED 30008734: e5940014 ldr r0, [r4, #20] <== 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;
30008738: e5998010 ldr r8, [r9, #16] <== NOT EXECUTED
char *buffer = args->buffer;
3000873c: e599a00c ldr sl, [r9, #12] <== NOT EXECUTED
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30008740: eb000503 bl 30009b54 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
30008744: e3500000 cmp r0, #0 <== NOT EXECUTED 30008748: e58d0000 str r0, [sp] <== NOT EXECUTED 3000874c: 1a00000e bne 3000878c <rtems_termios_read+0x74> <== NOT EXECUTED
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
30008750: e59420cc ldr r2, [r4, #204] ; 0xcc <== NOT EXECUTED 30008754: e59f3364 ldr r3, [pc, #868] ; 30008ac0 <rtems_termios_read+0x3a8><== NOT EXECUTED 30008758: e0833282 add r3, r3, r2, lsl #5 <== NOT EXECUTED 3000875c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30008760: e3530000 cmp r3, #0 <== NOT EXECUTED 30008764: 0a00000b beq 30008798 <rtems_termios_read+0x80> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
30008768: e1a00004 mov r0, r4 <== NOT EXECUTED 3000876c: e1a01009 mov r1, r9 <== NOT EXECUTED 30008770: e1a0e00f mov lr, pc <== NOT EXECUTED 30008774: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
30008778: e3a03000 mov r3, #0 <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
3000877c: e58d0000 str r0, [sp] <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
30008780: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
30008784: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED 30008788: eb00053a bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
} args->bytes_moved = args->count - count; tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; }
3000878c: e59d0000 ldr r0, [sp] <== NOT EXECUTED
30008790: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30008794: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
30008798: e5942024 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED 3000879c: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 300087a0: e1520003 cmp r2, r3 <== NOT EXECUTED 300087a4: 0a000018 beq 3000880c <rtems_termios_read+0xf4> <== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
300087a8: e3580000 cmp r8, #0 <== NOT EXECUTED 300087ac: 0a00000e beq 300087ec <rtems_termios_read+0xd4> <== NOT EXECUTED 300087b0: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 300087b4: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED 300087b8: e1530002 cmp r3, r2 <== NOT EXECUTED 300087bc: ba000003 blt 300087d0 <rtems_termios_read+0xb8> <== NOT EXECUTED 300087c0: ea000009 b 300087ec <rtems_termios_read+0xd4> <== NOT EXECUTED 300087c4: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED 300087c8: e1520003 cmp r2, r3 <== NOT EXECUTED 300087cc: da000006 ble 300087ec <rtems_termios_read+0xd4> <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
300087d0: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
300087d4: e2588001 subs r8, r8, #1 <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
300087d8: e7d22003 ldrb r2, [r2, r3] <== NOT EXECUTED 300087dc: e2833001 add r3, r3, #1 <== NOT EXECUTED 300087e0: e4ca2001 strb r2, [sl], #1 <== NOT EXECUTED 300087e4: 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)) {
300087e8: 1afffff5 bne 300087c4 <rtems_termios_read+0xac> <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
300087ec: e5993010 ldr r3, [r9, #16] <== NOT EXECUTED
tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem);
300087f0: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
300087f4: e0688003 rsb r8, r8, r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
300087f8: e3a03000 mov r3, #0 <== NOT EXECUTED
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
300087fc: e5898018 str r8, [r9, #24] <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
30008800: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
30008804: eb00051b bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
return sc;
30008808: eaffffdf b 3000878c <rtems_termios_read+0x74> <== NOT EXECUTED
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
3000880c: 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;
30008810: e59d1000 ldr r1, [sp] <== NOT EXECUTED
tty->read_start_column = tty->column;
30008814: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
if (tty->device.pollRead != NULL &&
30008818: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
3000881c: e5841020 str r1, [r4, #32] <== NOT EXECUTED 30008820: e5841024 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
tty->read_start_column = tty->column;
30008824: e584202c str r2, [r4, #44] ; 0x2c <== NOT EXECUTED
if (tty->device.pollRead != NULL &&
30008828: 0a000002 beq 30008838 <rtems_termios_read+0x120> <== NOT EXECUTED 3000882c: e59420b4 ldr r2, [r4, #180] ; 0xb4 <== NOT EXECUTED 30008830: e3520000 cmp r2, #0 <== NOT EXECUTED 30008834: 0a000065 beq 300089d0 <rtems_termios_read+0x2b8> <== 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)(
30008838: e2843049 add r3, 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;
3000883c: e5946074 ldr r6, [r4, #116] ; 0x74 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
30008840: e59f727c ldr r7, [pc, #636] ; 30008ac4 <rtems_termios_read+0x3ac><== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
30008844: e59fb27c ldr fp, [pc, #636] ; 30008ac8 <rtems_termios_read+0x3b0><== NOT EXECUTED
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = (int)1;
30008848: e3a05001 mov r5, #1 <== 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)(
3000884c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008850: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED 30008854: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED 30008858: e1520003 cmp r2, r3 <== NOT EXECUTED 3000885c: 0a000046 beq 3000897c <rtems_termios_read+0x264> <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
30008860: e5972008 ldr r2, [r7, #8] <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008864: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
30008868: e2422001 sub r2, r2, #1 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
3000886c: e1520003 cmp r2, r3 <== NOT EXECUTED 30008870: ca00000f bgt 300088b4 <rtems_termios_read+0x19c> <== NOT EXECUTED 30008874: ea000040 b 3000897c <rtems_termios_read+0x264> <== NOT EXECUTED
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
30008878: e1a00006 mov r0, r6 <== NOT EXECUTED 3000887c: e1a01004 mov r1, r4 <== NOT EXECUTED 30008880: ebffff59 bl 300085ec <siproc> <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008884: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED 30008888: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
3000888c: e3500000 cmp r0, #0 <== NOT EXECUTED 30008890: 13a05000 movne r5, #0 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008894: e1520003 cmp r2, r3 <== NOT EXECUTED
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
30008898: e5946070 ldr r6, [r4, #112] ; 0x70 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
3000889c: 0a000036 beq 3000897c <rtems_termios_read+0x264> <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
300088a0: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300088a4: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
300088a8: e2433001 sub r3, r3, #1 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300088ac: e1520003 cmp r2, r3 <== NOT EXECUTED 300088b0: aa000031 bge 3000897c <rtems_termios_read+0x264> <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
300088b4: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 300088b8: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED 300088bc: e2800001 add r0, r0, #1 <== NOT EXECUTED 300088c0: eb0033f4 bl 30015898 <__umodsi3> <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
300088c4: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED 300088c8: e7d36000 ldrb r6, [r3, r0] <== NOT EXECUTED
tty->rawInBuf.Head = newHead;
300088cc: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
300088d0: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED 300088d4: e5942064 ldr r2, [r4, #100] ; 0x64 <== NOT EXECUTED
% tty->rawInBuf.Size)
300088d8: 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)
300088dc: e0823003 add r3, r2, r3 <== NOT EXECUTED
% tty->rawInBuf.Size)
300088e0: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 300088e4: eb0033eb bl 30015898 <__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)
300088e8: e59430bc ldr r3, [r4, #188] ; 0xbc <== NOT EXECUTED 300088ec: e1500003 cmp r0, r3 <== NOT EXECUTED 300088f0: 2a000012 bcs 30008940 <rtems_termios_read+0x228> <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
300088f4: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
300088f8: e59f31c8 ldr r3, [pc, #456] ; 30008ac8 <rtems_termios_read+0x3b0><== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
300088fc: e3c22001 bic r2, r2, #1 <== NOT EXECUTED 30008900: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
30008904: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008908: e0023003 and r3, r2, r3 <== NOT EXECUTED 3000890c: e153000b cmp r3, fp <== NOT EXECUTED 30008910: 0a000022 beq 300089a0 <rtems_termios_read+0x288> <== NOT EXECUTED
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
30008914: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008918: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3000891c: 0a000007 beq 30008940 <rtems_termios_read+0x228> <== NOT EXECUTED
tty->flow_ctrl &= ~FL_IRTSOFF;
30008920: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
30008924: e59430b0 ldr r3, [r4, #176] ; 0xb0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
30008928: e3c22004 bic r2, r2, #4 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
3000892c: e3530000 cmp r3, #0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
30008930: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
tty->device.startRemoteTx(tty->minor);
30008934: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED 30008938: 11a0e00f movne lr, pc <== NOT EXECUTED 3000893c: 112fff13 bxne r3 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
30008940: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 30008944: e3130002 tst r3, #2 <== NOT EXECUTED 30008948: 1affffca bne 30008878 <rtems_termios_read+0x160> <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
3000894c: e1a00006 mov r0, r6 <== NOT EXECUTED 30008950: e1a01004 mov r1, r4 <== NOT EXECUTED 30008954: ebffff24 bl 300085ec <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
30008958: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED 3000895c: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
30008960: e5946070 ldr r6, [r4, #112] ; 0x70 <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
30008964: e1520003 cmp r2, r3 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008968: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED 3000896c: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
30008970: a3a05000 movge r5, #0 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008974: e1520003 cmp r2, r3 <== NOT EXECUTED 30008978: 1affffc8 bne 300088a0 <rtems_termios_read+0x188> <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
3000897c: e3550000 cmp r5, #0 <== NOT EXECUTED 30008980: 0affff88 beq 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
sc = rtems_semaphore_obtain(
30008984: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED 30008988: e594106c ldr r1, [r4, #108] ; 0x6c <== NOT EXECUTED 3000898c: e1a02006 mov r2, r6 <== NOT EXECUTED 30008990: eb00046f bl 30009b54 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
30008994: e3500000 cmp r0, #0 <== NOT EXECUTED 30008998: 0affffac beq 30008850 <rtems_termios_read+0x138> <== NOT EXECUTED 3000899c: eaffff81 b 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
300089a0: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED 300089a4: e3530000 cmp r3, #0 <== NOT EXECUTED 300089a8: 0a000002 beq 300089b8 <rtems_termios_read+0x2a0> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
300089ac: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300089b0: e3130020 tst r3, #32 <== NOT EXECUTED 300089b4: 0affffd6 beq 30008914 <rtems_termios_read+0x1fc> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
300089b8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 300089bc: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 300089c0: e3a02001 mov r2, #1 <== NOT EXECUTED 300089c4: e1a0e00f mov lr, pc <== NOT EXECUTED 300089c8: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 300089cc: eaffffdb b 30008940 <rtems_termios_read+0x228> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
300089d0: e594203c ldr r2, [r4, #60] ; 0x3c <== NOT EXECUTED 300089d4: e3120002 tst r2, #2 <== NOT EXECUTED 300089d8: 0a00000b beq 30008a0c <rtems_termios_read+0x2f4> <== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
300089dc: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 300089e0: e1a0e00f mov lr, pc <== NOT EXECUTED 300089e4: e12fff13 bx r3 <== NOT EXECUTED
if (n < 0) {
300089e8: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
300089ec: e1a01004 mov r1, r4 <== NOT EXECUTED 300089f0: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
300089f4: ba00002d blt 30008ab0 <rtems_termios_read+0x398> <== NOT EXECUTED
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
300089f8: ebfffefb bl 300085ec <siproc> <== NOT EXECUTED 300089fc: e3500000 cmp r0, #0 <== NOT EXECUTED 30008a00: 1affff68 bne 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
30008a04: e59430a0 ldr r3, [r4, #160] ; 0xa0 <== NOT EXECUTED 30008a08: eafffff3 b 300089dc <rtems_termios_read+0x2c4> <== NOT EXECUTED
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
30008a0c: eb0002b0 bl 300094d4 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED 30008a10: e1a05000 mov r5, r0 <== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
30008a14: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008a18: e1a0e00f mov lr, pc <== NOT EXECUTED 30008a1c: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (n < 0) {
30008a20: e3500000 cmp r0, #0 <== NOT EXECUTED 30008a24: ba00000c blt 30008a5c <rtems_termios_read+0x344> <== NOT EXECUTED
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
30008a28: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 30008a2c: e1a01004 mov r1, r4 <== NOT EXECUTED 30008a30: ebfffeed bl 300085ec <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
30008a34: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED 30008a38: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED 30008a3c: e1520003 cmp r2, r3 <== NOT EXECUTED 30008a40: aaffff58 bge 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
30008a44: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a48: 0afffff1 beq 30008a14 <rtems_termios_read+0x2fc> <== NOT EXECUTED 30008a4c: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED 30008a50: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a54: 0affffee beq 30008a14 <rtems_termios_read+0x2fc> <== NOT EXECUTED 30008a58: eaffffeb b 30008a0c <rtems_termios_read+0x2f4> <== NOT EXECUTED
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
30008a5c: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED 30008a60: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a64: 0a000008 beq 30008a8c <rtems_termios_read+0x374> <== NOT EXECUTED
if (tty->termios.c_cc[VTIME] && tty->ccount) {
30008a68: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED 30008a6c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a70: 0a000002 beq 30008a80 <rtems_termios_read+0x368> <== NOT EXECUTED 30008a74: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 30008a78: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a7c: 1a000005 bne 30008a98 <rtems_termios_read+0x380> <== NOT EXECUTED
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
30008a80: e3a00001 mov r0, #1 <== NOT EXECUTED 30008a84: eb000569 bl 3000a030 <rtems_task_wake_after> <== NOT EXECUTED 30008a88: eaffffe1 b 30008a14 <rtems_termios_read+0x2fc> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
30008a8c: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED 30008a90: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a94: 0affff43 beq 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
30008a98: eb00028d bl 300094d4 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
30008a9c: e5943054 ldr r3, [r4, #84] ; 0x54 <== NOT EXECUTED 30008aa0: e0650000 rsb r0, r5, r0 <== NOT EXECUTED 30008aa4: e1500003 cmp r0, r3 <== NOT EXECUTED 30008aa8: 9afffff4 bls 30008a80 <rtems_termios_read+0x368> <== NOT EXECUTED 30008aac: eaffff3d b 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
30008ab0: e3a00001 mov r0, #1 <== NOT EXECUTED 30008ab4: eb00055d bl 3000a030 <rtems_task_wake_after> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
30008ab8: e59430a0 ldr r3, [r4, #160] ; 0xa0 <== NOT EXECUTED 30008abc: eaffffc6 b 300089dc <rtems_termios_read+0x2c4> <== NOT EXECUTED
30008e54 <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))
30008e54: e59020b8 ldr r2, [r0, #184] ; 0xb8 <== NOT EXECUTED 30008e58: e59f31f4 ldr r3, [pc, #500] ; 30009054 <rtems_termios_refill_transmitter+0x200><== 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)
{
30008e5c: 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))
30008e60: e0023003 and r3, r2, r3 <== NOT EXECUTED 30008e64: e59f21ec ldr r2, [pc, #492] ; 30009058 <rtems_termios_refill_transmitter+0x204><== 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)
{
30008e68: 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))
30008e6c: e1530002 cmp r3, r2 <== NOT EXECUTED 30008e70: 0a000048 beq 30008f98 <rtems_termios_refill_transmitter+0x144><== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
30008e74: e59030b8 ldr r3, [r0, #184] ; 0xb8 <== NOT EXECUTED 30008e78: e2033003 and r3, r3, #3 <== NOT EXECUTED 30008e7c: e3530002 cmp r3, #2 <== NOT EXECUTED 30008e80: 0a000056 beq 30008fe0 <rtems_termios_refill_transmitter+0x18c><== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
30008e84: e5902080 ldr r2, [r0, #128] ; 0x80 <== NOT EXECUTED 30008e88: e5903084 ldr r3, [r0, #132] ; 0x84 <== NOT EXECUTED 30008e8c: e1520003 cmp r2, r3 <== NOT EXECUTED 30008e90: 0a00002a beq 30008f40 <rtems_termios_refill_transmitter+0xec><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008e94: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30008e98: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30008e9c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
30008ea0: e3a02000 mov r2, #0 <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
30008ea4: e5900090 ldr r0, [r0, #144] ; 0x90 <== NOT EXECUTED
tty->t_dqlen = 0;
30008ea8: e5842090 str r2, [r4, #144] ; 0x90 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30008eac: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
30008eb0: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED 30008eb4: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED 30008eb8: e0800003 add r0, r0, r3 <== NOT EXECUTED 30008ebc: eb003275 bl 30015898 <__umodsi3> <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
30008ec0: 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;
30008ec4: e1a05000 mov r5, r0 <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
30008ec8: 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;
30008ecc: e5840084 str r0, [r4, #132] ; 0x84 <== NOT EXECUTED
if (tty->rawOutBufState == rob_wait) {
30008ed0: 0a00002d beq 30008f8c <rtems_termios_refill_transmitter+0x138><== NOT EXECUTED
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
30008ed4: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED 30008ed8: e1530005 cmp r3, r5 <== NOT EXECUTED 30008edc: 0a00001f beq 30008f60 <rtems_termios_refill_transmitter+0x10c><== NOT EXECUTED
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
30008ee0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008ee4: e2033e21 and r3, r3, #528 ; 0x210 <== NOT EXECUTED 30008ee8: e3530e21 cmp r3, #528 ; 0x210 <== NOT EXECUTED 30008eec: 0a00004d beq 30009028 <rtems_termios_refill_transmitter+0x1d4><== NOT EXECUTED
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
30008ef0: 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)(
30008ef4: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
30008ef8: e1550003 cmp r5, r3 <== NOT EXECUTED
nToSend = tty->rawOutBuf.Size - newTail;
30008efc: 85946088 ldrhi r6, [r4, #136] ; 0x88 <== NOT EXECUTED
else
nToSend = tty->rawOutBuf.Head - newTail;
30008f00: 95946080 ldrls r6, [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)) {
30008f04: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
30008f08: 80656006 rsbhi r6, r5, r6 <== NOT EXECUTED
else
nToSend = tty->rawOutBuf.Head - newTail;
30008f0c: 90656006 rsbls r6, r5, r6 <== 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)) {
30008f10: e3130c06 tst r3, #1536 ; 0x600 <== NOT EXECUTED 30008f14: 13a06001 movne r6, #1 <== NOT EXECUTED
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
30008f18: e3a03001 mov r3, #1 <== NOT EXECUTED
nToSend = tty->rawOutBuf.Head - newTail;
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
nToSend = 1;
30008f1c: e1a02006 mov r2, r6 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
30008f20: e5843094 str r3, [r4, #148] ; 0x94 <== NOT EXECUTED
(*tty->device.write)(
30008f24: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008f28: e0811005 add r1, r1, r5 <== NOT EXECUTED 30008f2c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008f30: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
30008f34: e5845084 str r5, [r4, #132] ; 0x84 <== NOT EXECUTED
} return nToSend; }
30008f38: e1a00006 mov r0, r6 <== NOT EXECUTED
30008f3c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
30008f40: e5903094 ldr r3, [r0, #148] ; 0x94 <== NOT EXECUTED 30008f44: e3530002 cmp r3, #2 <== NOT EXECUTED
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
30008f48: 13a06000 movne r6, #0 <== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
30008f4c: 1afffff9 bne 30008f38 <rtems_termios_refill_transmitter+0xe4><== NOT EXECUTED
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
30008f50: e590008c ldr r0, [r0, #140] ; 0x8c <== NOT EXECUTED 30008f54: eb000347 bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
}
return 0;
30008f58: e3a06000 mov r6, #0 <== NOT EXECUTED 30008f5c: eafffff5 b 30008f38 <rtems_termios_refill_transmitter+0xe4><== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
30008f60: e59430d4 ldr r3, [r4, #212] ; 0xd4 <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
30008f64: e3a06000 mov r6, #0 <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
30008f68: e1530006 cmp r3, r6 <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
30008f6c: e5846094 str r6, [r4, #148] ; 0x94 <== NOT EXECUTED
nToSend = 0;
30008f70: 01a06003 moveq r6, r3 <== NOT EXECUTED
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
30008f74: 0affffee beq 30008f34 <rtems_termios_refill_transmitter+0xe0><== NOT EXECUTED
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
30008f78: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 30008f7c: e59410d8 ldr r1, [r4, #216] ; 0xd8 <== NOT EXECUTED 30008f80: e1a0e00f mov lr, pc <== NOT EXECUTED 30008f84: e12fff13 bx r3 <== NOT EXECUTED 30008f88: eaffffe9 b 30008f34 <rtems_termios_refill_transmitter+0xe0><== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
30008f8c: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED 30008f90: eb000338 bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED 30008f94: eaffffce b 30008ed4 <rtems_termios_refill_transmitter+0x80><== NOT EXECUTED
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
30008f98: e284104a add r1, r4, #74 ; 0x4a <== NOT EXECUTED 30008f9c: e3a02001 mov r2, #1 <== NOT EXECUTED 30008fa0: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED 30008fa4: e1a0e00f mov lr, pc <== NOT EXECUTED 30008fa8: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008fac: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30008fb0: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30008fb4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
30008fb8: e5941090 ldr r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
30008fbc: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
30008fc0: e2411001 sub r1, r1, #1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
30008fc4: e3822002 orr r2, r2, #2 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
30008fc8: e5841090 str r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
30008fcc: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30008fd0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
30008fd4: e3a06001 mov r6, #1 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
30008fd8: e1a00006 mov r0, r6 <== NOT EXECUTED
30008fdc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
30008fe0: e2841049 add r1, r4, #73 ; 0x49 <== NOT EXECUTED 30008fe4: e3a02001 mov r2, #1 <== NOT EXECUTED 30008fe8: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED 30008fec: e1a0e00f mov lr, pc <== NOT EXECUTED 30008ff0: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008ff4: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30008ff8: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30008ffc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
30009000: e5941090 ldr r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
30009004: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
30009008: e2411001 sub r1, r1, #1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
3000900c: e3c22002 bic r2, r2, #2 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
30009010: e5841090 str r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
30009014: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009018: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
3000901c: e3a06001 mov r6, #1 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
30009020: e1a00006 mov r0, r6 <== NOT EXECUTED
30009024: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30009028: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000902c: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30009030: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
tty->flow_ctrl |= FL_OSTOP;
30009034: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 30009038: e3822020 orr r2, r2, #32 <== NOT EXECUTED 3000903c: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
30009040: e3a02001 mov r2, #1 <== NOT EXECUTED 30009044: e5842094 str r2, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009048: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 0;
3000904c: e3a06000 mov r6, #0 <== NOT EXECUTED 30009050: eaffffb7 b 30008f34 <rtems_termios_refill_transmitter+0xe0><== NOT EXECUTED
30008dc8 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
30008dc8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
30008dcc: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
30008dd0: e1a04000 mov r4, r0 <== NOT EXECUTED
30008dd4: e28d7007 add r7, sp, #7 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30008dd8: e3a06000 mov r6, #0 <== NOT EXECUTED 30008ddc: ea000005 b 30008df8 <rtems_termios_rxdaemon+0x30> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30008de0: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008de4: e1a0e00f mov lr, pc <== NOT EXECUTED 30008de8: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (c != EOF) {
30008dec: e3700001 cmn r0, #1 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30008df0: e1a03000 mov r3, r0 <== NOT EXECUTED
if (c != EOF) {
30008df4: 1a000010 bne 30008e3c <rtems_termios_rxdaemon+0x74> <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30008df8: e1a0300d mov r3, sp <== NOT EXECUTED 30008dfc: e3a01002 mov r1, #2 <== NOT EXECUTED 30008e00: e3a02000 mov r2, #0 <== NOT EXECUTED 30008e04: e3a00003 mov r0, #3 <== NOT EXECUTED 30008e08: eb0001d1 bl 30009554 <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) {
30008e0c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30008e10: e3130001 tst r3, #1 <== NOT EXECUTED 30008e14: 0afffff1 beq 30008de0 <rtems_termios_rxdaemon+0x18> <== NOT EXECUTED
tty->rxTaskId = 0;
30008e18: e58460c4 str r6, [r4, #196] ; 0xc4 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
30008e1c: e1a00006 mov r0, r6 <== NOT EXECUTED 30008e20: eb00040d bl 30009e5c <rtems_task_delete> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30008e24: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008e28: e1a0e00f mov lr, pc <== NOT EXECUTED 30008e2c: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (c != EOF) {
30008e30: e3700001 cmn r0, #1 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30008e34: e1a03000 mov r3, r0 <== NOT EXECUTED
if (c != EOF) {
30008e38: 0affffee beq 30008df8 <rtems_termios_rxdaemon+0x30> <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
30008e3c: e1a00004 mov r0, r4 <== NOT EXECUTED 30008e40: e1a01007 mov r1, r7 <== NOT EXECUTED 30008e44: e3a02001 mov r2, #1 <== NOT EXECUTED
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
30008e48: e5cd3007 strb r3, [sp, #7] <== NOT EXECUTED
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
30008e4c: ebffff21 bl 30008ad8 <rtems_termios_enqueue_raw_characters><== NOT EXECUTED 30008e50: eaffffe8 b 30008df8 <rtems_termios_rxdaemon+0x30> <== NOT EXECUTED
30008acc <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);
30008acc: e59000c4 ldr r0, [r0, #196] ; 0xc4 <== NOT EXECUTED 30008ad0: e3a01002 mov r1, #2 <== NOT EXECUTED 30008ad4: ea0002fb b 300096c8 <rtems_event_send> <== NOT EXECUTED
3000b32c <rtems_termios_set_initial_baud>:
int rtems_termios_set_initial_baud(
struct rtems_termios_tty *ttyp,
int32_t baud
)
{
3000b32c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b330: e1a04000 mov r4, r0 <== NOT EXECUTED
int cflags_baud;
cflags_baud = rtems_termios_number_to_baud(baud);
3000b334: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b338: ebfff89f bl 300095bc <rtems_termios_number_to_baud> <== NOT EXECUTED
if ( cflags_baud == -1 )
3000b33c: e3700001 cmn r0, #1 <== NOT EXECUTED
return -1;
ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
3000b340: 15942038 ldrne r2, [r4, #56] ; 0x38 <== NOT EXECUTED
int32_t baud
)
{
int cflags_baud;
cflags_baud = rtems_termios_number_to_baud(baud);
3000b344: e1a03000 mov r3, r0 <== NOT EXECUTED
if ( cflags_baud == -1 )
return -1;
ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
3000b348: 13c22a01 bicne r2, r2, #4096 ; 0x1000 <== NOT EXECUTED 3000b34c: 13c2200f bicne r2, r2, #15 <== NOT EXECUTED 3000b350: 11833002 orrne r3, r3, r2 <== NOT EXECUTED
return 0;
3000b354: 13a00000 movne r0, #0 <== NOT EXECUTED
cflags_baud = rtems_termios_number_to_baud(baud);
if ( cflags_baud == -1 )
return -1;
ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
3000b358: 15843038 strne r3, [r4, #56] ; 0x38 <== NOT EXECUTED
{
int cflags_baud;
cflags_baud = rtems_termios_number_to_baud(baud);
if ( cflags_baud == -1 )
return -1;
3000b35c: 01a00003 moveq r0, r3 <== NOT EXECUTED
ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
return 0;
}
3000b360: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000905c <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
3000905c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
30009060: e59f6060 ldr r6, [pc, #96] ; 300090c8 <rtems_termios_txdaemon+0x6c><== NOT EXECUTED
30009064: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
30009068: e1a04000 mov r4, r0 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
3000906c: e3a07000 mov r7, #0 <== NOT EXECUTED 30009070: ea000008 b 30009098 <rtems_termios_txdaemon+0x3c> <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
30009074: e59430cc ldr r3, [r4, #204] ; 0xcc <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
30009078: e1a00004 mov r0, r4 <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
3000907c: e0863283 add r3, r6, r3, lsl #5 <== NOT EXECUTED 30009080: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED 30009084: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
30009088: 11a0e00f movne lr, pc <== NOT EXECUTED 3000908c: 112fff13 bxne r3 <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
30009090: e1a00004 mov r0, r4 <== NOT EXECUTED 30009094: ebffff6e bl 30008e54 <rtems_termios_refill_transmitter> <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30009098: e1a0300d mov r3, sp <== NOT EXECUTED 3000909c: e3a01002 mov r1, #2 <== NOT EXECUTED 300090a0: e3a02000 mov r2, #0 <== NOT EXECUTED 300090a4: e3a00003 mov r0, #3 <== NOT EXECUTED 300090a8: eb000129 bl 30009554 <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) {
300090ac: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300090b0: e3130001 tst r3, #1 <== NOT EXECUTED 300090b4: 0affffee beq 30009074 <rtems_termios_txdaemon+0x18> <== NOT EXECUTED
tty->txTaskId = 0;
300090b8: e58470c8 str r7, [r4, #200] ; 0xc8 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
300090bc: e1a00007 mov r0, r7 <== NOT EXECUTED 300090c0: eb000365 bl 30009e5c <rtems_task_delete> <== NOT EXECUTED 300090c4: eaffffea b 30009074 <rtems_termios_txdaemon+0x18> <== NOT EXECUTED
30008648 <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;
30008648: e5903000 ldr r3, [r0]
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
3000864c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
30008650: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30008654: e3a01000 mov r1, #0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
30008658: e1a05000 mov r5, r0
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3000865c: e1a02001 mov r2, r1 30008660: e5940018 ldr r0, [r4, #24] 30008664: eb00053a bl 30009b54 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
30008668: e2506000 subs r6, r0, #0
3000866c: 1a00000c bne 300086a4 <rtems_termios_write+0x5c>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
30008670: e59420cc ldr r2, [r4, #204] ; 0xcc 30008674: e59f3098 ldr r3, [pc, #152] ; 30008714 <rtems_termios_write+0xcc> 30008678: e0833282 add r3, r3, r2, lsl #5 3000867c: e593300c ldr r3, [r3, #12] 30008680: e3530000 cmp r3, #0
30008684: 0a000008 beq 300086ac <rtems_termios_write+0x64>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
30008688: e1a00004 mov r0, r4 <== NOT EXECUTED 3000868c: e1a01005 mov r1, r5 <== NOT EXECUTED 30008690: e1a0e00f mov lr, pc <== NOT EXECUTED 30008694: e12fff13 bx r3 <== NOT EXECUTED 30008698: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
3000869c: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED 300086a0: eb000574 bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
300086a4: e1a00006 mov r0, r6 <== NOT EXECUTED
300086a8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
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) {
300086ac: e5943034 ldr r3, [r4, #52] ; 0x34 300086b0: e3130001 tst r3, #1
300086b4: 0a000011 beq 30008700 <rtems_termios_write+0xb8>
uint32_t count = args->count;
300086b8: e5958010 ldr r8, [r5, #16]
char *buffer = args->buffer;
300086bc: e595a00c ldr sl, [r5, #12]
while (count--)
300086c0: e3580000 cmp r8, #0 300086c4: 01a03006 moveq r3, r6
300086c8: 0a000007 beq 300086ec <rtems_termios_write+0xa4>
300086cc: e1a07006 mov r7, r6
oproc (*buffer++, tty);
300086d0: e7da0007 ldrb r0, [sl, r7] 300086d4: e1a01004 mov r1, r4 300086d8: e2877001 add r7, r7, #1 300086dc: ebfffe47 bl 30008000 <oproc>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
300086e0: e1570008 cmp r7, r8
300086e4: 1afffff9 bne 300086d0 <rtems_termios_write+0x88>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
300086e8: e5953010 ldr r3, [r5, #16] 300086ec: e5853018 str r3, [r5, #24]
} rtems_semaphore_release (tty->osem);
300086f0: e5940018 ldr r0, [r4, #24] 300086f4: eb00055f bl 30009c78 <rtems_semaphore_release>
return sc; }
300086f8: e1a00006 mov r0, r6
300086fc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
30008700: e595000c ldr r0, [r5, #12] <== NOT EXECUTED 30008704: e5951010 ldr r1, [r5, #16] <== NOT EXECUTED 30008708: e1a02004 mov r2, r4 <== NOT EXECUTED 3000870c: ebfffdf4 bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED 30008710: eafffff4 b 300086e8 <rtems_termios_write+0xa0> <== NOT EXECUTED
3000a524 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
3000a524: e92d4070 push {r4, r5, r6, lr}
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
3000a528: e2504000 subs r4, r0, #0
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
3000a52c: e1a05001 mov r5, r1
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000a530: 03a00003 moveq r0, #3
rtems_id *id
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
3000a534: 08bd8070 popeq {r4, r5, r6, pc}
return RTEMS_INVALID_NAME;
if ( !id )
3000a538: e3510000 cmp r1, #0
3000a53c: 0a00001b beq 3000a5b0 <rtems_timer_create+0x8c>
3000a540: e59f3070 ldr r3, [pc, #112] ; 3000a5b8 <rtems_timer_create+0x94> 3000a544: e5932000 ldr r2, [r3] 3000a548: e2822001 add r2, r2, #1 3000a54c: 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 );
3000a550: e59f6064 ldr r6, [pc, #100] ; 3000a5bc <rtems_timer_create+0x98> 3000a554: e1a00006 mov r0, r6 3000a558: eb0003d9 bl 3000b4c4 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
3000a55c: e3500000 cmp r0, #0
3000a560: 0a00000f beq 3000a5a4 <rtems_timer_create+0x80>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000a564: e5903008 ldr r3, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a568: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000a56c: e1a01803 lsl r1, r3, #16
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a570: e3a06000 mov r6, #0
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
3000a574: e3a0c004 mov ip, #4 3000a578: e580c038 str ip, [r0, #56] ; 0x38 3000a57c: e5806018 str r6, [r0, #24]
the_watchdog->routine = routine;
3000a580: e580602c str r6, [r0, #44] ; 0x2c
the_watchdog->id = id;
3000a584: e5806030 str r6, [r0, #48] ; 0x30
the_watchdog->user_data = user_data;
3000a588: e5806034 str r6, [r0, #52] ; 0x34
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a58c: e7820721 str r0, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000a590: e580400c str r4, [r0, #12]
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
3000a594: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
3000a598: eb000833 bl 3000c66c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a59c: e1a00006 mov r0, r6
3000a5a0: e8bd8070 pop {r4, r5, r6, pc}
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
3000a5a4: eb000830 bl 3000c66c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000a5a8: e3a00005 mov r0, #5 <== NOT EXECUTED
3000a5ac: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000a5b0: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000a5b4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000a5c0 <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3000a5c0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
3000a5c4: e2516000 subs r6, r1, #0
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3000a5c8: e1a05000 mov r5, r0 3000a5cc: e24dd004 sub sp, sp, #4 3000a5d0: e1a04002 mov r4, r2 3000a5d4: e1a07003 mov r7, r3
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
3000a5d8: 03a0000a moveq r0, #10
{
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
3000a5dc: 0a000020 beq 3000a664 <rtems_timer_fire_after+0xa4>
return RTEMS_INVALID_NUMBER;
if ( !routine )
3000a5e0: e3520000 cmp r2, #0
return RTEMS_INVALID_ADDRESS;
3000a5e4: 03a00009 moveq r0, #9
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
3000a5e8: 0a00001d beq 3000a664 <rtems_timer_fire_after+0xa4>
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
3000a5ec: e59f0088 ldr r0, [pc, #136] ; 3000a67c <rtems_timer_fire_after+0xbc> 3000a5f0: e1a01005 mov r1, r5 3000a5f4: e1a0200d mov r2, sp 3000a5f8: eb0004e2 bl 3000b988 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3000a5fc: e59d3000 ldr r3, [sp] 3000a600: e1a08000 mov r8, r0 3000a604: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a608: 13a00004 movne r0, #4
if ( !routine )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3000a60c: 1a000014 bne 3000a664 <rtems_timer_fire_after+0xa4>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3000a610: e288a010 add sl, r8, #16 3000a614: e1a0000a mov r0, sl 3000a618: eb000c1c bl 3000d690 <_Watchdog_Remove>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a61c: e10f2000 mrs r2, CPSR 3000a620: e3823080 orr r3, r2, #128 ; 0x80 3000a624: 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 ) {
3000a628: e5983018 ldr r3, [r8, #24] 3000a62c: e3530000 cmp r3, #0
3000a630: 1a00000d bne 3000a66c <rtems_timer_fire_after+0xac>
/*
* 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;
3000a634: e5883038 str r3, [r8, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a638: e5883018 str r3, [r8, #24]
the_watchdog->routine = routine;
3000a63c: e588402c str r4, [r8, #44] ; 0x2c
the_watchdog->id = id;
3000a640: e5885030 str r5, [r8, #48] ; 0x30
the_watchdog->user_data = user_data;
3000a644: e5887034 str r7, [r8, #52] ; 0x34
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a648: e129f002 msr CPSR_fc, r2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a64c: e59f002c ldr r0, [pc, #44] ; 3000a680 <rtems_timer_fire_after+0xc0> 3000a650: e1a0100a mov r1, sl
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a654: e588601c str r6, [r8, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a658: eb000b9d bl 3000d4d4 <_Watchdog_Insert>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
3000a65c: eb000802 bl 3000c66c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a660: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000a664: e28dd004 add sp, sp, #4
3000a668: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
3000a66c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
_Thread_Enable_dispatch();
3000a670: eb0007fd bl 3000c66c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a674: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a678: eafffff9 b 3000a664 <rtems_timer_fire_after+0xa4> <== NOT EXECUTED
3001a0f4 <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a0f4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3001a0f8: e1a05000 mov r5, r0
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
3001a0fc: e59f00d0 ldr r0, [pc, #208] ; 3001a1d4 <rtems_timer_fire_when+0xe0>
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a100: e24dd004 sub sp, sp, #4
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
3001a104: e5d0c000 ldrb ip, [r0]
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a108: e1a06001 mov r6, r1
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
3001a10c: e35c0000 cmp ip, #0
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a110: e1a04002 mov r4, r2 3001a114: e1a07003 mov r7, r3
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
3001a118: 03a0000b moveq r0, #11
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
3001a11c: 1a000001 bne 3001a128 <rtems_timer_fire_when+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a120: e28dd004 add sp, sp, #4
3001a124: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
3001a128: e1a00001 mov r0, r1 3001a12c: ebfff4b6 bl 3001740c <_TOD_Validate> 3001a130: e3500000 cmp r0, #0
3001a134: 0a000009 beq 3001a160 <rtems_timer_fire_when+0x6c>
return RTEMS_INVALID_CLOCK;
if ( !routine )
3001a138: e3540000 cmp r4, #0
return RTEMS_INVALID_ADDRESS;
3001a13c: 03a00009 moveq r0, #9
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
3001a140: 0afffff6 beq 3001a120 <rtems_timer_fire_when+0x2c>
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
3001a144: e1a00006 mov r0, r6 3001a148: ebfff484 bl 30017360 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
3001a14c: e59f8084 ldr r8, [pc, #132] ; 3001a1d8 <rtems_timer_fire_when+0xe4>
return RTEMS_INVALID_CLOCK;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
3001a150: e1a06000 mov r6, r0
if ( seconds <= _TOD_Seconds_since_epoch() )
3001a154: e5983000 ldr r3, [r8] 3001a158: e1500003 cmp r0, r3
3001a15c: 8a000001 bhi 3001a168 <rtems_timer_fire_when+0x74>
return RTEMS_INVALID_CLOCK;
3001a160: e3a00014 mov r0, #20 <== NOT EXECUTED 3001a164: eaffffed b 3001a120 <rtems_timer_fire_when+0x2c> <== NOT EXECUTED
3001a168: e59f006c ldr r0, [pc, #108] ; 3001a1dc <rtems_timer_fire_when+0xe8> 3001a16c: e1a01005 mov r1, r5 3001a170: e1a0200d mov r2, sp 3001a174: eb000b74 bl 3001cf4c <_Objects_Get>
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a178: e59da000 ldr sl, [sp] 3001a17c: e1a09000 mov r9, r0 3001a180: e35a0000 cmp sl, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a184: 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 ) {
3001a188: 1affffe4 bne 3001a120 <rtems_timer_fire_when+0x2c>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001a18c: e289b010 add fp, r9, #16 3001a190: e1a0000b mov r0, fp 3001a194: eb00139d bl 3001f010 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
3001a198: e5983000 ldr r3, [r8]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001a19c: e59f003c ldr r0, [pc, #60] ; 3001a1e0 <rtems_timer_fire_when+0xec> 3001a1a0: e0636006 rsb r6, r3, r6
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY;
3001a1a4: e3a03002 mov r3, #2 3001a1a8: e5893038 str r3, [r9, #56] ; 0x38 3001a1ac: e1a0100b mov r1, fp
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001a1b0: e589a018 str sl, [r9, #24]
the_watchdog->routine = routine;
3001a1b4: e589402c str r4, [r9, #44] ; 0x2c
the_watchdog->id = id;
3001a1b8: e5895030 str r5, [r9, #48] ; 0x30
the_watchdog->user_data = user_data;
3001a1bc: e5897034 str r7, [r9, #52] ; 0x34
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001a1c0: e589601c str r6, [r9, #28]
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001a1c4: eb001322 bl 3001ee54 <_Watchdog_Insert>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
3001a1c8: eb000eba bl 3001dcb8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3001a1cc: e1a0000a mov r0, sl 3001a1d0: eaffffd2 b 3001a120 <rtems_timer_fire_when+0x2c>
3001a1e4 <rtems_timer_get_information>:
rtems_status_code rtems_timer_get_information(
rtems_id id,
rtems_timer_information *the_info
)
{
3001a1e4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
3001a1e8: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_timer_get_information(
rtems_id id,
rtems_timer_information *the_info
)
{
3001a1ec: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3001a1f0: e1a01000 mov r1, r0 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
3001a1f4: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
3001a1f8: 0a00000e beq 3001a238 <rtems_timer_get_information+0x54> <== NOT EXECUTED 3001a1fc: e59f003c ldr r0, [pc, #60] ; 3001a240 <rtems_timer_get_information+0x5c><== NOT EXECUTED 3001a200: e1a0200d mov r2, sp <== NOT EXECUTED 3001a204: eb000b50 bl 3001cf4c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a208: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3001a20c: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a210: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a214: 1a000007 bne 3001a238 <rtems_timer_get_information+0x54> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
3001a218: e590c038 ldr ip, [r0, #56] ; 0x38 <== NOT EXECUTED
the_info->initial = the_timer->Ticker.initial;
3001a21c: e590101c ldr r1, [r0, #28] <== NOT EXECUTED
the_info->start_time = the_timer->Ticker.start_time;
3001a220: e5902024 ldr r2, [r0, #36] ; 0x24 <== NOT EXECUTED
the_info->stop_time = the_timer->Ticker.stop_time;
3001a224: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
3001a228: e584c000 str ip, [r4] <== NOT EXECUTED
the_info->initial = the_timer->Ticker.initial;
3001a22c: e984000e stmib r4, {r1, r2, r3} <== NOT EXECUTED
the_info->start_time = the_timer->Ticker.start_time;
the_info->stop_time = the_timer->Ticker.stop_time;
_Thread_Enable_dispatch();
3001a230: eb000ea0 bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001a234: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a238: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3001a23c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3001a8ec <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
3001a8ec: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3001a8f0: e3500000 cmp r0, #0 <== NOT EXECUTED
3001a8f4: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
3001a8f8: e1a06001 mov r6, r1 <== NOT EXECUTED
3001a8fc: e1a08002 mov r8, r2 <== NOT EXECUTED
3001a900: 0a00004a beq 3001aa30 <rtems_timer_initiate_server+0x144> <== NOT EXECUTED
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
3001a904: e59f313c ldr r3, [pc, #316] ; 3001aa48 <rtems_timer_initiate_server+0x15c><== NOT EXECUTED 3001a908: e5d33000 ldrb r3, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
3001a90c: e1500003 cmp r0, r3 <== NOT EXECUTED 3001a910: 9a00004a bls 3001aa40 <rtems_timer_initiate_server+0x154> <== 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 )
3001a914: e3700001 cmn r0, #1 <== NOT EXECUTED
return RTEMS_INVALID_PRIORITY;
_priority = 0;
3001a918: 03a07000 moveq r7, #0 <== 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 )
3001a91c: 1a000043 bne 3001aa30 <rtems_timer_initiate_server+0x144> <== NOT EXECUTED 3001a920: e59f3124 ldr r3, [pc, #292] ; 3001aa4c <rtems_timer_initiate_server+0x160><== NOT EXECUTED 3001a924: e5932000 ldr r2, [r3] <== NOT EXECUTED 3001a928: e2822001 add r2, r2, #1 <== NOT EXECUTED 3001a92c: e5832000 str r2, [r3] <== NOT EXECUTED
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
3001a930: e59f4118 ldr r4, [pc, #280] ; 3001aa50 <rtems_timer_initiate_server+0x164><== NOT EXECUTED
initialized = true;
3001a934: e3a03001 mov r3, #1 <== NOT EXECUTED
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
3001a938: e5d45000 ldrb r5, [r4] <== NOT EXECUTED
initialized = true;
3001a93c: e5c43000 strb r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3001a940: eb000cdc bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( tmpInitialized )
3001a944: e3550000 cmp r5, #0 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3001a948: 13a0300e movne r3, #14 <== NOT EXECUTED
_Thread_Disable_dispatch();
tmpInitialized = initialized;
initialized = true;
_Thread_Enable_dispatch();
if ( tmpInitialized )
3001a94c: 1a000038 bne 3001aa34 <rtems_timer_initiate_server+0x148> <== 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(
3001a950: e388c902 orr ip, r8, #32768 ; 0x8000 <== NOT EXECUTED 3001a954: e3a03c01 mov r3, #256 ; 0x100 <== NOT EXECUTED 3001a958: e58dc000 str ip, [sp] <== NOT EXECUTED 3001a95c: e59f00f0 ldr r0, [pc, #240] ; 3001aa54 <rtems_timer_initiate_server+0x168><== NOT EXECUTED 3001a960: e28dc008 add ip, sp, #8 <== NOT EXECUTED 3001a964: e1a01007 mov r1, r7 <== NOT EXECUTED 3001a968: e1a02006 mov r2, r6 <== NOT EXECUTED 3001a96c: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3001a970: ebfffb0f bl 300195b4 <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) {
3001a974: e2503000 subs r3, r0, #0 <== NOT EXECUTED
initialized = false;
3001a978: 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) {
3001a97c: 1a00002c bne 3001aa34 <rtems_timer_initiate_server+0x148> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
3001a980: e59f20d0 ldr r2, [pc, #208] ; 3001aa58 <rtems_timer_initiate_server+0x16c><== 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(
&_RTEMS_tasks_Information,
_Objects_Get_index(id)
3001a984: e59de008 ldr lr, [sp, #8] <== NOT EXECUTED 3001a988: e592201c ldr r2, [r2, #28] <== NOT EXECUTED 3001a98c: e1a0180e lsl r1, lr, #16 <== 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(
3001a990: e7922721 ldr r2, [r2, r1, lsr #14] <== NOT EXECUTED 3001a994: e1a0c004 mov ip, r4 <== NOT EXECUTED 3001a998: e5ac2004 str r2, [ip, #4]! <== 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;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
3001a99c: e59f10b8 ldr r1, [pc, #184] ; 3001aa5c <rtems_timer_initiate_server+0x170><== NOT EXECUTED
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
3001a9a0: e59f20b8 ldr r2, [pc, #184] ; 3001aa60 <rtems_timer_initiate_server+0x174><== 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;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
3001a9a4: e5918000 ldr r8, [r1] <== NOT EXECUTED
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
3001a9a8: e592a000 ldr sl, [r2] <== 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;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
3001a9ac: e5848040 str r8, [r4, #64] ; 0x40 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3001a9b0: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
3001a9b4: e584a078 str sl, [r4, #120] ; 0x78 <== NOT EXECUTED 3001a9b8: e5843070 str r3, [r4, #112] ; 0x70 <== NOT EXECUTED
ts->insert_chain = NULL;
3001a9bc: e584307c str r3, [r4, #124] ; 0x7c <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001a9c0: e5843014 str r3, [r4, #20] <== NOT EXECUTED
ts->active = false;
3001a9c4: e5c43080 strb r3, [r4, #128] ; 0x80 <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3001a9c8: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001a9cc: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3001a9d0: e5843068 str r3, [r4, #104] ; 0x68 <== 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;
3001a9d4: e59f3088 ldr r3, [pc, #136] ; 3001aa64 <rtems_timer_initiate_server+0x178><== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3001a9d8: e59f5088 ldr r5, [pc, #136] ; 3001aa68 <rtems_timer_initiate_server+0x17c><== NOT EXECUTED 3001a9dc: e5843008 str r3, [r4, #8] <== NOT EXECUTED
ts->active = false;
/*
* The default timer server is now available.
*/
_Timer_server = ts;
3001a9e0: e59f3084 ldr r3, [pc, #132] ; 3001aa6c <rtems_timer_initiate_server+0x180><== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001a9e4: e2847038 add r7, r4, #56 ; 0x38 <== NOT EXECUTED 3001a9e8: e583c000 str ip, [r3] <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001a9ec: e2849034 add r9, r4, #52 ; 0x34 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001a9f0: e284b070 add fp, r4, #112 ; 0x70 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001a9f4: e284606c add r6, r4, #108 ; 0x6c <== NOT EXECUTED
/*
* Start the timer server
*/
status = rtems_task_start(
3001a9f8: e1a0000e mov r0, lr <== NOT EXECUTED 3001a9fc: e59f106c ldr r1, [pc, #108] ; 3001aa70 <rtems_timer_initiate_server+0x184><== NOT EXECUTED 3001aa00: e1a0200c mov r2, ip <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001aa04: e5847034 str r7, [r4, #52] ; 0x34 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001aa08: e584903c str r9, [r4, #60] ; 0x3c <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001aa0c: e584b06c str fp, [r4, #108] ; 0x6c <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001aa10: e5846074 str r6, [r4, #116] ; 0x74 <== NOT EXECUTED 3001aa14: e5845028 str r5, [r4, #40] ; 0x28 <== NOT EXECUTED
the_watchdog->id = id;
3001aa18: e584e02c str lr, [r4, #44] ; 0x2c <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3001aa1c: e5845060 str r5, [r4, #96] ; 0x60 <== NOT EXECUTED
the_watchdog->id = id;
3001aa20: e584e064 str lr, [r4, #100] ; 0x64 <== NOT EXECUTED 3001aa24: ebfffca4 bl 30019cbc <rtems_task_start> <== NOT EXECUTED 3001aa28: e1a03000 mov r3, r0 <== NOT EXECUTED
if (status) {
initialized = false;
}
#endif
return status;
3001aa2c: ea000000 b 3001aa34 <rtems_timer_initiate_server+0x148> <== NOT EXECUTED
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
return RTEMS_INVALID_PRIORITY;
3001aa30: e3a03013 mov r3, #19 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001aa34: e1a00003 mov r0, r3 <== NOT EXECUTED
3001aa38: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3001aa3c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3001aa40: e1a07000 mov r7, r0 <== NOT EXECUTED
3001aa44: eaffffb5 b 3001a920 <rtems_timer_initiate_server+0x34> <== NOT EXECUTED
3001a274 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
3001a274: e92d4070 push {r4, r5, r6, lr}
3001a278: e24dd004 sub sp, sp, #4
3001a27c: e1a01000 mov r1, r0
3001a280: e1a0200d mov r2, sp
3001a284: e59f0088 ldr r0, [pc, #136] ; 3001a314 <rtems_timer_reset+0xa0>
3001a288: eb000b2f bl 3001cf4c <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a28c: e59d4000 ldr r4, [sp] 3001a290: e1a06000 mov r6, r0 3001a294: e3540000 cmp r4, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a298: 13a05004 movne r5, #4
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a29c: 1a000006 bne 3001a2bc <rtems_timer_reset+0x48>
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
3001a2a0: e5905038 ldr r5, [r0, #56] ; 0x38 3001a2a4: e3550000 cmp r5, #0
3001a2a8: 0a000006 beq 3001a2c8 <rtems_timer_reset+0x54>
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001a2ac: e3550001 cmp r5, #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;
3001a2b0: 13a0500b movne r5, #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 ) {
3001a2b4: 0a00000b beq 3001a2e8 <rtems_timer_reset+0x74> <== 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();
3001a2b8: eb000e7e bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a2bc: e1a00005 mov r0, r5
3001a2c0: e28dd004 add sp, sp, #4
3001a2c4: e8bd8070 pop {r4, r5, r6, pc}
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
3001a2c8: e2806010 add r6, r0, #16 3001a2cc: e1a00006 mov r0, r6 3001a2d0: eb00134e bl 3001f010 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
3001a2d4: e59f003c ldr r0, [pc, #60] ; 3001a318 <rtems_timer_reset+0xa4> 3001a2d8: e1a01006 mov r1, r6 3001a2dc: eb0012dc bl 3001ee54 <_Watchdog_Insert>
* 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();
3001a2e0: eb000e74 bl 3001dcb8 <_Thread_Enable_dispatch> 3001a2e4: eafffff4 b 3001a2bc <rtems_timer_reset+0x48>
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;
3001a2e8: e59f302c ldr r3, [pc, #44] ; 3001a31c <rtems_timer_reset+0xa8><== NOT EXECUTED
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
3001a2ec: 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;
3001a2f0: e5935000 ldr r5, [r3] <== NOT EXECUTED
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
3001a2f4: eb001345 bl 3001f010 <_Watchdog_Remove> <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
3001a2f8: e1a00005 mov r0, r5 <== NOT EXECUTED 3001a2fc: e1a01006 mov r1, r6 <== NOT EXECUTED 3001a300: e1a0e00f mov lr, pc <== NOT EXECUTED 3001a304: e595f004 ldr pc, [r5, #4] <== NOT EXECUTED
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
3001a308: e1a05004 mov r5, r4 <== 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();
3001a30c: eb000e69 bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED 3001a310: eaffffe9 b 3001a2bc <rtems_timer_reset+0x48> <== NOT EXECUTED
3001a320 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a320: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3001a324: e1a07000 mov r7, r0 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
3001a328: e59f00cc ldr r0, [pc, #204] ; 3001a3fc <rtems_timer_server_fire_after+0xdc><== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a32c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
3001a330: e5904000 ldr r4, [r0] <== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a334: e1a06001 mov r6, r1 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
3001a338: e3540000 cmp r4, #0 <== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a33c: e1a05002 mov r5, r2 <== NOT EXECUTED 3001a340: e1a08003 mov r8, r3 <== NOT EXECUTED
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
3001a344: 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 )
3001a348: 0a000005 beq 3001a364 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !routine )
3001a34c: e3520000 cmp r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3001a350: 03a00009 moveq r0, #9 <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !routine )
3001a354: 0a000002 beq 3001a364 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
3001a358: e3510000 cmp r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
3001a35c: 03a0000a moveq r0, #10 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
3001a360: 1a000001 bne 3001a36c <rtems_timer_server_fire_after+0x4c> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a364: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3001a368: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3001a36c: e59f008c ldr r0, [pc, #140] ; 3001a400 <rtems_timer_server_fire_after+0xe0><== NOT EXECUTED
3001a370: e1a01007 mov r1, r7 <== NOT EXECUTED
3001a374: e1a0200d mov r2, sp <== NOT EXECUTED
3001a378: eb000af3 bl 3001cf4c <_Objects_Get> <== NOT EXECUTED
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a37c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3001a380: e1a0a000 mov sl, r0 <== NOT EXECUTED 3001a384: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a388: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a38c: 1afffff4 bne 3001a364 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001a390: e28a0010 add r0, sl, #16 <== NOT EXECUTED 3001a394: eb00131d bl 3001f010 <_Watchdog_Remove> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a398: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3001a39c: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3001a3a0: 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 ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
3001a3a4: e59a3018 ldr r3, [sl, #24] <== NOT EXECUTED 3001a3a8: e3530000 cmp r3, #0 <== NOT EXECUTED 3001a3ac: 1a00000e bne 3001a3ec <rtems_timer_server_fire_after+0xcc> <== 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;
3001a3b0: e3a01001 mov r1, #1 <== NOT EXECUTED 3001a3b4: e58a1038 str r1, [sl, #56] ; 0x38 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001a3b8: e58a3018 str r3, [sl, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
3001a3bc: e58a502c str r5, [sl, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
3001a3c0: e58a7030 str r7, [sl, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3001a3c4: e58a8034 str r8, [sl, #52] ; 0x34 <== NOT EXECUTED
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
3001a3c8: e58a601c str r6, [sl, #28] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a3cc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
(*timer_server->schedule_operation)( timer_server, the_timer );
3001a3d0: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a3d4: e1a0100a mov r1, sl <== NOT EXECUTED 3001a3d8: e1a0e00f mov lr, pc <== NOT EXECUTED 3001a3dc: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3001a3e0: eb000e34 bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001a3e4: e3a00000 mov r0, #0 <== NOT EXECUTED 3001a3e8: eaffffdd b 3001a364 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED 3001a3ec: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
_Thread_Enable_dispatch();
3001a3f0: eb000e30 bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001a3f4: e3a00000 mov r0, #0 <== NOT EXECUTED 3001a3f8: eaffffd9 b 3001a364 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
3001a404 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a404: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3001a408: e1a06000 mov r6, r0 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
3001a40c: e59f00e0 ldr r0, [pc, #224] ; 3001a4f4 <rtems_timer_server_fire_when+0xf0><== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a410: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
3001a414: e5904000 ldr r4, [r0] <== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a418: 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 )
3001a41c: e3540000 cmp r4, #0 <== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a420: e1a05002 mov r5, r2 <== NOT EXECUTED 3001a424: e1a08003 mov r8, r3 <== NOT EXECUTED
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
3001a428: 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 )
3001a42c: 0a00000c beq 3001a464 <rtems_timer_server_fire_when+0x60> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
3001a430: e59f30c0 ldr r3, [pc, #192] ; 3001a4f8 <rtems_timer_server_fire_when+0xf4><== NOT EXECUTED 3001a434: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 3001a438: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
3001a43c: 03a0000b moveq r0, #11 <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
3001a440: 0a000007 beq 3001a464 <rtems_timer_server_fire_when+0x60> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
if ( !routine )
3001a444: e3520000 cmp r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3001a448: 03a00009 moveq r0, #9 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
3001a44c: 0a000004 beq 3001a464 <rtems_timer_server_fire_when+0x60> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
3001a450: e1a00001 mov r0, r1 <== NOT EXECUTED 3001a454: ebfff3ec bl 3001740c <_TOD_Validate> <== NOT EXECUTED 3001a458: e3500000 cmp r0, #0 <== NOT EXECUTED 3001a45c: 1a000002 bne 3001a46c <rtems_timer_server_fire_when+0x68> <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
3001a460: e3a00014 mov r0, #20 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a464: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3001a468: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
3001a46c: e1a00007 mov r0, r7 <== NOT EXECUTED 3001a470: ebfff3ba bl 30017360 <_TOD_To_seconds> <== NOT EXECUTED
if ( seconds <= _TOD_Seconds_since_epoch() )
3001a474: e59fa080 ldr sl, [pc, #128] ; 3001a4fc <rtems_timer_server_fire_when+0xf8><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
3001a478: e1a07000 mov r7, r0 <== NOT EXECUTED
if ( seconds <= _TOD_Seconds_since_epoch() )
3001a47c: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3001a480: e1500003 cmp r0, r3 <== NOT EXECUTED 3001a484: 9afffff5 bls 3001a460 <rtems_timer_server_fire_when+0x5c> <== NOT EXECUTED 3001a488: e59f0070 ldr r0, [pc, #112] ; 3001a500 <rtems_timer_server_fire_when+0xfc><== NOT EXECUTED 3001a48c: e1a01006 mov r1, r6 <== NOT EXECUTED 3001a490: e1a0200d mov r2, sp <== NOT EXECUTED 3001a494: eb000aac bl 3001cf4c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a498: e59d9000 ldr r9, [sp] <== NOT EXECUTED 3001a49c: e1a0b000 mov fp, r0 <== NOT EXECUTED 3001a4a0: e3590000 cmp r9, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a4a4: 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 ) {
3001a4a8: 1affffed bne 3001a464 <rtems_timer_server_fire_when+0x60> <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001a4ac: e28b0010 add r0, fp, #16 <== NOT EXECUTED 3001a4b0: eb0012d6 bl 3001f010 <_Watchdog_Remove> <== NOT EXECUTED
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();
3001a4b4: e59a3000 ldr r3, [sl] <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
3001a4b8: e1a00004 mov r0, r4 <== 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();
3001a4bc: e0637007 rsb r7, r3, r7 <== NOT EXECUTED
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
3001a4c0: e3a03003 mov r3, #3 <== NOT EXECUTED 3001a4c4: 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();
(*timer_server->schedule_operation)( timer_server, the_timer );
3001a4c8: e1a0100b mov r1, fp <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001a4cc: e58b9018 str r9, [fp, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
3001a4d0: e58b502c str r5, [fp, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
3001a4d4: e58b6030 str r6, [fp, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3001a4d8: e58b8034 str r8, [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();
3001a4dc: e58b701c str r7, [fp, #28] <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
3001a4e0: e1a0e00f mov lr, pc <== NOT EXECUTED 3001a4e4: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3001a4e8: eb000df2 bl 3001dcb8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001a4ec: e1a00009 mov r0, r9 <== NOT EXECUTED 3001a4f0: eaffffdb b 3001a464 <rtems_timer_server_fire_when+0x60> <== NOT EXECUTED
3000af44 <rtems_verror>:
{
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
3000af44: e3100202 tst r0, #536870912 ; 0x20000000 <== NOT EXECUTED
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
3000af48: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000af4c: e1a04000 mov r4, r0 <== NOT EXECUTED
3000af50: e1a08001 mov r8, r1 <== NOT EXECUTED
3000af54: e1a06002 mov r6, r2 <== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
3000af58: 0a00000d beq 3000af94 <rtems_verror+0x50> <== NOT EXECUTED
if (rtems_panic_in_progress++)
3000af5c: e59f212c ldr r2, [pc, #300] ; 3000b090 <rtems_verror+0x14c><== NOT EXECUTED 3000af60: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000af64: e2813001 add r3, r1, #1 <== NOT EXECUTED 3000af68: e3510000 cmp r1, #0 <== NOT EXECUTED 3000af6c: e5823000 str r3, [r2] <== NOT EXECUTED 3000af70: 0a000004 beq 3000af88 <rtems_verror+0x44> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000af74: e59f3118 ldr r3, [pc, #280] ; 3000b094 <rtems_verror+0x150><== NOT EXECUTED 3000af78: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000af7c: e2811001 add r1, r1, #1 <== NOT EXECUTED 3000af80: e5831000 str r1, [r3] <== NOT EXECUTED
RTEMS_COMPILER_MEMORY_BARRIER();
3000af84: e5923000 ldr r3, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
3000af88: e3530002 cmp r3, #2 <== NOT EXECUTED
return 0;
3000af8c: c3a06000 movgt r6, #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)
3000af90: ca000024 bgt 3000b028 <rtems_verror+0xe4> <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
3000af94: e59f50fc ldr r5, [pc, #252] ; 3000b098 <rtems_verror+0x154><== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
3000af98: e3c47207 bic r7, r4, #1879048192 ; 0x70000000 <== NOT EXECUTED
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
3000af9c: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000afa0: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 3000afa4: eb0032f0 bl 30017b6c <fflush> <== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
3000afa8: e2144101 ands r4, r4, #1073741824 ; 0x40000000 <== NOT EXECUTED 3000afac: 1a00002a bne 3000b05c <rtems_verror+0x118> <== 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);
3000afb0: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000afb4: e1a02006 mov r2, r6 <== NOT EXECUTED 3000afb8: e1a01008 mov r1, r8 <== NOT EXECUTED 3000afbc: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000afc0: eb004e26 bl 3001e860 <vfprintf> <== NOT EXECUTED
if (status)
3000afc4: e3570000 cmp r7, #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);
3000afc8: e1a06000 mov r6, r0 <== NOT EXECUTED
if (status)
3000afcc: 1a000017 bne 3000b030 <rtems_verror+0xec> <== NOT EXECUTED
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
3000afd0: e3540000 cmp r4, #0 <== NOT EXECUTED 3000afd4: 0a00000b beq 3000b008 <rtems_verror+0xc4> <== NOT EXECUTED
if ((local_errno > 0) && *strerror(local_errno))
3000afd8: da000004 ble 3000aff0 <rtems_verror+0xac> <== NOT EXECUTED 3000afdc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000afe0: eb0036ca bl 30018b10 <strerror> <== NOT EXECUTED 3000afe4: e5d03000 ldrb r3, [r0] <== NOT EXECUTED 3000afe8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000afec: 1a00001d bne 3000b068 <rtems_verror+0x124> <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
3000aff0: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000aff4: e59f10a0 ldr r1, [pc, #160] ; 3000b09c <rtems_verror+0x158><== NOT EXECUTED 3000aff8: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000affc: e1a02004 mov r2, r4 <== NOT EXECUTED 3000b000: eb0033bf bl 30017f04 <fprintf> <== NOT EXECUTED 3000b004: e0866000 add r6, r6, r0 <== NOT EXECUTED
}
chars_written += fprintf(stderr, "\n");
3000b008: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000b00c: e59f108c ldr r1, [pc, #140] ; 3000b0a0 <rtems_verror+0x15c><== NOT EXECUTED 3000b010: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000b014: eb0033ba bl 30017f04 <fprintf> <== NOT EXECUTED
(void) fflush(stderr);
3000b018: 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");
3000b01c: e0806006 add r6, r0, r6 <== NOT EXECUTED
(void) fflush(stderr);
3000b020: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000b024: eb0032d0 bl 30017b6c <fflush> <== NOT EXECUTED
return chars_written;
}
3000b028: e1a00006 mov r0, r6 <== NOT EXECUTED
3000b02c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
3000b030: e59f3060 ldr r3, [pc, #96] ; 3000b098 <rtems_verror+0x154> <== NOT EXECUTED 3000b034: e1a00007 mov r0, r7 <== NOT EXECUTED 3000b038: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000b03c: e593700c ldr r7, [r3, #12] <== NOT EXECUTED 3000b040: ebffffbb bl 3000af34 <rtems_status_text> <== NOT EXECUTED 3000b044: e59f1058 ldr r1, [pc, #88] ; 3000b0a4 <rtems_verror+0x160> <== NOT EXECUTED 3000b048: e1a02000 mov r2, r0 <== NOT EXECUTED 3000b04c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000b050: eb0033ab bl 30017f04 <fprintf> <== NOT EXECUTED
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
3000b054: e0866000 add r6, r6, r0 <== NOT EXECUTED 3000b058: eaffffdc b 3000afd0 <rtems_verror+0x8c> <== NOT EXECUTED
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
3000b05c: eb0031cb bl 30017790 <__errno> <== NOT EXECUTED 3000b060: e5904000 ldr r4, [r0] <== NOT EXECUTED 3000b064: eaffffd1 b 3000afb0 <rtems_verror+0x6c> <== NOT EXECUTED
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
3000b068: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000b06c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b070: e593400c ldr r4, [r3, #12] <== NOT EXECUTED 3000b074: eb0036a5 bl 30018b10 <strerror> <== NOT EXECUTED 3000b078: e59f1028 ldr r1, [pc, #40] ; 3000b0a8 <rtems_verror+0x164> <== NOT EXECUTED 3000b07c: e1a02000 mov r2, r0 <== NOT EXECUTED 3000b080: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b084: eb00339e bl 30017f04 <fprintf> <== NOT EXECUTED 3000b088: e0866000 add r6, r6, r0 <== NOT EXECUTED 3000b08c: eaffffdd b 3000b008 <rtems_verror+0xc4> <== NOT EXECUTED
30006bc4 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
30006bc4: e92d4ff0 push {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;
30006bc8: e3a06000 mov r6, #0 <== NOT EXECUTED
int d;
for (;;) {
c = getc(fp);
30006bcc: e59f90f8 ldr r9, [pc, #248] ; 30006ccc <scanInt+0x108> <== NOT EXECUTED
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
30006bd0: e59f80f8 ldr r8, [pc, #248] ; 30006cd0 <scanInt+0x10c> <== NOT EXECUTED
return 0;
d = c - '0';
if ((i > (limit / 10))
30006bd4: e59fa0f8 ldr sl, [pc, #248] ; 30006cd4 <scanInt+0x110> <== NOT EXECUTED
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
30006bd8: e1a04000 mov r4, r0 <== NOT EXECUTED 30006bdc: e1a0b001 mov fp, r1 <== NOT EXECUTED
int c; unsigned int i = 0; unsigned int limit = INT_MAX;
30006be0: e3e07102 mvn r7, #-2147483648 ; 0x80000000 <== NOT EXECUTED
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
30006be4: e1a05006 mov r5, r6 <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
30006be8: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30006bec: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30006bf0: e3530000 cmp r3, #0 <== NOT EXECUTED 30006bf4: e5843004 str r3, [r4, #4] <== NOT EXECUTED 30006bf8: ba00001d blt 30006c74 <scanInt+0xb0> <== NOT EXECUTED 30006bfc: e5943000 ldr r3, [r4] <== NOT EXECUTED 30006c00: e4d30001 ldrb r0, [r3], #1 <== NOT EXECUTED
if (c == ':')
30006c04: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
30006c08: e5843000 str r3, [r4] <== NOT EXECUTED
if (c == ':')
30006c0c: 0a00001d beq 30006c88 <scanInt+0xc4> <== NOT EXECUTED
break;
if (sign == 0) {
30006c10: e3560000 cmp r6, #0 <== NOT EXECUTED 30006c14: 1a000004 bne 30006c2c <scanInt+0x68> <== NOT EXECUTED
if (c == '-') {
30006c18: e350002d cmp r0, #45 ; 0x2d <== NOT EXECUTED
sign = -1;
limit++;
30006c1c: 02877001 addeq r7, r7, #1 <== NOT EXECUTED
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
30006c20: 03e06000 mvneq r6, #0 <== NOT EXECUTED
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
30006c24: 0affffef beq 30006be8 <scanInt+0x24> <== NOT EXECUTED
sign = -1;
limit++;
continue;
}
sign = 1;
30006c28: e3a06001 mov r6, #1 <== NOT EXECUTED
}
if (!isdigit(c))
30006c2c: e5983000 ldr r3, [r8] <== NOT EXECUTED 30006c30: e0833000 add r3, r3, r0 <== NOT EXECUTED 30006c34: e5d33001 ldrb r3, [r3, #1] <== NOT EXECUTED 30006c38: e2133004 ands r3, r3, #4 <== NOT EXECUTED 30006c3c: 0a00001e beq 30006cbc <scanInt+0xf8> <== NOT EXECUTED
return 0;
d = c - '0';
if ((i > (limit / 10))
30006c40: e083279a umull r2, r3, sl, r7 <== NOT EXECUTED 30006c44: e15501a3 cmp r5, r3, lsr #3 <== NOT EXECUTED 30006c48: 8a000019 bhi 30006cb4 <scanInt+0xf0> <== NOT EXECUTED
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
30006c4c: e2400030 sub r0, r0, #48 ; 0x30 <== NOT EXECUTED 30006c50: 11a03105 lslne r3, r5, #2 <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
30006c54: 0a000011 beq 30006ca0 <scanInt+0xdc> <== NOT EXECUTED
return 0;
i = i * 10 + d;
30006c58: e0835005 add r5, r3, r5 <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
30006c5c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
30006c60: e0805085 add r5, r0, r5, lsl #1 <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
30006c64: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30006c68: e3530000 cmp r3, #0 <== NOT EXECUTED 30006c6c: e5843004 str r3, [r4, #4] <== NOT EXECUTED 30006c70: aaffffe1 bge 30006bfc <scanInt+0x38> <== NOT EXECUTED 30006c74: e5990000 ldr r0, [r9] <== NOT EXECUTED 30006c78: e1a01004 mov r1, r4 <== NOT EXECUTED 30006c7c: eb003675 bl 30014658 <__srget_r> <== NOT EXECUTED
if (c == ':')
30006c80: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED 30006c84: 1affffe1 bne 30006c10 <scanInt+0x4c> <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
30006c88: e3560000 cmp r6, #0 <== NOT EXECUTED 30006c8c: 0a00000c beq 30006cc4 <scanInt+0x100> <== NOT EXECUTED
return 0;
*val = i * sign;
30006c90: e0050596 mul r5, r6, r5 <== NOT EXECUTED
return 1;
30006c94: e3a00001 mov r0, #1 <== NOT EXECUTED
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
30006c98: e58b5000 str r5, [fp] <== NOT EXECUTED
return 1;
30006c9c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
30006ca0: e1a03105 lsl r3, r5, #2 <== NOT EXECUTED 30006ca4: e0832005 add r2, r3, r5 <== NOT EXECUTED 30006ca8: e0472082 sub r2, r7, r2, lsl #1 <== NOT EXECUTED 30006cac: e1500002 cmp r0, r2 <== NOT EXECUTED 30006cb0: 9affffe8 bls 30006c58 <scanInt+0x94> <== NOT EXECUTED
return 0;
30006cb4: e3a00000 mov r0, #0 <== NOT EXECUTED
30006cb8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
30006cbc: e1a00003 mov r0, r3 <== NOT EXECUTED
30006cc0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
30006cc4: e1a00006 mov r0, r6 <== NOT EXECUTED
*val = i * sign; return 1; }
30006cc8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30006cd8 <scanString>:
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
30006cd8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006cdc: e1a05002 mov r5, r2 <== NOT EXECUTED
int c;
*name = *bufp;
30006ce0: e5922000 ldr r2, [r2] <== NOT EXECUTED
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
30006ce4: e59d7018 ldr r7, [sp, #24] <== NOT EXECUTED
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
30006ce8: e59f60d8 ldr r6, [pc, #216] ; 30006dc8 <scanString+0xf0> <== NOT EXECUTED
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
30006cec: e1a04000 mov r4, r0 <== NOT EXECUTED 30006cf0: e1a08003 mov r8, r3 <== NOT EXECUTED
int c;
*name = *bufp;
30006cf4: e5812000 str r2, [r1] <== NOT EXECUTED 30006cf8: ea000013 b 30006d4c <scanString+0x74> <== NOT EXECUTED
for (;;) {
c = getc(fp);
30006cfc: e5943000 ldr r3, [r4] <== NOT EXECUTED 30006d00: e4d30001 ldrb r0, [r3], #1 <== NOT EXECUTED
if (c == ':') {
30006d04: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
30006d08: e5843000 str r3, [r4] <== NOT EXECUTED
if (c == ':') {
30006d0c: 0a000018 beq 30006d74 <scanString+0x9c> <== NOT EXECUTED
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
30006d10: e350000a cmp r0, #10 <== NOT EXECUTED 30006d14: 0a000025 beq 30006db0 <scanString+0xd8> <== NOT EXECUTED
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
30006d18: e3700001 cmn r0, #1 <== NOT EXECUTED 30006d1c: 0a000021 beq 30006da8 <scanString+0xd0> <== NOT EXECUTED
return 0;
if (*nleft < 2)
30006d20: e5983000 ldr r3, [r8] <== NOT EXECUTED 30006d24: e3530001 cmp r3, #1 <== NOT EXECUTED 30006d28: 9a000024 bls 30006dc0 <scanString+0xe8> <== NOT EXECUTED
return 0;
**bufp = c;
30006d2c: e5953000 ldr r3, [r5] <== NOT EXECUTED 30006d30: e5c30000 strb r0, [r3] <== NOT EXECUTED
++(*bufp);
30006d34: e5952000 ldr r2, [r5] <== NOT EXECUTED
--(*nleft);
30006d38: e5983000 ldr r3, [r8] <== NOT EXECUTED
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
30006d3c: e2822001 add r2, r2, #1 <== NOT EXECUTED
--(*nleft);
30006d40: e2433001 sub r3, r3, #1 <== NOT EXECUTED
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
30006d44: e5852000 str r2, [r5] <== NOT EXECUTED
--(*nleft);
30006d48: e5883000 str r3, [r8] <== NOT EXECUTED
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
30006d4c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30006d50: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30006d54: e3530000 cmp r3, #0 <== NOT EXECUTED 30006d58: e5843004 str r3, [r4, #4] <== NOT EXECUTED 30006d5c: aaffffe6 bge 30006cfc <scanString+0x24> <== NOT EXECUTED 30006d60: e5960000 ldr r0, [r6] <== NOT EXECUTED 30006d64: e1a01004 mov r1, r4 <== NOT EXECUTED 30006d68: eb00363a bl 30014658 <__srget_r> <== NOT EXECUTED
if (c == ':') {
30006d6c: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED 30006d70: 1affffe6 bne 30006d10 <scanString+0x38> <== NOT EXECUTED
if (nlFlag)
30006d74: e3570000 cmp r7, #0 <== NOT EXECUTED 30006d78: 1a00000a bne 30006da8 <scanString+0xd0> <== NOT EXECUTED
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
30006d7c: e5953000 ldr r3, [r5] <== NOT EXECUTED 30006d80: e3a02000 mov r2, #0 <== NOT EXECUTED 30006d84: e5c32000 strb r2, [r3] <== NOT EXECUTED
++(*bufp);
30006d88: e5952000 ldr r2, [r5] <== NOT EXECUTED
--(*nleft);
30006d8c: e5983000 ldr r3, [r8] <== NOT EXECUTED
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
30006d90: e2822001 add r2, r2, #1 <== NOT EXECUTED
--(*nleft);
30006d94: e2433001 sub r3, r3, #1 <== NOT EXECUTED
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
30006d98: e5852000 str r2, [r5] <== NOT EXECUTED
--(*nleft); return 1;
30006d9c: e3a00001 mov r0, #1 <== NOT EXECUTED
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
--(*nleft);
30006da0: e5883000 str r3, [r8] <== NOT EXECUTED
return 1;
30006da4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
return 0;
30006da8: e3a00000 mov r0, #0 <== NOT EXECUTED
30006dac: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
30006db0: e3570000 cmp r7, #0 <== NOT EXECUTED 30006db4: 1afffff0 bne 30006d7c <scanString+0xa4> <== NOT EXECUTED
return 0;
30006db8: e1a00007 mov r0, r7 <== NOT EXECUTED
30006dbc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
break;
}
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
30006dc0: e3a00000 mov r0, #0 <== NOT EXECUTED
} **bufp = '\0'; ++(*bufp); --(*nleft); return 1; }
30006dc4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30006dcc <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
30006dcc: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006dd0: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30006dd4: e28d5008 add r5, sp, #8 <== NOT EXECUTED 30006dd8: e28d4004 add r4, sp, #4 <== NOT EXECUTED
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
30006ddc: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 30006de0: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30006de4: e3a06000 mov r6, #0 <== NOT EXECUTED 30006de8: e1a02005 mov r2, r5 <== NOT EXECUTED 30006dec: e1a03004 mov r3, r4 <== NOT EXECUTED
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
30006df0: e1a07000 mov r7, r0 <== NOT EXECUTED 30006df4: e1a08001 mov r8, r1 <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30006df8: e58d6000 str r6, [sp] <== NOT EXECUTED 30006dfc: ebffffb5 bl 30006cd8 <scanString> <== NOT EXECUTED 30006e00: e3500000 cmp r0, #0 <== NOT EXECUTED 30006e04: 1a000001 bne 30006e10 <scangr+0x44> <== NOT EXECUTED
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
30006e08: e28dd014 add sp, sp, #20 <== NOT EXECUTED
30006e0c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
30006e10: e1a00007 mov r0, r7 <== NOT EXECUTED 30006e14: e2881004 add r1, r8, #4 <== NOT EXECUTED 30006e18: e1a02005 mov r2, r5 <== NOT EXECUTED 30006e1c: e1a03004 mov r3, r4 <== NOT EXECUTED 30006e20: e58d6000 str r6, [sp] <== NOT EXECUTED 30006e24: ebffffab bl 30006cd8 <scanString> <== NOT EXECUTED 30006e28: e3500000 cmp r0, #0 <== NOT EXECUTED 30006e2c: 0afffff5 beq 30006e08 <scangr+0x3c> <== NOT EXECUTED
|| !scanInt(fp, &grgid)
30006e30: e1a00007 mov r0, r7 <== NOT EXECUTED 30006e34: e28d1010 add r1, sp, #16 <== NOT EXECUTED 30006e38: ebffff61 bl 30006bc4 <scanInt> <== NOT EXECUTED 30006e3c: e3500000 cmp r0, #0 <== NOT EXECUTED 30006e40: 0afffff0 beq 30006e08 <scangr+0x3c> <== NOT EXECUTED
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
30006e44: e3a06001 mov r6, #1 <== NOT EXECUTED 30006e48: e1a00007 mov r0, r7 <== NOT EXECUTED 30006e4c: e28d100c add r1, sp, #12 <== NOT EXECUTED 30006e50: e1a02005 mov r2, r5 <== NOT EXECUTED 30006e54: e1a03004 mov r3, r4 <== NOT EXECUTED 30006e58: e58d6000 str r6, [sp] <== NOT EXECUTED 30006e5c: ebffff9d bl 30006cd8 <scanString> <== NOT EXECUTED 30006e60: e3500000 cmp r0, #0 <== NOT EXECUTED 30006e64: 0affffe7 beq 30006e08 <scangr+0x3c> <== NOT EXECUTED
return 0;
grp->gr_gid = grgid;
30006e68: e1dd31b0 ldrh r3, [sp, #16] <== NOT EXECUTED
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006e6c: e59d100c ldr r1, [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;
30006e70: e1c830b8 strh r3, [r8, #8] <== NOT EXECUTED
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006e74: e5d13000 ldrb r3, [r1] <== NOT EXECUTED 30006e78: e3530000 cmp r3, #0 <== NOT EXECUTED 30006e7c: 03a06017 moveq r6, #23 <== NOT EXECUTED 30006e80: 0a000007 beq 30006ea4 <scangr+0xd8> <== NOT EXECUTED 30006e84: e1a02001 mov r2, r1 <== NOT EXECUTED
if(*cp == ',')
30006e88: e353002c cmp r3, #44 ; 0x2c <== NOT EXECUTED
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006e8c: e5f23001 ldrb r3, [r2, #1]! <== NOT EXECUTED
if(*cp == ',')
memcount++;
30006e90: 02866001 addeq r6, r6, #1 <== NOT EXECUTED
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006e94: e3530000 cmp r3, #0 <== NOT EXECUTED 30006e98: 1afffffa bne 30006e88 <scangr+0xbc> <== NOT EXECUTED 30006e9c: e1a06106 lsl r6, r6, #2 <== NOT EXECUTED 30006ea0: e2866013 add r6, r6, #19 <== NOT EXECUTED
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
30006ea4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30006ea8: e1530006 cmp r3, r6 <== NOT EXECUTED
return 0;
30006eac: 33a00000 movcc r0, #0 <== NOT EXECUTED
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
30006eb0: 3affffd4 bcc 30006e08 <scangr+0x3c> <== NOT EXECUTED
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
30006eb4: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 30006eb8: e280000f add r0, r0, #15 <== NOT EXECUTED 30006ebc: e3c0000f bic r0, r0, #15 <== NOT EXECUTED 30006ec0: e588000c str r0, [r8, #12] <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
30006ec4: e5801000 str r1, [r0] <== NOT EXECUTED
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006ec8: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 30006ecc: e5d23000 ldrb r3, [r2] <== NOT EXECUTED 30006ed0: e3530000 cmp r3, #0 <== NOT EXECUTED 30006ed4: 0a000010 beq 30006f1c <scangr+0x150> <== NOT EXECUTED
}
/*
* Extract a single group record from the database
*/
static int scangr(
30006ed8: e2822001 add r2, r2, #1 <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006edc: e3a01001 mov r1, #1 <== NOT EXECUTED
if(*cp == ',') {
*cp = '\0';
30006ee0: e3a00000 mov r0, #0 <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',') {
30006ee4: e353002c cmp r3, #44 ; 0x2c <== NOT EXECUTED
*cp = '\0';
30006ee8: 05420001 strbeq r0, [r2, #-1] <== NOT EXECUTED
grp->gr_mem[memcount++] = cp + 1;
30006eec: 0598300c ldreq r3, [r8, #12] <== NOT EXECUTED 30006ef0: 07832101 streq r2, [r3, r1, lsl #2] <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006ef4: e4d23001 ldrb r3, [r2], #1 <== NOT EXECUTED
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
30006ef8: 02811001 addeq r1, r1, #1 <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006efc: e3530000 cmp r3, #0 <== NOT EXECUTED 30006f00: 1afffff7 bne 30006ee4 <scangr+0x118> <== NOT EXECUTED 30006f04: e598000c ldr r0, [r8, #12] <== NOT EXECUTED 30006f08: e1a01101 lsl r1, r1, #2 <== NOT EXECUTED
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
30006f0c: e3a03000 mov r3, #0 <== NOT EXECUTED 30006f10: e7803001 str r3, [r0, r1] <== NOT EXECUTED
return 1;
30006f14: e3a00001 mov r0, #1 <== NOT EXECUTED 30006f18: eaffffba b 30006e08 <scangr+0x3c> <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006f1c: e3a01004 mov r1, #4 <== NOT EXECUTED 30006f20: eafffff9 b 30006f0c <scangr+0x140> <== NOT EXECUTED
30006f24 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
30006f24: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006f28: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
30006f2c: e28d5008 add r5, sp, #8 <== NOT EXECUTED 30006f30: e28d4004 add r4, sp, #4 <== NOT EXECUTED
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
30006f34: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 30006f38: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
30006f3c: e3a06000 mov r6, #0 <== NOT EXECUTED 30006f40: e1a02005 mov r2, r5 <== NOT EXECUTED 30006f44: e1a03004 mov r3, r4 <== NOT EXECUTED
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
30006f48: e1a07000 mov r7, r0 <== NOT EXECUTED 30006f4c: e1a08001 mov r8, r1 <== NOT EXECUTED
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
30006f50: e58d6000 str r6, [sp] <== NOT EXECUTED 30006f54: ebffff5f bl 30006cd8 <scanString> <== NOT EXECUTED 30006f58: e3500000 cmp r0, #0 <== NOT EXECUTED 30006f5c: 1a000001 bne 30006f68 <scanpw+0x44> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
}
30006f60: e28dd014 add sp, sp, #20 <== NOT EXECUTED
30006f64: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
30006f68: e1a00007 mov r0, r7 <== NOT EXECUTED 30006f6c: e2881004 add r1, r8, #4 <== NOT EXECUTED 30006f70: e1a02005 mov r2, r5 <== NOT EXECUTED 30006f74: e1a03004 mov r3, r4 <== NOT EXECUTED 30006f78: e58d6000 str r6, [sp] <== NOT EXECUTED 30006f7c: ebffff55 bl 30006cd8 <scanString> <== NOT EXECUTED 30006f80: e3500000 cmp r0, #0 <== NOT EXECUTED 30006f84: 0afffff5 beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanInt(fp, &pwuid)
30006f88: e1a00007 mov r0, r7 <== NOT EXECUTED 30006f8c: e28d1010 add r1, sp, #16 <== NOT EXECUTED 30006f90: ebffff0b bl 30006bc4 <scanInt> <== NOT EXECUTED 30006f94: e3500000 cmp r0, #0 <== NOT EXECUTED 30006f98: 0afffff0 beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanInt(fp, &pwgid)
30006f9c: e1a00007 mov r0, r7 <== NOT EXECUTED 30006fa0: e28d100c add r1, sp, #12 <== NOT EXECUTED 30006fa4: ebffff06 bl 30006bc4 <scanInt> <== NOT EXECUTED 30006fa8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006fac: 0affffeb beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
30006fb0: e1a00007 mov r0, r7 <== NOT EXECUTED 30006fb4: e288100c add r1, r8, #12 <== NOT EXECUTED 30006fb8: e1a02005 mov r2, r5 <== NOT EXECUTED 30006fbc: e1a03004 mov r3, r4 <== NOT EXECUTED 30006fc0: e58d6000 str r6, [sp] <== NOT EXECUTED 30006fc4: ebffff43 bl 30006cd8 <scanString> <== NOT EXECUTED 30006fc8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006fcc: 0affffe3 beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
30006fd0: e1a00007 mov r0, r7 <== NOT EXECUTED 30006fd4: e2881010 add r1, r8, #16 <== NOT EXECUTED 30006fd8: e1a02005 mov r2, r5 <== NOT EXECUTED 30006fdc: e1a03004 mov r3, r4 <== NOT EXECUTED 30006fe0: e58d6000 str r6, [sp] <== NOT EXECUTED 30006fe4: ebffff3b bl 30006cd8 <scanString> <== NOT EXECUTED 30006fe8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006fec: 0affffdb beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
30006ff0: e1a00007 mov r0, r7 <== NOT EXECUTED 30006ff4: e2881014 add r1, r8, #20 <== NOT EXECUTED 30006ff8: e1a02005 mov r2, r5 <== NOT EXECUTED 30006ffc: e1a03004 mov r3, r4 <== NOT EXECUTED 30007000: e58d6000 str r6, [sp] <== NOT EXECUTED 30007004: ebffff33 bl 30006cd8 <scanString> <== NOT EXECUTED 30007008: e3500000 cmp r0, #0 <== NOT EXECUTED 3000700c: 0affffd3 beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
30007010: e1a03004 mov r3, r4 <== NOT EXECUTED 30007014: e3a06001 mov r6, #1 <== NOT EXECUTED 30007018: e1a00007 mov r0, r7 <== NOT EXECUTED 3000701c: e2881018 add r1, r8, #24 <== NOT EXECUTED 30007020: e1a02005 mov r2, r5 <== NOT EXECUTED 30007024: e58d6000 str r6, [sp] <== NOT EXECUTED 30007028: ebffff2a bl 30006cd8 <scanString> <== NOT EXECUTED 3000702c: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
pwd->pw_uid = pwuid;
30007030: 11dd31b0 ldrhne r3, [sp, #16] <== NOT EXECUTED
pwd->pw_gid = pwgid; return 1;
30007034: 11a00006 movne r0, r6 <== 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;
30007038: 11c830b8 strhne r3, [r8, #8] <== NOT EXECUTED
pwd->pw_gid = pwgid;
3000703c: 11dd30bc ldrhne r3, [sp, #12] <== NOT EXECUTED 30007040: 11c830ba strhne r3, [r8, #10] <== NOT EXECUTED
return 1;
30007044: eaffffc5 b 30006f60 <scanpw+0x3c> <== NOT EXECUTED
3000a5a8 <sched_get_priority_max>:
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
3000a5a8: e3500004 cmp r0, #4 <== NOT EXECUTED
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
3000a5ac: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
switch ( policy ) {
3000a5b0: 9a000004 bls 3000a5c8 <sched_get_priority_max+0x20> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000a5b4: eb002287 bl 30012fd8 <__errno> <== NOT EXECUTED
3000a5b8: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a5bc: e5803000 str r3, [r0] <== NOT EXECUTED
3000a5c0: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a5c4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
3000a5c8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a5cc: e1a00013 lsl r0, r3, r0 <== NOT EXECUTED 3000a5d0: e3100017 tst r0, #23 <== NOT EXECUTED 3000a5d4: 0afffff6 beq 3000a5b4 <sched_get_priority_max+0xc> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
3000a5d8: e59f3008 ldr r3, [pc, #8] ; 3000a5e8 <sched_get_priority_max+0x40><== NOT EXECUTED 3000a5dc: e5d30000 ldrb r0, [r3] <== NOT EXECUTED 3000a5e0: e2400001 sub r0, r0, #1 <== NOT EXECUTED
}
3000a5e4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a5ec <sched_get_priority_min>:
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
3000a5ec: e3500004 cmp r0, #4 <== NOT EXECUTED
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
3000a5f0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
switch ( policy ) {
3000a5f4: 9a000004 bls 3000a60c <sched_get_priority_min+0x20> <== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000a5f8: eb002276 bl 30012fd8 <__errno> <== NOT EXECUTED
3000a5fc: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a600: e5803000 str r3, [r0] <== NOT EXECUTED
3000a604: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a608: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
3000a60c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a610: e1a00013 lsl r0, r3, r0 <== NOT EXECUTED 3000a614: e3100017 tst r0, #23 <== NOT EXECUTED 3000a618: 0afffff6 beq 3000a5f8 <sched_get_priority_min+0xc> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
3000a61c: e1a00003 mov r0, r3 <== NOT EXECUTED
}
3000a620: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009a74 <sched_getparam>:
int sched_getparam(
pid_t pid __attribute__((unused)),
struct sched_param *param __attribute__((unused))
)
{
30009a74: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009a78: eb0023d6 bl 300129d8 <__errno> <== NOT EXECUTED 30009a7c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009a80: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009a84: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009a88: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009a8c <sched_getscheduler>:
#include <rtems/posix/time.h>
int sched_getscheduler(
pid_t pid __attribute__((unused))
)
{
30009a8c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009a90: eb0023d0 bl 300129d8 <__errno> <== NOT EXECUTED 30009a94: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009a98: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009a9c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009aa0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a624 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
3000a624: e92d4010 push {r4, lr} <== NOT EXECUTED
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
3000a628: e2504000 subs r4, r0, #0 <== NOT EXECUTED
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
3000a62c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
3000a630: 1a000007 bne 3000a654 <sched_rr_get_interval+0x30> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
3000a634: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a638: 0a00000f beq 3000a67c <sched_rr_get_interval+0x58> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
3000a63c: e59f304c ldr r3, [pc, #76] ; 3000a690 <sched_rr_get_interval+0x6c><== NOT EXECUTED 3000a640: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000a644: eb000e08 bl 3000de6c <_Timespec_From_ticks> <== NOT EXECUTED
return 0;
3000a648: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000a64c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a650: e8bd8010 pop {r4, pc} <== NOT EXECUTED
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
3000a654: e58d1000 str r1, [sp] <== NOT EXECUTED 3000a658: ebfff1f5 bl 30006e34 <getpid> <== NOT EXECUTED 3000a65c: e1500004 cmp r0, r4 <== NOT EXECUTED 3000a660: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000a664: 0afffff2 beq 3000a634 <sched_rr_get_interval+0x10> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ESRCH );
3000a668: eb00225a bl 30012fd8 <__errno> <== NOT EXECUTED 3000a66c: e3a03003 mov r3, #3 <== NOT EXECUTED 3000a670: e5803000 str r3, [r0] <== NOT EXECUTED 3000a674: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000a678: eafffff3 b 3000a64c <sched_rr_get_interval+0x28> <== NOT EXECUTED
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
3000a67c: eb002255 bl 30012fd8 <__errno> <== NOT EXECUTED 3000a680: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a684: e5803000 str r3, [r0] <== NOT EXECUTED 3000a688: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000a68c: eaffffee b 3000a64c <sched_rr_get_interval+0x28> <== NOT EXECUTED
30009aa4 <sched_setparam>:
int sched_setparam(
pid_t pid __attribute__((unused)),
const struct sched_param *param __attribute__((unused))
)
{
30009aa4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009aa8: eb0023ca bl 300129d8 <__errno> <== NOT EXECUTED 30009aac: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009ab0: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009ab4: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009ab8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009abc <sched_setscheduler>:
int sched_setscheduler(
pid_t pid __attribute__((unused)),
int policy __attribute__((unused)),
const struct sched_param *param __attribute__((unused))
)
{
30009abc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009ac0: eb0023c4 bl 300129d8 <__errno> <== NOT EXECUTED 30009ac4: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009ac8: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009acc: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009ad0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c990 <sem_close>:
*/
int sem_close(
sem_t *sem
)
{
3000c990: e92d4010 push {r4, lr} <== NOT EXECUTED
3000c994: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
_Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location );
3000c998: e5901000 ldr r1, [r0] <== NOT EXECUTED 3000c99c: e1a0200d mov r2, sp <== NOT EXECUTED 3000c9a0: e59f0040 ldr r0, [pc, #64] ; 3000c9e8 <sem_close+0x58> <== NOT EXECUTED 3000c9a4: eb000880 bl 3000ebac <_Objects_Get> <== NOT EXECUTED
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000c9a8: e59d4000 ldr r4, [sp] <== NOT EXECUTED 3000c9ac: e3540000 cmp r4, #0 <== NOT EXECUTED 3000c9b0: 0a000005 beq 3000c9cc <sem_close+0x3c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000c9b4: eb00262b bl 30016268 <__errno> <== NOT EXECUTED 3000c9b8: e3a03016 mov r3, #22 <== NOT EXECUTED 3000c9bc: e5803000 str r3, [r0] <== NOT EXECUTED 3000c9c0: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000c9c4: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c9c8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_semaphore->open_count -= 1;
3000c9cc: e5902018 ldr r2, [r0, #24] <== NOT EXECUTED 3000c9d0: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000c9d4: e5802018 str r2, [r0, #24] <== NOT EXECUTED
_POSIX_Semaphore_Delete( the_semaphore );
3000c9d8: eb001a2d bl 30013294 <_POSIX_Semaphore_Delete> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000c9dc: eb000bcd bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000c9e0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c9e4: eafffff6 b 3000c9c4 <sem_close+0x34> <== NOT EXECUTED
3000c9ec <sem_destroy>:
*/
int sem_destroy(
sem_t *sem
)
{
3000c9ec: e92d4010 push {r4, lr} <== NOT EXECUTED
3000c9f0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000c9f4: e5901000 ldr r1, [r0] <== NOT EXECUTED
3000c9f8: e1a0200d mov r2, sp <== NOT EXECUTED
3000c9fc: e59f0058 ldr r0, [pc, #88] ; 3000ca5c <sem_destroy+0x70> <== NOT EXECUTED
3000ca00: eb000869 bl 3000ebac <_Objects_Get> <== NOT EXECUTED
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000ca04: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000ca08: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ca0c: 0a000005 beq 3000ca28 <sem_destroy+0x3c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000ca10: eb002614 bl 30016268 <__errno> <== NOT EXECUTED 3000ca14: e3a03016 mov r3, #22 <== NOT EXECUTED 3000ca18: e5803000 str r3, [r0] <== NOT EXECUTED 3000ca1c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000ca20: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000ca24: e8bd8010 pop {r4, pc} <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
3000ca28: e5d04014 ldrb r4, [r0, #20] <== NOT EXECUTED 3000ca2c: e3540000 cmp r4, #0 <== NOT EXECUTED 3000ca30: 1a000003 bne 3000ca44 <sem_destroy+0x58> <== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
_POSIX_Semaphore_Delete( the_semaphore );
3000ca34: eb001a16 bl 30013294 <_POSIX_Semaphore_Delete> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000ca38: eb000bb6 bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000ca3c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ca40: eafffff6 b 3000ca20 <sem_destroy+0x34> <== NOT EXECUTED
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
_Thread_Enable_dispatch();
3000ca44: eb000bb3 bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000ca48: eb002606 bl 30016268 <__errno> <== NOT EXECUTED 3000ca4c: e3a03016 mov r3, #22 <== NOT EXECUTED 3000ca50: e5803000 str r3, [r0] <== NOT EXECUTED 3000ca54: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000ca58: eafffff0 b 3000ca20 <sem_destroy+0x34> <== NOT EXECUTED
3000ca60 <sem_getvalue>:
int sem_getvalue(
sem_t *sem,
int *sval
)
{
3000ca60: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000ca64: e5903000 ldr r3, [r0] <== NOT EXECUTED
3000ca68: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000ca6c: e1a04001 mov r4, r1 <== NOT EXECUTED
3000ca70: e59f0040 ldr r0, [pc, #64] ; 3000cab8 <sem_getvalue+0x58> <== NOT EXECUTED
3000ca74: e1a01003 mov r1, r3 <== NOT EXECUTED
3000ca78: e1a0200d mov r2, sp <== NOT EXECUTED
3000ca7c: eb00084a bl 3000ebac <_Objects_Get> <== NOT EXECUTED
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000ca80: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000ca84: e3550000 cmp r5, #0 <== NOT EXECUTED 3000ca88: 0a000005 beq 3000caa4 <sem_getvalue+0x44> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000ca8c: eb0025f5 bl 30016268 <__errno> <== NOT EXECUTED 3000ca90: e3a03016 mov r3, #22 <== NOT EXECUTED 3000ca94: e5803000 str r3, [r0] <== NOT EXECUTED 3000ca98: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000ca9c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000caa0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore );
3000caa4: e5903064 ldr r3, [r0, #100] ; 0x64 <== NOT EXECUTED 3000caa8: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000caac: eb000b99 bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000cab0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000cab4: eafffff8 b 3000ca9c <sem_getvalue+0x3c> <== NOT EXECUTED
3000cabc <sem_init>:
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
3000cabc: e92d4010 push {r4, lr} <== NOT EXECUTED
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
3000cac0: e2504000 subs r4, r0, #0 <== NOT EXECUTED
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
3000cac4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
3000cac8: 0a000008 beq 3000caf0 <sem_init+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
status = _POSIX_Semaphore_Create_support(
3000cacc: e1a0300d mov r3, sp <== NOT EXECUTED 3000cad0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cad4: eb0019ad bl 30013190 <_POSIX_Semaphore_Create_support> <== NOT EXECUTED
pshared,
value,
&the_semaphore
);
if ( status != -1 )
3000cad8: e3700001 cmn r0, #1 <== NOT EXECUTED
*sem = the_semaphore->Object.id;
3000cadc: 159d3000 ldrne r3, [sp] <== NOT EXECUTED 3000cae0: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED 3000cae4: 15843000 strne r3, [r4] <== NOT EXECUTED
return status;
}
3000cae8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000caec: e8bd8010 pop {r4, pc} <== NOT EXECUTED
{
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
rtems_set_errno_and_return_minus_one( EINVAL );
3000caf0: eb0025dc bl 30016268 <__errno> <== NOT EXECUTED 3000caf4: e3a03016 mov r3, #22 <== NOT EXECUTED 3000caf8: e5803000 str r3, [r0] <== NOT EXECUTED 3000cafc: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000cb00: eafffff8 b 3000cae8 <sem_init+0x2c> <== NOT EXECUTED
3000cb04 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
3000cb04: e92d000e push {r1, r2, r3} <== NOT EXECUTED
3000cb08: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000cb0c: e59f30f0 ldr r3, [pc, #240] ; 3000cc04 <sem_open+0x100> <== NOT EXECUTED 3000cb10: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 3000cb14: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000cb18: e59d4028 ldr r4, [sp, #40] ; 0x28 <== NOT EXECUTED 3000cb1c: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000cb20: e5832000 str r2, [r3] <== NOT EXECUTED 3000cb24: e1a05000 mov r5, r0 <== NOT EXECUTED
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
3000cb28: e2146c02 ands r6, r4, #512 ; 0x200 <== NOT EXECUTED
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
3000cb2c: 128d3034 addne r3, sp, #52 ; 0x34 <== NOT EXECUTED
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
3000cb30: 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 );
3000cb34: 158d300c strne r3, [sp, #12] <== NOT EXECUTED 3000cb38: 159d7030 ldrne r7, [sp, #48] ; 0x30 <== NOT EXECUTED
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
3000cb3c: 01a07006 moveq r7, r6 <== 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 );
3000cb40: eb0019e7 bl 300132e4 <_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 ) {
3000cb44: e2508000 subs r8, r0, #0 <== NOT EXECUTED 3000cb48: 0a000008 beq 3000cb70 <sem_open+0x6c> <== 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) ) ) {
3000cb4c: e3580002 cmp r8, #2 <== NOT EXECUTED 3000cb50: 1a000001 bne 3000cb5c <sem_open+0x58> <== NOT EXECUTED 3000cb54: e3560000 cmp r6, #0 <== NOT EXECUTED 3000cb58: 1a000018 bne 3000cbc0 <sem_open+0xbc> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000cb5c: eb000b6d bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
3000cb60: eb0025c0 bl 30016268 <__errno> <== NOT EXECUTED 3000cb64: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000cb68: e5808000 str r8, [r0] <== NOT EXECUTED 3000cb6c: ea00000e b 3000cbac <sem_open+0xa8> <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
3000cb70: e2044c0a and r4, r4, #2560 ; 0xa00 <== NOT EXECUTED 3000cb74: e3540c0a cmp r4, #2560 ; 0xa00 <== NOT EXECUTED 3000cb78: 0a00001b beq 3000cbec <sem_open+0xe8> <== NOT EXECUTED 3000cb7c: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3000cb80: e1a0200d mov r2, sp <== NOT EXECUTED 3000cb84: e59f007c ldr r0, [pc, #124] ; 3000cc08 <sem_open+0x104> <== NOT EXECUTED 3000cb88: eb000807 bl 3000ebac <_Objects_Get> <== NOT EXECUTED
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
3000cb8c: 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 );
3000cb90: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
the_semaphore->open_count += 1;
3000cb94: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000cb98: e5803018 str r3, [r0, #24] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000cb9c: eb000b5d bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000cba0: eb000b5c bl 3000f918 <_Thread_Enable_dispatch> <== 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;
3000cba4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3000cba8: e2833008 add r3, r3, #8 <== NOT EXECUTED
#endif return id; }
3000cbac: e1a00003 mov r0, r3 <== NOT EXECUTED
3000cbb0: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000cbb4: e8bd41f0 pop {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000cbb8: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000cbbc: e12fff1e bx lr <== 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(
3000cbc0: e28d3004 add r3, sp, #4 <== NOT EXECUTED 3000cbc4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000cbc8: e1a02007 mov r2, r7 <== NOT EXECUTED 3000cbcc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000cbd0: eb00196e bl 30013190 <_POSIX_Semaphore_Create_support> <== NOT EXECUTED 3000cbd4: e1a04000 mov r4, r0 <== NOT EXECUTED
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
3000cbd8: eb000b4e bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( status == -1 )
3000cbdc: e3740001 cmn r4, #1 <== NOT EXECUTED
return SEM_FAILED;
3000cbe0: 01a03004 moveq r3, r4 <== NOT EXECUTED
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
3000cbe4: 1affffee bne 3000cba4 <sem_open+0xa0> <== NOT EXECUTED 3000cbe8: eaffffef b 3000cbac <sem_open+0xa8> <== NOT EXECUTED
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
3000cbec: eb000b49 bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
3000cbf0: eb00259c bl 30016268 <__errno> <== NOT EXECUTED 3000cbf4: e3a03011 mov r3, #17 <== NOT EXECUTED 3000cbf8: e5803000 str r3, [r0] <== NOT EXECUTED 3000cbfc: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000cc00: eaffffe9 b 3000cbac <sem_open+0xa8> <== NOT EXECUTED
3000cc0c <sem_post>:
*/
int sem_post(
sem_t *sem
)
{
3000cc0c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000cc10: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000cc14: e5901000 ldr r1, [r0] <== NOT EXECUTED
3000cc18: e1a0200d mov r2, sp <== NOT EXECUTED
3000cc1c: e59f0044 ldr r0, [pc, #68] ; 3000cc68 <sem_post+0x5c> <== NOT EXECUTED
3000cc20: eb0007e1 bl 3000ebac <_Objects_Get> <== NOT EXECUTED
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
3000cc24: e59d4000 ldr r4, [sp] <== NOT EXECUTED 3000cc28: e1a03000 mov r3, r0 <== NOT EXECUTED 3000cc2c: e3540000 cmp r4, #0 <== NOT EXECUTED 3000cc30: 0a000005 beq 3000cc4c <sem_post+0x40> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000cc34: eb00258b bl 30016268 <__errno> <== NOT EXECUTED 3000cc38: e3a03016 mov r3, #22 <== NOT EXECUTED 3000cc3c: e5803000 str r3, [r0] <== NOT EXECUTED 3000cc40: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000cc44: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000cc48: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Surrender(
3000cc4c: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED 3000cc50: e1a02004 mov r2, r4 <== NOT EXECUTED 3000cc54: e280001c add r0, r0, #28 <== NOT EXECUTED 3000cc58: eb00052e bl 3000e118 <_CORE_semaphore_Surrender> <== NOT EXECUTED
NULL /* XXX need to define a routine to handle this case */
#else
NULL
#endif
);
_Thread_Enable_dispatch();
3000cc5c: eb000b2d bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000cc60: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cc64: eafffff6 b 3000cc44 <sem_post+0x38> <== NOT EXECUTED
3000cc6c <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
3000cc6c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000cc70: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000cc74: 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 );
3000cc78: e1a00001 mov r0, r1 <== NOT EXECUTED 3000cc7c: e1a0100d mov r1, sp <== NOT EXECUTED 3000cc80: eb0016a4 bl 30012718 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
3000cc84: e3500003 cmp r0, #3 <== NOT EXECUTED 3000cc88: 0a000005 beq 3000cca4 <sem_timedwait+0x38> <== NOT EXECUTED
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
3000cc8c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cc90: e3a01000 mov r1, #0 <== NOT EXECUTED 3000cc94: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000cc98: eb0019b9 bl 30013384 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
3000cc9c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000cca0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
3000cca4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cca8: e3a01001 mov r1, #1 <== NOT EXECUTED 3000ccac: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000ccb0: eb0019b3 bl 30013384 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED 3000ccb4: eafffff8 b 3000cc9c <sem_timedwait+0x30> <== NOT EXECUTED
3000ccb8 <sem_trywait>:
int sem_trywait(
sem_t *sem
)
{
return _POSIX_Semaphore_Wait_support(sem, false, THREAD_QUEUE_WAIT_FOREVER);
3000ccb8: e3a01000 mov r1, #0 <== NOT EXECUTED 3000ccbc: e1a02001 mov r2, r1 <== NOT EXECUTED 3000ccc0: ea0019af b 30013384 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
3000ccc4 <sem_unlink>:
*/
int sem_unlink(
const char *name
)
{
3000ccc4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000ccc8: e59f3068 ldr r3, [pc, #104] ; 3000cd38 <sem_unlink+0x74> <== NOT EXECUTED
3000cccc: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000ccd0: e5932000 ldr r2, [r3] <== NOT EXECUTED
3000ccd4: e2822001 add r2, r2, #1 <== NOT EXECUTED
3000ccd8: 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 );
3000ccdc: e1a0100d mov r1, sp <== NOT EXECUTED 3000cce0: eb00197f bl 300132e4 <_POSIX_Semaphore_Name_to_id> <== NOT EXECUTED
if ( status != 0 ) {
3000cce4: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3000cce8: 1a00000d bne 3000cd24 <sem_unlink+0x60> <== NOT EXECUTED
_POSIX_Semaphore_Namespace_remove( the_semaphore );
_POSIX_Semaphore_Delete( the_semaphore );
_Thread_Enable_dispatch();
return 0;
}
3000ccec: e59f0048 ldr r0, [pc, #72] ; 3000cd3c <sem_unlink+0x78> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
3000ccf0: e1dd20b0 ldrh r2, [sp] <== NOT EXECUTED 3000ccf4: 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(
3000ccf8: e7934102 ldr r4, [r3, r2, lsl #2] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Namespace_remove (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Namespace_remove(
3000ccfc: e1a01004 mov r1, r4 <== NOT EXECUTED
&_POSIX_Semaphore_Information,
_Objects_Get_index( the_semaphore_id )
);
the_semaphore->linked = false;
3000cd00: e5c45015 strb r5, [r4, #21] <== NOT EXECUTED 3000cd04: eb0007ff bl 3000ed08 <_Objects_Namespace_remove> <== NOT EXECUTED
_POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore );
3000cd08: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cd0c: eb001960 bl 30013294 <_POSIX_Semaphore_Delete> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000cd10: eb000b00 bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000cd14: e1a03005 mov r3, r5 <== NOT EXECUTED
}
3000cd18: e1a00003 mov r0, r3 <== NOT EXECUTED
3000cd1c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000cd20: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_Thread_Disable_dispatch();
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
if ( status != 0 ) {
_Thread_Enable_dispatch();
3000cd24: eb000afb bl 3000f918 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( status );
3000cd28: eb00254e bl 30016268 <__errno> <== NOT EXECUTED 3000cd2c: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000cd30: e5805000 str r5, [r0] <== NOT EXECUTED 3000cd34: eafffff7 b 3000cd18 <sem_unlink+0x54> <== NOT EXECUTED
3000cd40 <sem_wait>:
int sem_wait(
sem_t *sem
)
{
return _POSIX_Semaphore_Wait_support( sem, true, THREAD_QUEUE_WAIT_FOREVER );
3000cd40: e3a01001 mov r1, #1 <== NOT EXECUTED 3000cd44: e3a02000 mov r2, #0 <== NOT EXECUTED 3000cd48: ea00198d b 30013384 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
30009598 <seteuid>:
#include <rtems/userenv.h>
int seteuid( uid_t euid )
{
_POSIX_types_Euid = euid;
30009598: e59f300c ldr r3, [pc, #12] ; 300095ac <seteuid+0x14> <== NOT EXECUTED 3000959c: e5933000 ldr r3, [r3] <== NOT EXECUTED 300095a0: e1c303b6 strh r0, [r3, #54] ; 0x36 <== NOT EXECUTED
return 0; }
300095a4: e3a00000 mov r0, #0 <== NOT EXECUTED 300095a8: e12fff1e bx lr <== NOT EXECUTED
300083c8 <setgid>:
*/
int setgid(
gid_t gid
)
{
_POSIX_types_Gid = gid;
300083c8: e59f300c ldr r3, [pc, #12] ; 300083dc <setgid+0x14> <== NOT EXECUTED 300083cc: e5933000 ldr r3, [r3] <== NOT EXECUTED 300083d0: e1c303b4 strh r0, [r3, #52] ; 0x34 <== NOT EXECUTED
return 0; }
300083d4: e3a00000 mov r0, #0 <== NOT EXECUTED 300083d8: e12fff1e bx lr <== NOT EXECUTED
30007568 <setgrent>:
void setgrent(void)
{
30007568: e92d4010 push {r4, lr} <== NOT EXECUTED
init_etc_passwd_group();
if (group_fp != NULL)
3000756c: e59f4020 ldr r4, [pc, #32] ; 30007594 <setgrent+0x2c> <== NOT EXECUTED
return &grent;
}
void setgrent(void)
{
init_etc_passwd_group();
30007570: ebfffeb4 bl 30007048 <init_etc_passwd_group> <== NOT EXECUTED
if (group_fp != NULL)
30007574: e59401c4 ldr r0, [r4, #452] ; 0x1c4 <== NOT EXECUTED 30007578: e3500000 cmp r0, #0 <== NOT EXECUTED
fclose(group_fp);
3000757c: 1b002f05 blne 30013198 <fclose> <== NOT EXECUTED
group_fp = fopen("/etc/group", "r");
30007580: e59f0010 ldr r0, [pc, #16] ; 30007598 <setgrent+0x30> <== NOT EXECUTED 30007584: e59f1010 ldr r1, [pc, #16] ; 3000759c <setgrent+0x34> <== NOT EXECUTED 30007588: eb0030d9 bl 300138f4 <fopen> <== NOT EXECUTED 3000758c: e58401c4 str r0, [r4, #452] ; 0x1c4 <== NOT EXECUTED
}
30007590: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300099a0 <setitimer>:
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
if ( !value )
300099a0: e3510000 cmp r1, #0 <== NOT EXECUTED
int setitimer(
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
300099a4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !value )
300099a8: 0a00000d beq 300099e4 <setitimer+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
300099ac: e3520000 cmp r2, #0 <== NOT EXECUTED 300099b0: 0a00000b beq 300099e4 <setitimer+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
300099b4: e3500002 cmp r0, #2 <== NOT EXECUTED 300099b8: 9a000004 bls 300099d0 <setitimer+0x30> <== NOT EXECUTED
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
300099bc: eb0023bf bl 300128c0 <__errno> <== NOT EXECUTED 300099c0: e3a03016 mov r3, #22 <== NOT EXECUTED 300099c4: e5803000 str r3, [r0] <== NOT EXECUTED
}
300099c8: e3e00000 mvn r0, #0 <== NOT EXECUTED
300099cc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
switch ( which ) {
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
300099d0: eb0023ba bl 300128c0 <__errno> <== NOT EXECUTED 300099d4: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300099d8: e5803000 str r3, [r0] <== NOT EXECUTED
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
300099dc: e3e00000 mvn r0, #0 <== NOT EXECUTED
300099e0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
if ( !value )
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
rtems_set_errno_and_return_minus_one( EFAULT );
300099e4: eb0023b5 bl 300128c0 <__errno> <== NOT EXECUTED 300099e8: e3a0300e mov r3, #14 <== NOT EXECUTED 300099ec: e5803000 str r3, [r0] <== NOT EXECUTED 300099f0: eafffff4 b 300099c8 <setitimer+0x28> <== NOT EXECUTED
300083e0 <setpgid>:
int setpgid(
pid_t pid __attribute__((unused)),
pid_t pgid __attribute__((unused))
)
{
300083e0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
300083e4: eb002b1d bl 30013060 <__errno> <== NOT EXECUTED 300083e8: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300083ec: e5803000 str r3, [r0] <== NOT EXECUTED
}
300083f0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300083f4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300073fc <setpwent>:
void setpwent(void)
{
300073fc: e92d4010 push {r4, lr} <== NOT EXECUTED
init_etc_passwd_group();
if (passwd_fp != NULL)
30007400: e59f4020 ldr r4, [pc, #32] ; 30007428 <setpwent+0x2c> <== NOT EXECUTED
return &pwent;
}
void setpwent(void)
{
init_etc_passwd_group();
30007404: ebffff0f bl 30007048 <init_etc_passwd_group> <== NOT EXECUTED
if (passwd_fp != NULL)
30007408: e59400e8 ldr r0, [r4, #232] ; 0xe8 <== NOT EXECUTED 3000740c: e3500000 cmp r0, #0 <== NOT EXECUTED
fclose(passwd_fp);
30007410: 1b002f60 blne 30013198 <fclose> <== NOT EXECUTED
passwd_fp = fopen("/etc/passwd", "r");
30007414: e59f0010 ldr r0, [pc, #16] ; 3000742c <setpwent+0x30> <== NOT EXECUTED 30007418: e59f1010 ldr r1, [pc, #16] ; 30007430 <setpwent+0x34> <== NOT EXECUTED 3000741c: eb003134 bl 300138f4 <fopen> <== NOT EXECUTED 30007420: e58400e8 str r0, [r4, #232] ; 0xe8 <== NOT EXECUTED
}
30007424: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300083f8 <setsid>:
*
* 4.3.2 Create Session and Set Process Group ID, P1003.1b-1993, p. 88
*/
pid_t setsid( void )
{
300083f8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
300083fc: eb002b17 bl 30013060 <__errno> <== NOT EXECUTED 30008400: e3a03001 mov r3, #1 <== NOT EXECUTED 30008404: e5803000 str r3, [r0] <== NOT EXECUTED
}
30008408: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000840c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30008410 <setuid>:
*/
int setuid(
uid_t uid
)
{
_POSIX_types_Uid = uid;
30008410: e59f300c ldr r3, [pc, #12] ; 30008424 <setuid+0x14> <== NOT EXECUTED 30008414: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008418: e1c303b2 strh r0, [r3, #50] ; 0x32 <== NOT EXECUTED
return 0; }
3000841c: e3a00000 mov r0, #0 <== NOT EXECUTED 30008420: e12fff1e bx lr <== NOT EXECUTED
3000a49c <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
3000a49c: e2523000 subs r3, r2, #0 <== NOT EXECUTED
*oact = _POSIX_signals_Vectors[ sig ];
3000a4a0: 159f20c4 ldrne r2, [pc, #196] ; 3000a56c <sigaction+0xd0> <== NOT EXECUTED
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
3000a4a4: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000a4a8: e1a05001 mov r5, r1 <== NOT EXECUTED
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
3000a4ac: 10801080 addne r1, r0, r0, lsl #1 <== NOT EXECUTED 3000a4b0: 10822101 addne r2, r2, r1, lsl #2 <== NOT EXECUTED
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
3000a4b4: e1a04000 mov r4, r0 <== NOT EXECUTED
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
3000a4b8: 18920007 ldmne r2, {r0, r1, r2} <== NOT EXECUTED
3000a4bc: 18830007 stmne r3, {r0, r1, r2} <== NOT EXECUTED
if ( !sig )
3000a4c0: e3540000 cmp r4, #0 <== NOT EXECUTED 3000a4c4: 0a000023 beq 3000a558 <sigaction+0xbc> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000a4c8: e2443001 sub r3, r4, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
3000a4cc: e353001f cmp r3, #31 <== NOT EXECUTED 3000a4d0: 8a000020 bhi 3000a558 <sigaction+0xbc> <== NOT EXECUTED
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
3000a4d4: e3540009 cmp r4, #9 <== NOT EXECUTED 3000a4d8: 0a00001e beq 3000a558 <sigaction+0xbc> <== NOT EXECUTED
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
3000a4dc: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a4e0: 0a00001a beq 3000a550 <sigaction+0xb4> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a4e4: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000a4e8: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000a4ec: 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 ) {
3000a4f0: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000a4f4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a4f8: 0a000009 beq 3000a524 <sigaction+0x88> <== NOT EXECUTED
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
3000a4fc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a500: eb001775 bl 300102dc <_POSIX_signals_Clear_process_signals><== NOT EXECUTED
_POSIX_signals_Vectors[ sig ] = *act;
3000a504: e8950007 ldm r5, {r0, r1, r2} <== NOT EXECUTED
3000a508: e59f305c ldr r3, [pc, #92] ; 3000a56c <sigaction+0xd0> <== NOT EXECUTED
3000a50c: e0844084 add r4, r4, r4, lsl #1 <== NOT EXECUTED
3000a510: e0834104 add r4, r3, r4, lsl #2 <== NOT EXECUTED
3000a514: e8840007 stm r4, {r0, r1, r2} <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a518: 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;
3000a51c: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a520: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
3000a524: e59f2044 ldr r2, [pc, #68] ; 3000a570 <sigaction+0xd4> <== NOT EXECUTED
3000a528: e0844084 add r4, r4, r4, lsl #1 <== NOT EXECUTED
3000a52c: e59f3038 ldr r3, [pc, #56] ; 3000a56c <sigaction+0xd0> <== NOT EXECUTED
3000a530: e1a04104 lsl r4, r4, #2 <== NOT EXECUTED
3000a534: e0833004 add r3, r3, r4 <== NOT EXECUTED
3000a538: e0824004 add r4, r2, r4 <== NOT EXECUTED
3000a53c: e8940007 ldm r4, {r0, r1, r2} <== NOT EXECUTED
3000a540: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
3000a544: 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;
3000a548: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a54c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000a550: e1a00005 mov r0, r5 <== NOT EXECUTED
}
3000a554: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
3000a558: eb002383 bl 3001336c <__errno> <== NOT EXECUTED
3000a55c: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a560: e5803000 str r3, [r0] <== NOT EXECUTED
3000a564: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a568: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000a574 <sigaddset>:
int sigaddset(
sigset_t *set,
int signo
)
{
if ( !set )
3000a574: e2503000 subs r3, r0, #0 <== NOT EXECUTED
int sigaddset(
sigset_t *set,
int signo
)
{
3000a578: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000a57c: 0a00000a beq 3000a5ac <sigaddset+0x38> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000a580: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a584: 0a000008 beq 3000a5ac <sigaddset+0x38> <== NOT EXECUTED 3000a588: e2411001 sub r1, r1, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(signo) )
3000a58c: e351001f cmp r1, #31 <== NOT EXECUTED 3000a590: 8a000005 bhi 3000a5ac <sigaddset+0x38> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
*set |= signo_to_mask(signo);
3000a594: e5932000 ldr r2, [r3] <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3000a598: e3a00001 mov r0, #1 <== NOT EXECUTED 3000a59c: e1821110 orr r1, r2, r0, lsl r1 <== NOT EXECUTED
return 0;
3000a5a0: e3a00000 mov r0, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
*set |= signo_to_mask(signo);
3000a5a4: e5831000 str r1, [r3] <== NOT EXECUTED
return 0; }
3000a5a8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !signo )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
3000a5ac: eb00236e bl 3001336c <__errno> <== NOT EXECUTED
3000a5b0: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a5b4: e5803000 str r3, [r0] <== NOT EXECUTED
3000a5b8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a5bc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c930 <sigdelset>:
int sigdelset(
sigset_t *set,
int signo
)
{
if ( !set )
3000c930: e2503000 subs r3, r0, #0 <== NOT EXECUTED
int sigdelset(
sigset_t *set,
int signo
)
{
3000c934: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000c938: 0a00000c beq 3000c970 <sigdelset+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000c93c: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c940: 0a000008 beq 3000c968 <sigdelset+0x38> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000c944: e2411001 sub r1, r1, #1 <== NOT EXECUTED
return 0;
if ( !is_valid_signo(signo) )
3000c948: e351001f cmp r1, #31 <== NOT EXECUTED 3000c94c: 8a000007 bhi 3000c970 <sigdelset+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
*set &= ~signo_to_mask(signo);
3000c950: e5932000 ldr r2, [r3] <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3000c954: e3a00001 mov r0, #1 <== NOT EXECUTED 3000c958: e1c21110 bic r1, r2, r0, lsl r1 <== NOT EXECUTED
return 0;
3000c95c: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
*set &= ~signo_to_mask(signo);
3000c960: e5831000 str r1, [r3] <== NOT EXECUTED
return 0;
3000c964: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
return 0;
3000c968: 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;
}
3000c96c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !signo )
return 0;
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
3000c970: eb0023e3 bl 30015904 <__errno> <== NOT EXECUTED
3000c974: e3a03016 mov r3, #22 <== NOT EXECUTED
3000c978: e5803000 str r3, [r0] <== NOT EXECUTED
3000c97c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000c980: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000f5d4 <sigemptyset>:
int sigemptyset(
sigset_t *set
)
{
if ( !set )
3000f5d4: e2503000 subs r3, r0, #0
#include <rtems/seterr.h>
int sigemptyset(
sigset_t *set
)
{
3000f5d8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( !set )
3000f5dc: 0a000002 beq 3000f5ec <sigemptyset+0x18>
rtems_set_errno_and_return_minus_one( EINVAL );
*set = 0;
3000f5e0: e3a00000 mov r0, #0 3000f5e4: e5830000 str r0, [r3]
return 0; }
3000f5e8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
int sigemptyset(
sigset_t *set
)
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
3000f5ec: eb000aa0 bl 30012074 <__errno> <== NOT EXECUTED
3000f5f0: e3a03016 mov r3, #22 <== NOT EXECUTED
3000f5f4: e5803000 str r3, [r0] <== NOT EXECUTED
3000f5f8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000f5fc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c9b0 <sigfillset>:
int sigfillset(
sigset_t *set
)
{
if ( !set )
3000c9b0: e3500000 cmp r0, #0 <== NOT EXECUTED
#include <rtems/seterr.h>
int sigfillset(
sigset_t *set
)
{
3000c9b4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000c9b8: 0a000003 beq 3000c9cc <sigfillset+0x1c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
*set = SIGNAL_ALL_MASK;
3000c9bc: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000c9c0: e5803000 str r3, [r0] <== NOT EXECUTED
return 0;
3000c9c4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000c9c8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int sigfillset(
sigset_t *set
)
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
3000c9cc: eb0023cc bl 30015904 <__errno> <== NOT EXECUTED
3000c9d0: e3a03016 mov r3, #22 <== NOT EXECUTED
3000c9d4: e5803000 str r3, [r0] <== NOT EXECUTED
3000c9d8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000c9dc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c9e0 <sigismember>:
int sigismember(
const sigset_t *set,
int signo
)
{
if ( !set )
3000c9e0: e3500000 cmp r0, #0 <== NOT EXECUTED
int sigismember(
const sigset_t *set,
int signo
)
{
3000c9e4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !set )
3000c9e8: 0a00000c beq 3000ca20 <sigismember+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !signo )
3000c9ec: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c9f0: 0a000008 beq 3000ca18 <sigismember+0x38> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
3000c9f4: e2411001 sub r1, r1, #1 <== NOT EXECUTED
return 0;
if ( !is_valid_signo(signo) )
3000c9f8: e351001f cmp r1, #31 <== NOT EXECUTED 3000c9fc: 8a000007 bhi 3000ca20 <sigismember+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( *set & signo_to_mask(signo) )
3000ca00: e5903000 ldr r3, [r0] <== NOT EXECUTED
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
3000ca04: e3a02001 mov r2, #1 <== NOT EXECUTED
const sigset_t *set,
int signo
)
{
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
3000ca08: e0133112 ands r3, r3, r2, lsl r1 <== NOT EXECUTED
3000ca0c: 03a00000 moveq r0, #0 <== NOT EXECUTED
3000ca10: 13a00001 movne r0, #1 <== NOT EXECUTED
3000ca14: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !signo )
return 0;
3000ca18: e1a00001 mov r0, r1 <== NOT EXECUTED
if ( *set & signo_to_mask(signo) )
return 1;
return 0;
}
3000ca1c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !signo )
return 0;
if ( !is_valid_signo(signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
3000ca20: eb0023b7 bl 30015904 <__errno> <== NOT EXECUTED
3000ca24: e3a03016 mov r3, #22 <== NOT EXECUTED
3000ca28: e5803000 str r3, [r0] <== NOT EXECUTED
3000ca2c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000ca30: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a2ec <signal>:
sighandler_t signal(
int signum,
sighandler_t handler
)
{
3000a2ec: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000a2f0: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
struct sigaction s;
struct sigaction old;
s.sa_handler = handler ;
sigemptyset(&s.sa_mask);
3000a2f4: e28d400c add r4, sp, #12 <== NOT EXECUTED
sighandler_t signal(
int signum,
sighandler_t handler
)
{
3000a2f8: e1a05000 mov r5, r0 <== NOT EXECUTED
struct sigaction s;
struct sigaction old;
s.sa_handler = handler ;
sigemptyset(&s.sa_mask);
3000a2fc: e2840004 add r0, r4, #4 <== NOT EXECUTED
)
{
struct sigaction s;
struct sigaction old;
s.sa_handler = handler ;
3000a300: e58d1014 str r1, [sp, #20] <== NOT EXECUTED
sigemptyset(&s.sa_mask);
3000a304: ebffffed bl 3000a2c0 <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;
3000a308: e3a03000 mov r3, #0 <== NOT EXECUTED
#endif
sigaction( signum, &s, &old );
3000a30c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a310: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a314: 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;
3000a318: e58d300c str r3, [sp, #12] <== NOT EXECUTED
#endif
sigaction( signum, &s, &old );
3000a31c: ebffff9e bl 3000a19c <sigaction> <== NOT EXECUTED
return (sighandler_t) old.sa_handler; }
3000a320: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
3000a324: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3000a328: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000a5ec <sigpending>:
sigset_t *set
)
{
POSIX_API_Control *api;
if ( !set )
3000a5ec: e2503000 subs r3, r0, #0 <== NOT EXECUTED
#include <rtems/seterr.h>
int sigpending(
sigset_t *set
)
{
3000a5f0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
POSIX_API_Control *api;
if ( !set )
3000a5f4: 0a000009 beq 3000a620 <sigpending+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
3000a5f8: e59f2034 ldr r2, [pc, #52] ; 3000a634 <sigpending+0x48> <== NOT EXECUTED
*set = api->signals_pending | _POSIX_signals_Pending;
3000a5fc: e59f1034 ldr r1, [pc, #52] ; 3000a638 <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 ];
3000a600: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED
*set = api->signals_pending | _POSIX_signals_Pending;
3000a604: e5911000 ldr r1, [r1] <== NOT EXECUTED 3000a608: e59220fc ldr r2, [r2, #252] ; 0xfc <== NOT EXECUTED
return 0;
3000a60c: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
*set = api->signals_pending | _POSIX_signals_Pending;
3000a610: e59220d4 ldr r2, [r2, #212] ; 0xd4 <== NOT EXECUTED 3000a614: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000a618: e5832000 str r2, [r3] <== NOT EXECUTED
return 0;
}
3000a61c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
)
{
POSIX_API_Control *api;
if ( !set )
rtems_set_errno_and_return_minus_one( EINVAL );
3000a620: eb002351 bl 3001336c <__errno> <== NOT EXECUTED
3000a624: e3a03016 mov r3, #22 <== NOT EXECUTED
3000a628: e5803000 str r3, [r0] <== NOT EXECUTED
3000a62c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000a630: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000a63c <sigprocmask>:
/*
* P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask.
*/
#if defined(RTEMS_POSIX_API)
return pthread_sigmask( how, set, oset );
3000a63c: ea0018ec b 300109f4 <pthread_sigmask> <== NOT EXECUTED
3000ca88 <sigqueue>:
int sigqueue(
pid_t pid,
int signo,
const union sigval value
)
{
3000ca88: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000ca8c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000ca90: e28d3004 add r3, sp, #4 <== NOT EXECUTED
3000ca94: e5232004 str r2, [r3, #-4]! <== NOT EXECUTED
return killinfo( pid, signo, &value );
3000ca98: e1a0200d mov r2, sp <== NOT EXECUTED 3000ca9c: eb001789 bl 300128c8 <killinfo> <== NOT EXECUTED
}
3000caa0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000caa4: e8bd8000 pop {pc} <== NOT EXECUTED
3000caa8 <sigsuspend>:
#include <rtems/seterr.h>
int sigsuspend(
const sigset_t *sigmask
)
{
3000caa8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000caac: e24dd008 sub sp, sp, #8 <== 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 );
3000cab0: e28d4004 add r4, sp, #4 <== NOT EXECUTED
#include <rtems/seterr.h>
int sigsuspend(
const sigset_t *sigmask
)
{
3000cab4: 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 );
3000cab8: e1a01000 mov r1, r0 <== NOT EXECUTED 3000cabc: e1a02004 mov r2, r4 <== NOT EXECUTED 3000cac0: e3a00001 mov r0, #1 <== NOT EXECUTED 3000cac4: ebffffee bl 3000ca84 <sigprocmask> <== NOT EXECUTED
current_unblocked_signals = ~(*sigmask);
3000cac8: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000cacc: e28d0008 add r0, sp, #8 <== NOT EXECUTED 3000cad0: e1e03003 mvn r3, r3 <== NOT EXECUTED
status = sigtimedwait( ¤t_unblocked_signals, NULL, NULL );
3000cad4: 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);
3000cad8: e5203008 str r3, [r0, #-8]! <== NOT EXECUTED
status = sigtimedwait( ¤t_unblocked_signals, NULL, NULL );
3000cadc: e1a02001 mov r2, r1 <== NOT EXECUTED 3000cae0: e1a0000d mov r0, sp <== NOT EXECUTED 3000cae4: eb00001c bl 3000cb5c <sigtimedwait> <== NOT EXECUTED
(void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL );
3000cae8: e3a00000 mov r0, #0 <== NOT EXECUTED 3000caec: e1a01004 mov r1, r4 <== NOT EXECUTED 3000caf0: e1a02000 mov r2, r0 <== NOT EXECUTED 3000caf4: ebffffe2 bl 3000ca84 <sigprocmask> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
assert( status != -1 );
#endif
rtems_set_errno_and_return_minus_one( EINTR );
3000caf8: eb002381 bl 30015904 <__errno> <== NOT EXECUTED 3000cafc: e3a03004 mov r3, #4 <== NOT EXECUTED 3000cb00: e5803000 str r3, [r0] <== NOT EXECUTED
}
3000cb04: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000cb08: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000cb0c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000a998 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
3000a998: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
3000a99c: e2506000 subs r6, r0, #0 <== NOT EXECUTED
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
3000a9a0: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 3000a9a4: e1a04001 mov r4, r1 <== NOT EXECUTED 3000a9a8: e1a05002 mov r5, r2 <== NOT EXECUTED
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
3000a9ac: 0a000062 beq 3000ab3c <sigtimedwait+0x1a4> <== NOT EXECUTED
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
3000a9b0: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a9b4: 0a00004e beq 3000aaf4 <sigtimedwait+0x15c> <== NOT EXECUTED
if ( !_Timespec_Is_valid( timeout ) )
3000a9b8: e1a00002 mov r0, r2 <== NOT EXECUTED 3000a9bc: eb000e23 bl 3000e250 <_Timespec_Is_valid> <== NOT EXECUTED 3000a9c0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a9c4: 0a00005c beq 3000ab3c <sigtimedwait+0x1a4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
3000a9c8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a9cc: eb000e46 bl 3000e2ec <_Timespec_To_ticks> <== NOT EXECUTED
if ( !interval )
3000a9d0: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000a9d4: 0a000058 beq 3000ab3c <sigtimedwait+0x1a4> <== NOT EXECUTED
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
the_thread = _Thread_Executing;
3000a9d8: e59f7188 ldr r7, [pc, #392] ; 3000ab68 <sigtimedwait+0x1d0><== NOT EXECUTED
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
3000a9dc: e3540000 cmp r4, #0 <== NOT EXECUTED
the_thread = _Thread_Executing;
3000a9e0: e5973004 ldr r3, [r7, #4] <== NOT EXECUTED
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
3000a9e4: 028d4004 addeq r4, sp, #4 <== NOT EXECUTED
the_thread = _Thread_Executing;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
3000a9e8: e593a0fc ldr sl, [r3, #252] ; 0xfc <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a9ec: e10f8000 mrs r8, CPSR <== NOT EXECUTED 3000a9f0: e3882080 orr r2, r8, #128 ; 0x80 <== NOT EXECUTED 3000a9f4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
*/
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
3000a9f8: e5962000 ldr r2, [r6] <== NOT EXECUTED 3000a9fc: e59a00d4 ldr r0, [sl, #212] ; 0xd4 <== NOT EXECUTED 3000aa00: e0129000 ands r9, r2, r0 <== NOT EXECUTED 3000aa04: 1a00003c bne 3000aafc <sigtimedwait+0x164> <== NOT EXECUTED
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
3000aa08: e59f015c ldr r0, [pc, #348] ; 3000ab6c <sigtimedwait+0x1d4><== NOT EXECUTED 3000aa0c: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000aa10: e1120000 tst r2, r0 <== NOT EXECUTED 3000aa14: 1a000027 bne 3000aab8 <sigtimedwait+0x120> <== NOT EXECUTED 3000aa18: e59f2150 ldr r2, [pc, #336] ; 3000ab70 <sigtimedwait+0x1d8><== NOT EXECUTED
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
3000aa1c: e3e0c000 mvn ip, #0 <== NOT EXECUTED 3000aa20: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000aa24: e584c000 str ip, [r4] <== NOT EXECUTED 3000aa28: e2800001 add r0, r0, #1 <== NOT EXECUTED 3000aa2c: e5820000 str r0, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
3000aa30: e3a02004 mov r2, #4 <== NOT EXECUTED 3000aa34: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
the_thread->Wait.option = *set;
3000aa38: e5960000 ldr r0, [r6] <== NOT EXECUTED
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
3000aa3c: e59f2130 ldr r2, [pc, #304] ; 3000ab74 <sigtimedwait+0x1dc><== NOT EXECUTED
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
3000aa40: e5830030 str r0, [r3, #48] ; 0x30 <== NOT EXECUTED
the_thread->Wait.return_argument = the_info;
3000aa44: e5834028 str r4, [r3, #40] ; 0x28 <== NOT EXECUTED
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
3000aa48: 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;
3000aa4c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000aa50: e5823030 str r3, [r2, #48] ; 0x30 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000aa54: e129f008 msr CPSR_fc, r8 <== 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 );
3000aa58: e59f0114 ldr r0, [pc, #276] ; 3000ab74 <sigtimedwait+0x1dc><== NOT EXECUTED 3000aa5c: e59f2114 ldr r2, [pc, #276] ; 3000ab78 <sigtimedwait+0x1e0><== NOT EXECUTED 3000aa60: eb000c50 bl 3000dba8 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000aa64: eb000b23 bl 3000d6f8 <_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 );
3000aa68: e3a0c000 mov ip, #0 <== NOT EXECUTED 3000aa6c: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000aa70: e1a0300c mov r3, ip <== NOT EXECUTED 3000aa74: e1a0000a mov r0, sl <== NOT EXECUTED 3000aa78: e1a02004 mov r2, r4 <== NOT EXECUTED 3000aa7c: e58dc000 str ip, [sp] <== NOT EXECUTED 3000aa80: eb001824 bl 30010b18 <_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)
3000aa84: e5973004 ldr r3, [r7, #4] <== NOT EXECUTED 3000aa88: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000aa8c: e3530004 cmp r3, #4 <== NOT EXECUTED 3000aa90: 1a00002e bne 3000ab50 <sigtimedwait+0x1b8> <== NOT EXECUTED
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
3000aa94: e5945000 ldr r5, [r4] <== NOT EXECUTED 3000aa98: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000aa9c: e2452001 sub r2, r5, #1 <== NOT EXECUTED 3000aaa0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000aaa4: e0133211 ands r3, r3, r1, lsl r2 <== NOT EXECUTED 3000aaa8: 0a000028 beq 3000ab50 <sigtimedwait+0x1b8> <== NOT EXECUTED
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
3000aaac: e1a00005 mov r0, r5 <== NOT EXECUTED
3000aab0: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000aab4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
3000aab8: ebffffa3 bl 3000a94c <_POSIX_signals_Get_lowest> <== NOT EXECUTED
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
3000aabc: e1a02004 mov r2, r4 <== NOT EXECUTED 3000aac0: e1a01000 mov r1, r0 <== NOT EXECUTED
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
3000aac4: e1a05000 mov r5, r0 <== NOT EXECUTED
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
3000aac8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000aacc: e1a0000a mov r0, sl <== NOT EXECUTED 3000aad0: e58d9000 str r9, [sp] <== NOT EXECUTED 3000aad4: eb00180f bl 30010b18 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 3000aad8: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level );
the_info->si_signo = signo;
the_info->si_code = SI_USER;
3000aadc: e3a03001 mov r3, #1 <== NOT EXECUTED 3000aae0: e5843004 str r3, [r4, #4] <== NOT EXECUTED
the_info->si_value.sival_int = 0;
3000aae4: 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;
3000aae8: e5845000 str r5, [r4] <== NOT EXECUTED
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
3000aaec: e5843008 str r3, [r4, #8] <== NOT EXECUTED
return signo;
3000aaf0: eaffffed b 3000aaac <sigtimedwait+0x114> <== NOT EXECUTED
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
3000aaf4: e1a01002 mov r1, r2 <== NOT EXECUTED 3000aaf8: eaffffb6 b 3000a9d8 <sigtimedwait+0x40> <== 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 );
3000aafc: ebffff92 bl 3000a94c <_POSIX_signals_Get_lowest> <== NOT EXECUTED
_POSIX_signals_Clear_signals(
3000ab00: e3a0c000 mov ip, #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 );
3000ab04: e5840000 str r0, [r4] <== NOT EXECUTED 3000ab08: e1a01000 mov r1, r0 <== NOT EXECUTED
_POSIX_signals_Clear_signals(
3000ab0c: e1a02004 mov r2, r4 <== NOT EXECUTED 3000ab10: e1a0000a mov r0, sl <== NOT EXECUTED 3000ab14: e1a0300c mov r3, ip <== NOT EXECUTED 3000ab18: e58dc000 str ip, [sp] <== NOT EXECUTED 3000ab1c: eb0017fd bl 30010b18 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 3000ab20: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
3000ab24: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ab28: e5843004 str r3, [r4, #4] <== NOT EXECUTED
the_info->si_value.sival_int = 0;
3000ab2c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000ab30: e5843008 str r3, [r4, #8] <== NOT EXECUTED
return the_info->si_signo;
3000ab34: e5945000 ldr r5, [r4] <== NOT EXECUTED 3000ab38: eaffffdb b 3000aaac <sigtimedwait+0x114> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
3000ab3c: eb0023e7 bl 30013ae0 <__errno> <== NOT EXECUTED 3000ab40: e3a03016 mov r3, #22 <== NOT EXECUTED 3000ab44: e5803000 str r3, [r0] <== NOT EXECUTED 3000ab48: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000ab4c: eaffffd6 b 3000aaac <sigtimedwait+0x114> <== NOT EXECUTED
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
3000ab50: eb0023e2 bl 30013ae0 <__errno> <== NOT EXECUTED 3000ab54: e5973004 ldr r3, [r7, #4] <== NOT EXECUTED
return -1;
3000ab58: e3e05000 mvn r5, #0 <== NOT EXECUTED
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
3000ab5c: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 3000ab60: e5803000 str r3, [r0] <== NOT EXECUTED
return -1;
3000ab64: eaffffd0 b 3000aaac <sigtimedwait+0x114> <== NOT EXECUTED
3000cd48 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
3000cd48: e92d4010 push {r4, lr} <== NOT EXECUTED
3000cd4c: e1a04001 mov r4, r1 <== NOT EXECUTED
int status;
status = sigtimedwait( set, NULL, NULL );
3000cd50: e3a01000 mov r1, #0 <== NOT EXECUTED 3000cd54: e1a02001 mov r2, r1 <== NOT EXECUTED 3000cd58: ebffff7f bl 3000cb5c <sigtimedwait> <== NOT EXECUTED
if ( status != -1 ) {
3000cd5c: e3700001 cmn r0, #1 <== NOT EXECUTED 3000cd60: 0a000005 beq 3000cd7c <sigwait+0x34> <== NOT EXECUTED
if ( sig )
3000cd64: e3540000 cmp r4, #0 <== NOT EXECUTED
*sig = status;
3000cd68: 15840000 strne r0, [r4] <== NOT EXECUTED
return 0;
3000cd6c: 13a00000 movne r0, #0 <== NOT EXECUTED
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
3000cd70: 18bd8010 popne {r4, pc} <== NOT EXECUTED
*sig = status;
return 0;
3000cd74: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
3000cd78: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( sig )
*sig = status;
return 0;
}
return errno;
3000cd7c: eb0022e0 bl 30015904 <__errno> <== NOT EXECUTED
3000cd80: e5900000 ldr r0, [r0] <== NOT EXECUTED
3000cd84: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000cd40 <sigwaitinfo>:
int sigwaitinfo(
const sigset_t *set,
siginfo_t *info
)
{
return sigtimedwait( set, info, NULL );
3000cd40: e3a02000 mov r2, #0 <== NOT EXECUTED 3000cd44: eaffff84 b 3000cb5c <sigtimedwait> <== NOT EXECUTED
300085ec <siproc>:
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
300085ec: e591203c ldr r2, [r1, #60] ; 0x3c <== NOT EXECUTED 300085f0: e59f304c ldr r3, [pc, #76] ; 30008644 <siproc+0x58> <== NOT EXECUTED
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
300085f4: 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)) {
300085f8: e0023003 and r3, r2, r3 <== NOT EXECUTED 300085fc: e3530000 cmp r3, #0 <== NOT EXECUTED
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008600: e1a04001 mov r4, r1 <== NOT EXECUTED 30008604: 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)) {
30008608: 1a000001 bne 30008614 <siproc+0x28> <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
3000860c: 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);
30008610: eaffff81 b 3000841c <iproc> <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30008614: e3a01000 mov r1, #0 <== NOT EXECUTED 30008618: e1a02001 mov r2, r1 <== NOT EXECUTED 3000861c: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED 30008620: eb00054b bl 30009b54 <rtems_semaphore_obtain> <== NOT EXECUTED
i = iproc (c, tty);
30008624: e1a01004 mov r1, r4 <== NOT EXECUTED 30008628: e1a00005 mov r0, r5 <== NOT EXECUTED 3000862c: ebffff7a bl 3000841c <iproc> <== NOT EXECUTED 30008630: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
30008634: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED 30008638: eb00058e bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
3000863c: e1a00005 mov r0, r5 <== NOT EXECUTED
30008640: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000741c <stat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
3000741c: e92d4070 push {r4, r5, r6, lr}
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
30007420: e2515000 subs r5, r1, #0
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
30007424: e24dd018 sub sp, sp, #24 30007428: e1a06000 mov r6, r0
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
3000742c: 0a000019 beq 30007498 <stat+0x7c>
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
30007430: eb00272d bl 300110ec <strlen> 30007434: e28d4004 add r4, sp, #4 30007438: e3a03001 mov r3, #1 3000743c: e1a01000 mov r1, r0 30007440: e58d3000 str r3, [sp] 30007444: e3a02000 mov r2, #0 30007448: e1a00006 mov r0, r6 3000744c: e1a03004 mov r3, r4 30007450: ebfffc26 bl 300064f0 <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
30007454: e2501000 subs r1, r0, #0
return -1;
30007458: 13e05000 mvnne r5, #0
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
3000745c: 1a00000a bne 3000748c <stat+0x70>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
30007460: e1a00005 mov r0, r5 30007464: e3a02048 mov r2, #72 ; 0x48 30007468: eb002615 bl 30010cc4 <memset>
status = (*loc.handlers->fstat_h)( &loc, buf );
3000746c: e1a01005 mov r1, r5 30007470: e1a00004 mov r0, r4 30007474: e59d300c ldr r3, [sp, #12] 30007478: e1a0e00f mov lr, pc 3000747c: e593f018 ldr pc, [r3, #24] 30007480: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
30007484: e1a00004 mov r0, r4 30007488: ebfffc52 bl 300065d8 <rtems_filesystem_freenode>
return status;
}
3000748c: e1a00005 mov r0, r5
30007490: e28dd018 add sp, sp, #24
30007494: e8bd8070 pop {r4, r5, r6, pc}
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
30007498: eb0023a4 bl 30010330 <__errno> <== NOT EXECUTED 3000749c: e3a0300e mov r3, #14 <== NOT EXECUTED 300074a0: e5803000 str r3, [r0] <== NOT EXECUTED 300074a4: e3e05000 mvn r5, #0 <== NOT EXECUTED 300074a8: eafffff7 b 3000748c <stat+0x70> <== NOT EXECUTED
30009f64 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
30009f64: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30009f68: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30009f6c: e1a05001 mov r5, r1 <== NOT EXECUTED
30009f70: 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 ) )
30009f74: eb00345a bl 300170e4 <strlen> <== NOT EXECUTED 30009f78: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30009f7c: e3a03001 mov r3, #1 <== NOT EXECUTED 30009f80: e1a01000 mov r1, r0 <== NOT EXECUTED 30009f84: e58d3000 str r3, [sp] <== NOT EXECUTED 30009f88: e3a02000 mov r2, #0 <== NOT EXECUTED 30009f8c: e1a00006 mov r0, r6 <== NOT EXECUTED 30009f90: e1a03004 mov r3, r4 <== NOT EXECUTED 30009f94: ebfffac0 bl 30008a9c <rtems_filesystem_evaluate_path> <== NOT EXECUTED 30009f98: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30009f9c: 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 ) )
30009fa0: 1a000018 bne 3000a008 <statvfs+0xa4> <== NOT EXECUTED
return -1;
mt_entry = loc.mt_entry;
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
30009fa4: e1a03005 mov r3, r5 <== NOT EXECUTED 30009fa8: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fac: e2833004 add r3, r3, #4 <== NOT EXECUTED 30009fb0: e5850004 str r0, [r5, #4] <== NOT EXECUTED 30009fb4: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fb8: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fbc: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fc0: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fc4: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fc8: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fcc: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fd0: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fd4: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fd8: e4830004 str r0, [r3], #4 <== NOT EXECUTED
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
30009fdc: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
30009fe0: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fe4: e5830000 str r0, [r3] <== NOT EXECUTED
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
30009fe8: e1a01005 mov r1, r5 <== NOT EXECUTED 30009fec: e5923028 ldr r3, [r2, #40] ; 0x28 <== NOT EXECUTED 30009ff0: e282001c add r0, r2, #28 <== NOT EXECUTED 30009ff4: e1a0e00f mov lr, pc <== NOT EXECUTED 30009ff8: e593f044 ldr pc, [r3, #68] ; 0x44 <== NOT EXECUTED 30009ffc: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
3000a000: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a004: ebfffade bl 30008b84 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
3000a008: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a00c: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3000a010: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000876c <sync>:
{
/*
* Walk the one used initially by RTEMS.
*/
_fwalk(_global_impure_ptr, sync_wrapper);
3000876c: e59f3018 ldr r3, [pc, #24] ; 3000878c <sync+0x20> <== NOT EXECUTED
* We have to extern it here.
*/
extern struct _reent * const _global_impure_ptr __ATTRIBUTE_IMPURE_PTR__;
void sync(void)
{
30008770: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
/*
* Walk the one used initially by RTEMS.
*/
_fwalk(_global_impure_ptr, sync_wrapper);
30008774: e5930000 ldr r0, [r3] <== NOT EXECUTED 30008778: e59f1010 ldr r1, [pc, #16] ; 30008790 <sync+0x24> <== NOT EXECUTED 3000877c: eb002e49 bl 300140a8 <_fwalk> <== NOT EXECUTED
*/
/*
* Now walk all the per-thread reentrancy structures.
*/
rtems_iterate_over_all_threads(sync_per_thread);
30008780: e59f000c ldr r0, [pc, #12] ; 30008794 <sync+0x28> <== NOT EXECUTED
}
30008784: 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);
30008788: ea000ee2 b 3000c318 <rtems_iterate_over_all_threads> <== NOT EXECUTED
30008710 <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;
30008710: 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)
{
30008714: 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 ) {
30008718: e3530000 cmp r3, #0 <== NOT EXECUTED
3000871c: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
current_reent = _Thread_Executing->libc_reent;
30008720: e59f4020 ldr r4, [pc, #32] ; 30008748 <sync_per_thread+0x38><== NOT EXECUTED
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
30008724: e59f1020 ldr r1, [pc, #32] ; 3000874c <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;
30008728: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000872c: e59250f4 ldr r5, [r2, #244] ; 0xf4 <== NOT EXECUTED
_Thread_Executing->libc_reent = this_reent;
30008730: e58230f4 str r3, [r2, #244] ; 0xf4 <== NOT EXECUTED
_fwalk (t->libc_reent, sync_wrapper);
30008734: e59000f4 ldr r0, [r0, #244] ; 0xf4 <== NOT EXECUTED 30008738: eb002e5a bl 300140a8 <_fwalk> <== NOT EXECUTED
_Thread_Executing->libc_reent = current_reent;
3000873c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
30008740: e58350f4 str r5, [r3, #244] ; 0xf4 <== NOT EXECUTED
30008744: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30008750 <sync_wrapper>:
/* XXX check standards -- Linux version appears to be void */
void _fwalk(struct _reent *, void *);
static void sync_wrapper(FILE *f)
{
30008750: e92d4010 push {r4, lr} <== NOT EXECUTED
int fn = fileno(f);
30008754: eb002b6f bl 30013518 <fileno> <== NOT EXECUTED 30008758: 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);
3000875c: ebfffae9 bl 30007308 <fsync> <== NOT EXECUTED
fdatasync(fn);
30008760: e1a00004 mov r0, r4 <== NOT EXECUTED
}
30008764: 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);
30008768: eafffa2c b 30007020 <fdatasync> <== NOT EXECUTED
300096f4 <sysconf>:
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
300096f4: e3500002 cmp r0, #2 <== NOT EXECUTED
*/
long sysconf(
int name
)
{
300096f8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( name == _SC_CLK_TCK )
300096fc: 0a000008 beq 30009724 <sysconf+0x30> <== NOT EXECUTED
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
30009700: e3500004 cmp r0, #4 <== NOT EXECUTED 30009704: 0a00000b beq 30009738 <sysconf+0x44> <== NOT EXECUTED
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
30009708: e3500033 cmp r0, #51 ; 0x33 <== NOT EXECUTED
return 1024;
3000970c: 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 )
30009710: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
return 1024;
if ( name == _SC_PAGESIZE )
30009714: e3500008 cmp r0, #8 <== NOT EXECUTED 30009718: 1a000009 bne 30009744 <sysconf+0x50> <== NOT EXECUTED
return PAGE_SIZE;
3000971c: 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 );
}
30009720: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
30009724: e59f302c ldr r3, [pc, #44] ; 30009758 <sysconf+0x64> <== NOT EXECUTED
30009728: e59f002c ldr r0, [pc, #44] ; 3000975c <sysconf+0x68> <== NOT EXECUTED
3000972c: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
30009730: eb0032cc bl 30016268 <__aeabi_uidiv> <== NOT EXECUTED
30009734: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
return rtems_libio_number_iops;
30009738: e59f3020 ldr r3, [pc, #32] ; 30009760 <sysconf+0x6c> <== NOT EXECUTED
3000973c: e5930000 ldr r0, [r3] <== NOT EXECUTED
30009740: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
30009744: eb0023b9 bl 30012630 <__errno> <== NOT EXECUTED
30009748: e3a03016 mov r3, #22 <== NOT EXECUTED
3000974c: e5803000 str r3, [r0] <== NOT EXECUTED
30009750: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009754: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300093e4 <tcgetattr>:
int tcgetattr(
int fd,
struct termios *tp
)
{
300093e4: e1a02001 mov r2, r1 <== NOT EXECUTED
return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp );
300093e8: e3a01001 mov r1, #1 <== NOT EXECUTED 300093ec: ea001de1 b 30010b78 <ioctl> <== NOT EXECUTED
300093f0 <tcsetattr>:
int fd,
int opt,
struct termios *tp
)
{
switch (opt) {
300093f0: e3510000 cmp r1, #0 <== NOT EXECUTED
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
300093f4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
300093f8: e1a05000 mov r5, r0 <== NOT EXECUTED
300093fc: e1a04002 mov r4, r2 <== NOT EXECUTED
switch (opt) {
30009400: 0a00000b beq 30009434 <tcsetattr+0x44> <== NOT EXECUTED 30009404: e3510001 cmp r1, #1 <== NOT EXECUTED 30009408: 0a000004 beq 30009420 <tcsetattr+0x30> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000940c: eb002b68 bl 300141b4 <__errno> <== NOT EXECUTED 30009410: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 30009414: e5803000 str r3, [r0] <== NOT EXECUTED
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
}
}
30009418: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000941c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
30009420: e3a01003 mov r1, #3 <== NOT EXECUTED 30009424: e3a02000 mov r2, #0 <== NOT EXECUTED 30009428: eb001dd2 bl 30010b78 <ioctl> <== NOT EXECUTED 3000942c: e3500000 cmp r0, #0 <== NOT EXECUTED 30009430: bafffff8 blt 30009418 <tcsetattr+0x28> <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
30009434: e1a00005 mov r0, r5 <== NOT EXECUTED 30009438: e3a01002 mov r1, #2 <== NOT EXECUTED 3000943c: e1a02004 mov r2, r4 <== NOT EXECUTED
} }
30009440: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
30009444: ea001dcb b 30010b78 <ioctl> <== NOT EXECUTED
30009a84 <timer_create>:
timer_t *timerid
)
{
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
30009a84: e3500001 cmp r0, #1 <== NOT EXECUTED
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
30009a88: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30009a8c: e1a04001 mov r4, r1 <== NOT EXECUTED
30009a90: e1a05002 mov r5, r2 <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
30009a94: 1a000035 bne 30009b70 <timer_create+0xec> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
30009a98: e3520000 cmp r2, #0 <== NOT EXECUTED 30009a9c: 0a000033 beq 30009b70 <timer_create+0xec> <== NOT EXECUTED
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
30009aa0: e3510000 cmp r1, #0 <== NOT EXECUTED 30009aa4: 0a000009 beq 30009ad0 <timer_create+0x4c> <== NOT EXECUTED
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
30009aa8: e5913000 ldr r3, [r1] <== NOT EXECUTED 30009aac: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30009ab0: e3530001 cmp r3, #1 <== NOT EXECUTED 30009ab4: 8a00002d bhi 30009b70 <timer_create+0xec> <== 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 )
30009ab8: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 30009abc: e3530000 cmp r3, #0 <== NOT EXECUTED 30009ac0: 0a00002a beq 30009b70 <timer_create+0xec> <== NOT EXECUTED
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
30009ac4: e2433001 sub r3, r3, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
30009ac8: e353001f cmp r3, #31 <== NOT EXECUTED 30009acc: 8a000027 bhi 30009b70 <timer_create+0xec> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009ad0: e59f30c4 ldr r3, [pc, #196] ; 30009b9c <timer_create+0x118><== NOT EXECUTED 30009ad4: e5932000 ldr r2, [r3] <== NOT EXECUTED 30009ad8: e2822001 add r2, r2, #1 <== NOT EXECUTED 30009adc: 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 );
30009ae0: e59f00b8 ldr r0, [pc, #184] ; 30009ba0 <timer_create+0x11c><== NOT EXECUTED 30009ae4: eb00079b bl 3000b958 <_Objects_Allocate> <== NOT EXECUTED
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
30009ae8: e3500000 cmp r0, #0 <== NOT EXECUTED 30009aec: 0a000024 beq 30009b84 <timer_create+0x100> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
30009af0: e3a03002 mov r3, #2 <== NOT EXECUTED 30009af4: e5c0303c strb r3, [r0, #60] ; 0x3c <== NOT EXECUTED
ptimer->thread_id = _Thread_Executing->Object.id;
30009af8: e59f30a4 ldr r3, [pc, #164] ; 30009ba4 <timer_create+0x120><== NOT EXECUTED
if ( evp != NULL ) {
30009afc: 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;
30009b00: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30009b04: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30009b08: e5803038 str r3, [r0, #56] ; 0x38 <== NOT EXECUTED
if ( evp != NULL ) {
30009b0c: 0a000003 beq 30009b20 <timer_create+0x9c> <== NOT EXECUTED
ptimer->inf.sigev_notify = evp->sigev_notify;
30009b10: e894000e ldm r4, {r1, r2, r3} <== NOT EXECUTED
30009b14: e5801040 str r1, [r0, #64] ; 0x40 <== NOT EXECUTED
ptimer->inf.sigev_signo = evp->sigev_signo;
30009b18: e5802044 str r2, [r0, #68] ; 0x44 <== NOT EXECUTED
ptimer->inf.sigev_value = evp->sigev_value;
30009b1c: e5803048 str r3, [r0, #72] ; 0x48 <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009b20: e59f2078 ldr r2, [pc, #120] ; 30009ba0 <timer_create+0x11c><== NOT EXECUTED
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30009b24: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009b28: e592201c ldr r2, [r2, #28] <== NOT EXECUTED
}
ptimer->overrun = 0;
30009b2c: e3a04000 mov r4, #0 <== NOT EXECUTED
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
30009b30: e1a01803 lsl r1, r3, #16 <== NOT EXECUTED 30009b34: e5804068 str r4, [r0, #104] ; 0x68 <== NOT EXECUTED
ptimer->timer_data.it_value.tv_sec = 0;
30009b38: e580405c str r4, [r0, #92] ; 0x5c <== NOT EXECUTED
ptimer->timer_data.it_value.tv_nsec = 0;
30009b3c: e5804060 str r4, [r0, #96] ; 0x60 <== NOT EXECUTED
ptimer->timer_data.it_interval.tv_sec = 0;
30009b40: e5804054 str r4, [r0, #84] ; 0x54 <== NOT EXECUTED
ptimer->timer_data.it_interval.tv_nsec = 0;
30009b44: e5804058 str r4, [r0, #88] ; 0x58 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30009b48: e5804018 str r4, [r0, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
30009b4c: e580402c str r4, [r0, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
30009b50: e5804030 str r4, [r0, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
30009b54: e5804034 str r4, [r0, #52] ; 0x34 <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30009b58: e7820721 str r0, [r2, r1, lsr #14] <== NOT EXECUTED
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
30009b5c: 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;
30009b60: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
30009b64: eb000be5 bl 3000cb00 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009b68: e1a00004 mov r0, r4 <== NOT EXECUTED
}
30009b6c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( !evp->sigev_signo )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
30009b70: eb0024ac bl 30012e28 <__errno> <== NOT EXECUTED
30009b74: e3a03016 mov r3, #22 <== NOT EXECUTED
30009b78: e5803000 str r3, [r0] <== NOT EXECUTED
30009b7c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009b80: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
30009b84: eb000bdd bl 3000cb00 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EAGAIN );
30009b88: eb0024a6 bl 30012e28 <__errno> <== NOT EXECUTED
30009b8c: e3a0300b mov r3, #11 <== NOT EXECUTED
30009b90: e5803000 str r3, [r0] <== NOT EXECUTED
30009b94: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009b98: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000a31c <timer_delete>:
int timer_delete(
timer_t timerid
)
{
3000a31c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000a320: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000a324: 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 );
3000a328: e1a0200d mov r2, sp <== NOT EXECUTED 3000a32c: e59f005c ldr r0, [pc, #92] ; 3000a390 <timer_delete+0x74> <== NOT EXECUTED 3000a330: eb000868 bl 3000c4d8 <_Objects_Get> <== NOT EXECUTED
*/
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000a334: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000a338: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a33c: e3550000 cmp r5, #0 <== NOT EXECUTED 3000a340: 0a000005 beq 3000a35c <timer_delete+0x40> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000a344: eb002566 bl 300138e4 <__errno> <== NOT EXECUTED 3000a348: e3a03016 mov r3, #22 <== NOT EXECUTED 3000a34c: e5803000 str r3, [r0] <== NOT EXECUTED 3000a350: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
3000a354: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000a358: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Timer_Information, &ptimer->Object );
3000a35c: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a360: e59f0028 ldr r0, [pc, #40] ; 3000a390 <timer_delete+0x74> <== NOT EXECUTED 3000a364: eb00074f bl 3000c0a8 <_Objects_Close> <== NOT EXECUTED
ptimer->state = POSIX_TIMER_STATE_FREE;
3000a368: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a36c: e5c4303c strb r3, [r4, #60] ; 0x3c <== NOT EXECUTED
(void) _Watchdog_Remove( &ptimer->Timer );
3000a370: e2840010 add r0, r4, #16 <== NOT EXECUTED 3000a374: eb000fde bl 3000e2f4 <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free (
POSIX_Timer_Control *the_timer
)
{
_Objects_Free( &_POSIX_Timer_Information, &the_timer->Object );
3000a378: e59f0010 ldr r0, [pc, #16] ; 3000a390 <timer_delete+0x74> <== NOT EXECUTED 3000a37c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a380: eb0007fd bl 3000c37c <_Objects_Free> <== NOT EXECUTED
_POSIX_Timer_Free( ptimer );
_Thread_Enable_dispatch();
3000a384: eb000b8c bl 3000d1bc <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000a388: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a38c: eafffff0 b 3000a354 <timer_delete+0x38> <== NOT EXECUTED
3000af38 <timer_getoverrun>:
* its execution, _POSIX_Timer_TSR will have to set this counter to 0.
*/
int timer_getoverrun(
timer_t timerid
)
{
3000af38: e92d4010 push {r4, lr} <== NOT EXECUTED
3000af3c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000af40: 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 );
3000af44: e1a0200d mov r2, sp <== NOT EXECUTED 3000af48: e59f0038 ldr r0, [pc, #56] ; 3000af88 <timer_getoverrun+0x50><== NOT EXECUTED 3000af4c: eb00084a bl 3000d07c <_Objects_Get> <== NOT EXECUTED
int overrun;
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000af50: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000af54: e3530000 cmp r3, #0 <== NOT EXECUTED 3000af58: 0a000006 beq 3000af78 <timer_getoverrun+0x40> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000af5c: eb00245a bl 300140cc <__errno> <== NOT EXECUTED 3000af60: e3a03016 mov r3, #22 <== NOT EXECUTED 3000af64: e5803000 str r3, [r0] <== NOT EXECUTED 3000af68: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
3000af6c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000af70: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000af74: e8bd8010 pop {r4, pc} <== NOT EXECUTED
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
case OBJECTS_LOCAL:
overrun = ptimer->overrun;
3000af78: e5904068 ldr r4, [r0, #104] ; 0x68 <== NOT EXECUTED
ptimer->overrun = 0;
3000af7c: e5803068 str r3, [r0, #104] ; 0x68 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000af80: eb000b76 bl 3000dd60 <_Thread_Enable_dispatch> <== NOT EXECUTED
return overrun;
3000af84: eafffff8 b 3000af6c <timer_getoverrun+0x34> <== NOT EXECUTED
3000af8c <timer_gettime>:
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
3000af8c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
3000af90: e2514000 subs r4, r1, #0 <== NOT EXECUTED
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
3000af94: e24dd00c sub sp, sp, #12 <== NOT EXECUTED 3000af98: e1a05000 mov r5, r0 <== NOT EXECUTED
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
3000af9c: 0a000018 beq 3000b004 <timer_gettime+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
/* Reads the current time */
_TOD_Get( ¤t_time );
3000afa0: e1a0000d mov r0, sp <== NOT EXECUTED 3000afa4: eb000598 bl 3000c60c <_TOD_Get> <== NOT EXECUTED 3000afa8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000afac: e59f0064 ldr r0, [pc, #100] ; 3000b018 <timer_gettime+0x8c><== NOT EXECUTED 3000afb0: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000afb4: eb000830 bl 3000d07c <_Objects_Get> <== NOT EXECUTED
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
3000afb8: e59d6008 ldr r6, [sp, #8] <== NOT EXECUTED 3000afbc: e1a05000 mov r5, r0 <== NOT EXECUTED 3000afc0: e3560000 cmp r6, #0 <== NOT EXECUTED 3000afc4: 1a00000e bne 3000b004 <timer_gettime+0x78> <== NOT EXECUTED
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
3000afc8: e59f304c ldr r3, [pc, #76] ; 3000b01c <timer_gettime+0x90> <== NOT EXECUTED 3000afcc: e5952024 ldr r2, [r5, #36] ; 0x24 <== NOT EXECUTED 3000afd0: e590001c ldr r0, [r0, #28] <== NOT EXECUTED 3000afd4: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000afd8: e0800002 add r0, r0, r2 <== NOT EXECUTED
_Watchdog_Ticks_since_boot; /* now */
_Timespec_From_ticks( left, &value->it_value );
3000afdc: e0630000 rsb r0, r3, r0 <== NOT EXECUTED 3000afe0: e2841008 add r1, r4, #8 <== NOT EXECUTED 3000afe4: eb000e33 bl 3000e8b8 <_Timespec_From_ticks> <== NOT EXECUTED
value->it_interval = ptimer->timer_data.it_interval;
3000afe8: e2853054 add r3, r5, #84 ; 0x54 <== NOT EXECUTED
3000afec: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000aff0: e884000c stm r4, {r2, r3} <== NOT EXECUTED
_Thread_Enable_dispatch();
3000aff4: eb000b59 bl 3000dd60 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000aff8: e1a00006 mov r0, r6 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
3000affc: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000b000: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
3000b004: eb002430 bl 300140cc <__errno> <== NOT EXECUTED 3000b008: e3a03016 mov r3, #22 <== NOT EXECUTED 3000b00c: e5803000 str r3, [r0] <== NOT EXECUTED 3000b010: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000b014: eafffff8 b 3000affc <timer_gettime+0x70> <== NOT EXECUTED
30009ba8 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
30009ba8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
30009bac: e2525000 subs r5, r2, #0 <== NOT EXECUTED
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
30009bb0: e24dd020 sub sp, sp, #32 <== NOT EXECUTED 30009bb4: e1a06000 mov r6, r0 <== NOT EXECUTED 30009bb8: e1a08001 mov r8, r1 <== NOT EXECUTED 30009bbc: e1a07003 mov r7, r3 <== NOT EXECUTED
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
30009bc0: 0a00004e beq 30009d00 <timer_settime+0x158> <== 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) ) ) {
30009bc4: e2850008 add r0, r5, #8 <== NOT EXECUTED 30009bc8: eb000eb0 bl 3000d690 <_Timespec_Is_valid> <== NOT EXECUTED 30009bcc: e3500000 cmp r0, #0 <== NOT EXECUTED 30009bd0: 0a00004a beq 30009d00 <timer_settime+0x158> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
30009bd4: e1a00005 mov r0, r5 <== NOT EXECUTED 30009bd8: eb000eac bl 3000d690 <_Timespec_Is_valid> <== NOT EXECUTED 30009bdc: e3500000 cmp r0, #0 <== NOT EXECUTED 30009be0: 0a000046 beq 30009d00 <timer_settime+0x158> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
30009be4: e3580000 cmp r8, #0 <== NOT EXECUTED 30009be8: 13580004 cmpne r8, #4 <== NOT EXECUTED 30009bec: 1a000043 bne 30009d00 <timer_settime+0x158> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
30009bf0: e28d4004 add r4, sp, #4 <== NOT EXECUTED
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
30009bf4: e3580004 cmp r8, #4 <== NOT EXECUTED
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
30009bf8: e895000f ldm r5, {r0, r1, r2, r3} <== NOT EXECUTED
30009bfc: e884000f stm r4, {r0, r1, r2, r3} <== NOT EXECUTED
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
30009c00: 0a000029 beq 30009cac <timer_settime+0x104> <== NOT EXECUTED
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
30009c04: e1a01006 mov r1, r6 <== NOT EXECUTED 30009c08: e59f0148 ldr r0, [pc, #328] ; 30009d58 <timer_settime+0x1b0><== NOT EXECUTED 30009c0c: e28d201c add r2, sp, #28 <== NOT EXECUTED 30009c10: eb000881 bl 3000be1c <_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 ) {
30009c14: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 30009c18: e1a06000 mov r6, r0 <== NOT EXECUTED 30009c1c: e3530000 cmp r3, #0 <== NOT EXECUTED 30009c20: 1a000036 bne 30009d00 <timer_settime+0x158> <== 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 ) {
30009c24: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30009c28: e3530000 cmp r3, #0 <== NOT EXECUTED 30009c2c: 1a000002 bne 30009c3c <timer_settime+0x94> <== NOT EXECUTED 30009c30: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30009c34: e3530000 cmp r3, #0 <== NOT EXECUTED 30009c38: 0a000035 beq 30009d14 <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 );
30009c3c: e1a00005 mov r0, r5 <== NOT EXECUTED 30009c40: eb000eb9 bl 3000d72c <_Timespec_To_ticks> <== NOT EXECUTED 30009c44: e5860064 str r0, [r6, #100] ; 0x64 <== NOT EXECUTED
initial_period = _Timespec_To_ticks( &normalize.it_value );
30009c48: e2840008 add r0, r4, #8 <== NOT EXECUTED 30009c4c: eb000eb6 bl 3000d72c <_Timespec_To_ticks> <== NOT EXECUTED
activated = _POSIX_Timer_Insert_helper(
30009c50: e5962008 ldr r2, [r6, #8] <== 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 );
30009c54: e1a01000 mov r1, r0 <== NOT EXECUTED
activated = _POSIX_Timer_Insert_helper(
30009c58: e59f30fc ldr r3, [pc, #252] ; 30009d5c <timer_settime+0x1b4><== NOT EXECUTED 30009c5c: e2860010 add r0, r6, #16 <== NOT EXECUTED 30009c60: e58d6000 str r6, [sp] <== NOT EXECUTED 30009c64: eb001978 bl 3001024c <_POSIX_Timer_Insert_helper> <== NOT EXECUTED
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
30009c68: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30009c6c: 0a000036 beq 30009d4c <timer_settime+0x1a4> <== NOT EXECUTED
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
30009c70: e3570000 cmp r7, #0 <== NOT EXECUTED
*ovalue = ptimer->timer_data;
30009c74: 1286c054 addne ip, r6, #84 ; 0x54 <== NOT EXECUTED
30009c78: 189c000f ldmne ip, {r0, r1, r2, r3} <== NOT EXECUTED
30009c7c: 1887000f stmne r7, {r0, r1, r2, r3} <== NOT EXECUTED
30009c80: 0286c054 addeq ip, r6, #84 ; 0x54 <== NOT EXECUTED
ptimer->timer_data = normalize;
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
30009c84: e3a0e003 mov lr, #3 <== NOT EXECUTED
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
*ovalue = ptimer->timer_data;
ptimer->timer_data = normalize;
30009c88: e894000f ldm r4, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
30009c8c: e5c6e03c strb lr, [r6, #60] ; 0x3c <== NOT EXECUTED
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
*ovalue = ptimer->timer_data;
ptimer->timer_data = normalize;
30009c90: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
_TOD_Get( &ptimer->time );
30009c94: e286006c add r0, r6, #108 ; 0x6c <== NOT EXECUTED 30009c98: eb0005cc bl 3000b3d0 <_TOD_Get> <== NOT EXECUTED
_Thread_Enable_dispatch();
30009c9c: eb000b97 bl 3000cb00 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009ca0: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
30009ca4: e28dd020 add sp, sp, #32 <== NOT EXECUTED
30009ca8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
normalize = *value;
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
30009cac: e28d8014 add r8, sp, #20 <== NOT EXECUTED 30009cb0: e1a00008 mov r0, r8 <== NOT EXECUTED
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
30009cb4: e284a008 add sl, r4, #8 <== NOT EXECUTED
normalize = *value;
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
30009cb8: eb0005c4 bl 3000b3d0 <_TOD_Get> <== NOT EXECUTED
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
30009cbc: e1a00008 mov r0, r8 <== NOT EXECUTED 30009cc0: e1a0100a mov r1, sl <== NOT EXECUTED 30009cc4: eb000e63 bl 3000d658 <_Timespec_Greater_than> <== NOT EXECUTED 30009cc8: e3500000 cmp r0, #0 <== NOT EXECUTED 30009ccc: 1a00000b bne 30009d00 <timer_settime+0x158> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
30009cd0: e1a0100a mov r1, sl <== NOT EXECUTED 30009cd4: e1a00008 mov r0, r8 <== NOT EXECUTED 30009cd8: e1a0200a mov r2, sl <== NOT EXECUTED 30009cdc: eb000e7c bl 3000d6d4 <_Timespec_Subtract> <== NOT EXECUTED 30009ce0: e1a01006 mov r1, r6 <== NOT EXECUTED 30009ce4: e59f006c ldr r0, [pc, #108] ; 30009d58 <timer_settime+0x1b0><== NOT EXECUTED 30009ce8: e28d201c add r2, sp, #28 <== NOT EXECUTED 30009cec: eb00084a bl 3000be1c <_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 ) {
30009cf0: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 30009cf4: e1a06000 mov r6, r0 <== NOT EXECUTED 30009cf8: e3530000 cmp r3, #0 <== NOT EXECUTED 30009cfc: 0affffc8 beq 30009c24 <timer_settime+0x7c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
30009d00: eb002448 bl 30012e28 <__errno> <== NOT EXECUTED 30009d04: e3a03016 mov r3, #22 <== NOT EXECUTED 30009d08: e5803000 str r3, [r0] <== NOT EXECUTED 30009d0c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009d10: eaffffe3 b 30009ca4 <timer_settime+0xfc> <== 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 ) {
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
30009d14: e2800010 add r0, r0, #16 <== NOT EXECUTED 30009d18: eb000fb5 bl 3000dbf4 <_Watchdog_Remove> <== NOT EXECUTED
/* The old data of the timer are returned */
if ( ovalue )
30009d1c: e3570000 cmp r7, #0 <== NOT EXECUTED
*ovalue = ptimer->timer_data;
30009d20: 1286c054 addne ip, r6, #84 ; 0x54 <== NOT EXECUTED
30009d24: 189c000f ldmne ip, {r0, r1, r2, r3} <== NOT EXECUTED
30009d28: 1887000f stmne r7, {r0, r1, r2, r3} <== NOT EXECUTED
30009d2c: 0286c054 addeq ip, r6, #84 ; 0x54 <== NOT EXECUTED
/* The new data are set */
ptimer->timer_data = normalize;
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
30009d30: e3a0e004 mov lr, #4 <== NOT EXECUTED
(void) _Watchdog_Remove( &ptimer->Timer );
/* The old data of the timer are returned */
if ( ovalue )
*ovalue = ptimer->timer_data;
/* The new data are set */
ptimer->timer_data = normalize;
30009d34: e894000f ldm r4, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
30009d38: e5c6e03c strb lr, [r6, #60] ; 0x3c <== NOT EXECUTED
(void) _Watchdog_Remove( &ptimer->Timer );
/* The old data of the timer are returned */
if ( ovalue )
*ovalue = ptimer->timer_data;
/* The new data are set */
ptimer->timer_data = normalize;
30009d3c: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
/* Returns with success */
_Thread_Enable_dispatch();
30009d40: eb000b6e bl 3000cb00 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009d44: e3a00000 mov r0, #0 <== NOT EXECUTED 30009d48: eaffffd5 b 30009ca4 <timer_settime+0xfc> <== NOT EXECUTED
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
_Thread_Enable_dispatch();
30009d4c: eb000b6b bl 3000cb00 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
30009d50: e1a00005 mov r0, r5 <== NOT EXECUTED 30009d54: eaffffd2 b 30009ca4 <timer_settime+0xfc> <== NOT EXECUTED
300094c4 <times>:
clock_t times(
struct tms *ptms
)
{
return _times( ptms );
300094c4: eaffffcb b 300093f8 <_times> <== NOT EXECUTED
3000cd14 <truncate>:
int truncate(
const char *path,
off_t length
)
{
3000cd14: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000cd18: e1a05001 mov r5, r1 <== NOT EXECUTED
int status;
int fd;
fd = open( path, O_WRONLY );
3000cd1c: e3a01001 mov r1, #1 <== NOT EXECUTED
int truncate(
const char *path,
off_t length
)
{
3000cd20: e1a06002 mov r6, r2 <== NOT EXECUTED
int status;
int fd;
fd = open( path, O_WRONLY );
3000cd24: ebfff6a0 bl 3000a7ac <open> <== NOT EXECUTED
if ( fd == -1 )
3000cd28: e3700001 cmn r0, #1 <== NOT EXECUTED
)
{
int status;
int fd;
fd = open( path, O_WRONLY );
3000cd2c: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( fd == -1 )
return -1;
3000cd30: 01a05000 moveq r5, r0 <== NOT EXECUTED
{
int status;
int fd;
fd = open( path, O_WRONLY );
if ( fd == -1 )
3000cd34: 0a000005 beq 3000cd50 <truncate+0x3c> <== NOT EXECUTED
return -1;
status = ftruncate( fd, length );
3000cd38: e1a01005 mov r1, r5 <== NOT EXECUTED 3000cd3c: e1a02006 mov r2, r6 <== NOT EXECUTED 3000cd40: eb001676 bl 30012720 <ftruncate> <== NOT EXECUTED 3000cd44: e1a05000 mov r5, r0 <== NOT EXECUTED
(void) close( fd );
3000cd48: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cd4c: ebfff150 bl 30009294 <close> <== NOT EXECUTED
return status;
}
3000cd50: e1a00005 mov r0, r5 <== NOT EXECUTED
3000cd54: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300099d8 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
300099d8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
300099dc: e59f40ec ldr r4, [pc, #236] ; 30009ad0 <ualarm+0xf8> <== NOT EXECUTED
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
300099e0: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
300099e4: e594601c ldr r6, [r4, #28] <== NOT EXECUTED
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
300099e8: e1a05000 mov r5, r0 <== NOT EXECUTED
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
300099ec: e3560000 cmp r6, #0 <== NOT EXECUTED 300099f0: 0a00001e beq 30009a70 <ualarm+0x98> <== NOT EXECUTED
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
300099f4: e1a00004 mov r0, r4 <== NOT EXECUTED 300099f8: eb000f6f bl 3000d7bc <_Watchdog_Remove> <== NOT EXECUTED
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
300099fc: e2400002 sub r0, r0, #2 <== NOT EXECUTED 30009a00: e3500001 cmp r0, #1 <== NOT EXECUTED
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
30009a04: 83a06000 movhi r6, #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) ) {
30009a08: 9a00001e bls 30009a88 <ualarm+0xb0> <== 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 ) {
30009a0c: e3550000 cmp r5, #0 <== NOT EXECUTED 30009a10: 0a000013 beq 30009a64 <ualarm+0x8c> <== NOT EXECUTED
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
30009a14: e59f30b8 ldr r3, [pc, #184] ; 30009ad4 <ualarm+0xfc> <== NOT EXECUTED
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ticks = _Timespec_To_ticks( &tp );
30009a18: e1a0000d mov r0, sp <== 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;
30009a1c: e0832395 umull r2, r3, r5, r3 <== NOT EXECUTED 30009a20: e1a03923 lsr r3, r3, #18 <== NOT EXECUTED
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
30009a24: e0632283 rsb r2, r3, r3, lsl #5 <== NOT EXECUTED 30009a28: e0622302 rsb r2, r2, r2, lsl #6 <== NOT EXECUTED 30009a2c: e0832182 add r2, r3, r2, lsl #3 <== NOT EXECUTED 30009a30: e0455302 sub r5, r5, r2, lsl #6 <== NOT EXECUTED 30009a34: e0652285 rsb r2, r5, r5, lsl #5 <== NOT EXECUTED 30009a38: e0855102 add r5, r5, r2, lsl #2 <== NOT EXECUTED 30009a3c: e1a05185 lsl r5, r5, #3 <== 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;
30009a40: e88d0028 stm sp, {r3, r5} <== NOT EXECUTED
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ticks = _Timespec_To_ticks( &tp );
30009a44: eb000df9 bl 3000d230 <_Timespec_To_ticks> <== NOT EXECUTED
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
30009a48: e1a0000d mov r0, sp <== NOT EXECUTED 30009a4c: eb000df7 bl 3000d230 <_Timespec_To_ticks> <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30009a50: e59f1078 ldr r1, [pc, #120] ; 30009ad0 <ualarm+0xf8> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30009a54: e584000c str r0, [r4, #12] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30009a58: e59f0078 ldr r0, [pc, #120] ; 30009ad8 <ualarm+0x100> <== 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 );
30009a5c: e1a0700d mov r7, sp <== NOT EXECUTED 30009a60: eb000ee6 bl 3000d600 <_Watchdog_Insert> <== NOT EXECUTED
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
}
return remaining;
}
30009a64: e1a00006 mov r0, r6 <== NOT EXECUTED
30009a68: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30009a6c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30009a70: e59f3064 ldr r3, [pc, #100] ; 30009adc <ualarm+0x104> <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30009a74: e5846008 str r6, [r4, #8] <== NOT EXECUTED
the_watchdog->routine = routine;
30009a78: e584301c str r3, [r4, #28] <== NOT EXECUTED
the_watchdog->id = id;
30009a7c: e5846020 str r6, [r4, #32] <== NOT EXECUTED
the_watchdog->user_data = user_data;
30009a80: e5846024 str r6, [r4, #36] ; 0x24 <== NOT EXECUTED 30009a84: eaffffe0 b 30009a0c <ualarm+0x34> <== 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);
30009a88: e594200c ldr r2, [r4, #12] <== NOT EXECUTED 30009a8c: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED 30009a90: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 30009a94: e0800002 add r0, r0, r2 <== NOT EXECUTED
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
30009a98: e0630000 rsb r0, r3, r0 <== NOT EXECUTED 30009a9c: e1a0100d mov r1, sp <== NOT EXECUTED 30009aa0: eb000dbb bl 3000d194 <_Timespec_From_ticks> <== NOT EXECUTED
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
remaining += tp.tv_nsec / 1000;
30009aa4: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 30009aa8: e59f0030 ldr r0, [pc, #48] ; 30009ae0 <ualarm+0x108> <== 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;
30009aac: e59d3000 ldr r3, [sp] <== NOT EXECUTED
remaining += tp.tv_nsec / 1000;
30009ab0: e0c01092 smull r1, r0, r2, r0 <== 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;
30009ab4: e0631283 rsb r1, r3, r3, lsl #5 <== NOT EXECUTED 30009ab8: e0611301 rsb r1, r1, r1, lsl #6 <== NOT EXECUTED
remaining += tp.tv_nsec / 1000;
30009abc: e1a02fc2 asr r2, r2, #31 <== 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;
30009ac0: e0833181 add r3, r3, r1, lsl #3 <== NOT EXECUTED
remaining += tp.tv_nsec / 1000;
30009ac4: e0622340 rsb r2, r2, r0, asr #6 <== NOT EXECUTED 30009ac8: e0826303 add r6, r2, r3, lsl #6 <== NOT EXECUTED 30009acc: eaffffce b 30009a0c <ualarm+0x34> <== NOT EXECUTED
30009a4c <uname>:
*/
int uname(
struct utsname *name
)
{
30009a4c: e92d4010 push {r4, lr} <== NOT EXECUTED
release = 5.3
version = Generic_101318-12
machine = sun4m
*/
if ( !name )
30009a50: e2504000 subs r4, r0, #0 <== NOT EXECUTED
*/
int uname(
struct utsname *name
)
{
30009a54: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
release = 5.3
version = Generic_101318-12
machine = sun4m
*/
if ( !name )
30009a58: 0a000019 beq 30009ac4 <uname+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
strncpy( name->sysname, "RTEMS", sizeof(name->sysname) );
30009a5c: e59f1074 ldr r1, [pc, #116] ; 30009ad8 <uname+0x8c> <== NOT EXECUTED 30009a60: e3a02020 mov r2, #32 <== NOT EXECUTED 30009a64: eb00297e bl 30014064 <strncpy> <== NOT EXECUTED
snprintf( name->nodename, sizeof(name->nodename), "Node %" PRId16, _Objects_Local_node );
30009a68: e3a03001 mov r3, #1 <== NOT EXECUTED 30009a6c: e3a01020 mov r1, #32 <== NOT EXECUTED 30009a70: e59f2064 ldr r2, [pc, #100] ; 30009adc <uname+0x90> <== NOT EXECUTED 30009a74: e2840020 add r0, r4, #32 <== NOT EXECUTED 30009a78: eb002820 bl 30013b00 <snprintf> <== NOT EXECUTED
strncpy( name->release, RTEMS_VERSION, sizeof(name->release) );
30009a7c: e59f105c ldr r1, [pc, #92] ; 30009ae0 <uname+0x94> <== NOT EXECUTED 30009a80: e3a02020 mov r2, #32 <== NOT EXECUTED 30009a84: e2840040 add r0, r4, #64 ; 0x40 <== NOT EXECUTED 30009a88: eb002975 bl 30014064 <strncpy> <== NOT EXECUTED
strncpy( name->version, "", sizeof(name->version) );
30009a8c: e59f1050 ldr r1, [pc, #80] ; 30009ae4 <uname+0x98> <== NOT EXECUTED 30009a90: e3a02020 mov r2, #32 <== NOT EXECUTED 30009a94: e2840060 add r0, r4, #96 ; 0x60 <== NOT EXECUTED 30009a98: eb002971 bl 30014064 <strncpy> <== NOT EXECUTED
snprintf( name->machine, sizeof(name->machine), "%s/%s", CPU_NAME, CPU_MODEL_NAME );
30009a9c: e59f3044 ldr r3, [pc, #68] ; 30009ae8 <uname+0x9c> <== NOT EXECUTED 30009aa0: e3a01020 mov r1, #32 <== NOT EXECUTED 30009aa4: e58d3000 str r3, [sp] <== NOT EXECUTED 30009aa8: e59f203c ldr r2, [pc, #60] ; 30009aec <uname+0xa0> <== NOT EXECUTED 30009aac: e2840080 add r0, r4, #128 ; 0x80 <== NOT EXECUTED 30009ab0: e59f3038 ldr r3, [pc, #56] ; 30009af0 <uname+0xa4> <== NOT EXECUTED 30009ab4: eb002811 bl 30013b00 <snprintf> <== NOT EXECUTED
return 0;
30009ab8: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30009abc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30009ac0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
version = Generic_101318-12
machine = sun4m
*/
if ( !name )
rtems_set_errno_and_return_minus_one( EFAULT );
30009ac4: eb002543 bl 30012fd8 <__errno> <== NOT EXECUTED 30009ac8: e3a0300e mov r3, #14 <== NOT EXECUTED 30009acc: e5803000 str r3, [r0] <== NOT EXECUTED 30009ad0: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009ad4: eafffff8 b 30009abc <uname+0x70> <== NOT EXECUTED
3000a500 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
3000a500: e92d40f0 push {r4, r5, r6, r7, lr}
3000a504: e24dd030 sub sp, sp, #48 ; 0x30
3000a508: e1a07000 mov r7, r0
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
3000a50c: ebfff459 bl 30007678 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
3000a510: e2505000 subs r5, r0, #0
3000a514: 1a000039 bne 3000a600 <unlink+0x100>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
3000a518: e28d4018 add r4, sp, #24 <== NOT EXECUTED 3000a51c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a520: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 3000a524: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a528: ebfff86f bl 300086ec <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;
3000a52c: e1a06005 mov r6, r5 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
3000a530: e28dc004 add ip, sp, #4
3000a534: e1a0e004 mov lr, r4
3000a538: e8be000f ldm lr!, {r0, r1, r2, r3}
3000a53c: e8ac000f stmia ip!, {r0, r1, r2, r3}
name = path + parentpathlen;
3000a540: e0875005 add r5, r7, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
3000a544: e59e3000 ldr r3, [lr]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000a548: e1a00005 mov r0, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
3000a54c: e58c3000 str r3, [ip]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000a550: eb0033d0 bl 30017498 <strlen> 3000a554: e1a01000 mov r1, r0 3000a558: e1a00005 mov r0, r5 3000a55c: ebfff454 bl 300076b4 <rtems_filesystem_prefix_separators> 3000a560: e0857000 add r7, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
3000a564: e1a00007 mov r0, r7 3000a568: eb0033ca bl 30017498 <strlen> 3000a56c: e28d5004 add r5, sp, #4 3000a570: e1a01000 mov r1, r0 3000a574: e3a02000 mov r2, #0 3000a578: e1a00007 mov r0, r7 3000a57c: e1a03005 mov r3, r5 3000a580: e58d2000 str r2, [sp] 3000a584: ebfff409 bl 300075b0 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
3000a588: e3500000 cmp r0, #0
3000a58c: 1a000013 bne 3000a5e0 <unlink+0xe0>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
3000a590: e1a00005 mov r0, r5 3000a594: e59d3010 ldr r3, [sp, #16] 3000a598: e1a0e00f mov lr, pc 3000a59c: e593f010 ldr pc, [r3, #16] 3000a5a0: e3500001 cmp r0, #1
3000a5a4: 0a000021 beq 3000a630 <unlink+0x130>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( EISDIR );
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
3000a5a8: e1a01005 mov r1, r5 3000a5ac: e59d3010 ldr r3, [sp, #16] 3000a5b0: e1a00004 mov r0, r4 3000a5b4: e1a0e00f mov lr, pc 3000a5b8: e593f00c ldr pc, [r3, #12] 3000a5bc: e1a07000 mov r7, r0
rtems_filesystem_freenode( &loc );
3000a5c0: e1a00005 mov r0, r5 3000a5c4: ebfff44f bl 30007708 <rtems_filesystem_freenode>
if ( free_parentloc )
3000a5c8: e3560000 cmp r6, #0
rtems_filesystem_freenode( &parentloc );
3000a5cc: 11a00004 movne r0, r4 3000a5d0: 1bfff44c blne 30007708 <rtems_filesystem_freenode>
return result;
}
3000a5d4: e1a00007 mov r0, r7
3000a5d8: e28dd030 add sp, sp, #48 ; 0x30
3000a5dc: e8bd80f0 pop {r4, r5, r6, r7, pc}
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
3000a5e0: e3560000 cmp r6, #0 <== NOT EXECUTED 3000a5e4: 1a000001 bne 3000a5f0 <unlink+0xf0> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
return -1;
3000a5e8: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000a5ec: eafffff8 b 3000a5d4 <unlink+0xd4> <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
3000a5f0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a5f4: ebfff443 bl 30007708 <rtems_filesystem_freenode> <== NOT EXECUTED
return -1;
3000a5f8: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000a5fc: eafffff4 b 3000a5d4 <unlink+0xd4> <== NOT EXECUTED
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
3000a600: e3a03000 mov r3, #0 3000a604: e28d4018 add r4, sp, #24 3000a608: e58d3000 str r3, [sp] 3000a60c: e3a02002 mov r2, #2 3000a610: e1a00007 mov r0, r7 3000a614: e1a01005 mov r1, r5 3000a618: e1a03004 mov r3, r4 3000a61c: ebfff3ff bl 30007620 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
3000a620: e3500000 cmp r0, #0
3000a624: 1affffef bne 3000a5e8 <unlink+0xe8>
return -1;
free_parentloc = true;
3000a628: e3a06001 mov r6, #1 3000a62c: eaffffbf b 3000a530 <unlink+0x30>
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
3000a630: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a634: ebfff433 bl 30007708 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_parentloc )
3000a638: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
3000a63c: 11a00004 movne r0, r4 <== NOT EXECUTED 3000a640: 1bfff430 blne 30007708 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EISDIR );
3000a644: eb002fd4 bl 3001659c <__errno> <== NOT EXECUTED 3000a648: e3a03015 mov r3, #21 <== NOT EXECUTED 3000a64c: e5803000 str r3, [r0] <== NOT EXECUTED 3000a650: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000a654: eaffffde b 3000a5d4 <unlink+0xd4> <== NOT EXECUTED
3000a820 <unmount>:
*/
int unmount(
const char *path
)
{
3000a820: e92d4070 push {r4, r5, r6, lr}
3000a824: e24dd018 sub sp, sp, #24
3000a828: 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 ) )
3000a82c: eb00288e bl 30014a6c <strlen> 3000a830: e28d4004 add r4, sp, #4 3000a834: e1a01000 mov r1, r0 3000a838: e3a0c001 mov ip, #1 3000a83c: e1a00005 mov r0, r5 3000a840: e3a02000 mov r2, #0 3000a844: e1a03004 mov r3, r4 3000a848: e58dc000 str ip, [sp] 3000a84c: ebfff338 bl 30007534 <rtems_filesystem_evaluate_path> 3000a850: e3500000 cmp r0, #0
3000a854: 1a00001a bne 3000a8c4 <unmount+0xa4>
return -1;
mt_entry = loc.mt_entry;
3000a858: 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 ){
3000a85c: e59d3004 ldr r3, [sp, #4] 3000a860: e595201c ldr r2, [r5, #28] 3000a864: e1520003 cmp r2, r3
3000a868: 1a00002d bne 3000a924 <unmount+0x104>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
3000a86c: e1a00004 mov r0, r4 3000a870: ebfff369 bl 3000761c <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 )
3000a874: e59f30f8 ldr r3, [pc, #248] ; 3000a974 <unmount+0x154> 3000a878: e5933000 ldr r3, [r3] 3000a87c: e5933014 ldr r3, [r3, #20] 3000a880: e1530005 cmp r3, r5
3000a884: 0a00002d beq 3000a940 <unmount+0x120>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
3000a888: e59f00e8 ldr r0, [pc, #232] ; 3000a978 <unmount+0x158> 3000a88c: e595102c ldr r1, [r5, #44] ; 0x2c 3000a890: ebfff5c0 bl 30007f98 <rtems_filesystem_mount_iterate> 3000a894: e3500000 cmp r0, #0
3000a898: 1a000028 bne 3000a940 <unmount+0x120>
* 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 )
3000a89c: e1a00005 mov r0, r5 3000a8a0: ebfff457 bl 30007a04 <rtems_libio_is_open_files_in_fs> 3000a8a4: e3500001 cmp r0, #1
3000a8a8: 0a000024 beq 3000a940 <unmount+0x120>
* 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 )
3000a8ac: e5953014 ldr r3, [r5, #20] 3000a8b0: e1a00005 mov r0, r5 3000a8b4: e1a0e00f mov lr, pc 3000a8b8: e593f028 ldr pc, [r3, #40] ; 0x28 3000a8bc: e2506000 subs r6, r0, #0
3000a8c0: 0a000002 beq 3000a8d0 <unmount+0xb0>
*/
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;
3000a8c4: e3e00000 mvn r0, #0
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
3000a8c8: e28dd018 add sp, sp, #24
3000a8cc: e8bd8070 pop {r4, r5, r6, pc}
* 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){
3000a8d0: e5953028 ldr r3, [r5, #40] ; 0x28 3000a8d4: e1a00005 mov r0, r5 3000a8d8: e1a0e00f mov lr, pc 3000a8dc: e593f02c ldr pc, [r3, #44] ; 0x2c 3000a8e0: e2504000 subs r4, r0, #0
3000a8e4: 1a00001a bne 3000a954 <unmount+0x134>
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 );
3000a8e8: e59f608c ldr r6, [pc, #140] ; 3000a97c <unmount+0x15c> 3000a8ec: e1a01004 mov r1, r4 3000a8f0: e1a02004 mov r2, r4 3000a8f4: e5960000 ldr r0, [r6] 3000a8f8: eb0002a4 bl 3000b390 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000a8fc: e1a00005 mov r0, r5 3000a900: eb000509 bl 3000bd2c <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3000a904: e5960000 ldr r0, [r6] 3000a908: eb0002e9 bl 3000b4b4 <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 );
3000a90c: e2850008 add r0, r5, #8 3000a910: ebfff341 bl 3000761c <rtems_filesystem_freenode>
free( mt_entry );
3000a914: e1a00005 mov r0, r5 3000a918: ebfff344 bl 30007630 <free>
return 0;
3000a91c: e1a00004 mov r0, r4 3000a920: eaffffe8 b 3000a8c8 <unmount+0xa8>
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
rtems_filesystem_freenode( &loc );
3000a924: e1a00004 mov r0, r4 3000a928: ebfff33b bl 3000761c <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
3000a92c: eb0022d6 bl 3001348c <__errno> 3000a930: e3a0300d mov r3, #13 3000a934: e5803000 str r3, [r0] 3000a938: e3e00000 mvn r0, #0 3000a93c: eaffffe1 b 3000a8c8 <unmount+0xa8>
* 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 )
rtems_set_errno_and_return_minus_one( EBUSY );
3000a940: eb0022d1 bl 3001348c <__errno> 3000a944: e3a03010 mov r3, #16 3000a948: e5803000 str r3, [r0] 3000a94c: e3e00000 mvn r0, #0 3000a950: eaffffdc b 3000a8c8 <unmount+0xa8>
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
3000a954: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 3000a958: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a95c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a960: e593f020 ldr pc, [r3, #32] <== NOT EXECUTED 3000a964: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a968: 0affffd5 beq 3000a8c4 <unmount+0xa4> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
3000a96c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a970: eb000417 bl 3000b9d4 <rtems_fatal_error_occurred> <== NOT EXECUTED
3000a538 <utime>:
int utime(
const char *path,
const struct utimbuf *times
)
{
3000a538: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000a53c: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
3000a540: e1a05001 mov r5, r1 <== NOT EXECUTED
3000a544: e1a06000 mov r6, 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 ) )
3000a548: eb002a02 bl 30014d58 <strlen> <== NOT EXECUTED 3000a54c: e28d4004 add r4, sp, #4 <== NOT EXECUTED 3000a550: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a554: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a558: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a55c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a560: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a564: e1a03004 mov r3, r4 <== NOT EXECUTED 3000a568: ebfff1f4 bl 30006d40 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 3000a56c: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
3000a570: 13e05000 mvnne r5, #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 ) )
3000a574: 1a000009 bne 3000a5a0 <utime+0x68> <== NOT EXECUTED
return -1;
if ( times == NULL ) {
3000a578: e3550000 cmp r5, #0 <== NOT EXECUTED
3000a57c: 0a00000a beq 3000a5ac <utime+0x74> <== NOT EXECUTED
3000a580: e8950006 ldm r5, {r1, r2} <== NOT EXECUTED
now.actime = now.modtime = time( NULL );
times = &now;
}
result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
3000a584: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a588: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000a58c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a590: e593f030 ldr pc, [r3, #48] ; 0x30 <== NOT EXECUTED 3000a594: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &temp_loc );
3000a598: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a59c: ebfff304 bl 300071b4 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
3000a5a0: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a5a4: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3000a5a8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
return -1;
if ( times == NULL ) {
now.actime = now.modtime = time( NULL );
3000a5ac: eb002a3c bl 30014ea4 <time> <== NOT EXECUTED 3000a5b0: e1a02000 mov r2, r0 <== NOT EXECUTED 3000a5b4: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a5b8: eafffff1 b 3000a584 <utime+0x4c> <== NOT EXECUTED
3000a5bc <utimes>:
int utimes(
const char *path,
const struct timeval times[2]
)
{
3000a5bc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct utimbuf timeinsecs;
if ( times == NULL )
3000a5c0: e2513000 subs r3, r1, #0 <== NOT EXECUTED
int utimes(
const char *path,
const struct timeval times[2]
)
{
3000a5c4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
struct utimbuf timeinsecs;
if ( times == NULL )
return utime( path, NULL );
timeinsecs.actime = (time_t) times[0].tv_sec;
3000a5c8: 15932000 ldrne r2, [r3] <== NOT EXECUTED
timeinsecs.modtime = (time_t) times[1].tv_sec;
3000a5cc: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
return utime( path, &timeinsecs );
3000a5d0: 11a0100d movne r1, sp <== NOT EXECUTED
struct utimbuf timeinsecs;
if ( times == NULL )
return utime( path, NULL );
timeinsecs.actime = (time_t) times[0].tv_sec;
3000a5d4: 158d2000 strne r2, [sp] <== NOT EXECUTED
timeinsecs.modtime = (time_t) times[1].tv_sec;
3000a5d8: 158d3004 strne r3, [sp, #4] <== NOT EXECUTED
return utime( path, &timeinsecs );
3000a5dc: ebffffd5 bl 3000a538 <utime> <== NOT EXECUTED
}
3000a5e0: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000a5e4: e8bd8000 pop {pc} <== NOT EXECUTED
30009ad4 <vfork>:
#include <unistd.h>
pid_t vfork(void)
{
return -1;
}
30009ad4: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009ad8: e12fff1e bx lr <== NOT EXECUTED
30009144 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
30009144: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30009148: e1a0a000 mov sl, r0
for (; *fmt != '\0'; fmt++) {
3000914c: e5d00000 ldrb r0, [r0]
*/
void vprintk(
const char *fmt,
va_list ap
)
{
30009150: e24dd01c sub sp, sp, #28
for (; *fmt != '\0'; fmt++) {
30009154: e3500000 cmp r0, #0
*/
void vprintk(
const char *fmt,
va_list ap
)
{
30009158: e58d1000 str r1, [sp]
for (; *fmt != '\0'; fmt++) {
3000915c: 0a00006e beq 3000931c <vprintk+0x1d8>
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
BSP_output_char(*fmt);
30009160: e59f8340 ldr r8, [pc, #832] ; 300094a8 <vprintk+0x364>
* console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
30009164: e28db008 add fp, sp, #8
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
30009168: e3500025 cmp r0, #37 ; 0x25
3000916c: 1a00006d bne 30009328 <vprintk+0x1e4>
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
30009170: e5fa3001 ldrb r3, [sl, #1]! 30009174: e3530030 cmp r3, #48 ; 0x30
lead = '0';
fmt++;
30009178: 05fa3001 ldrbeq r3, [sl, #1]!
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
3000917c: 03a02030 moveq r2, #48 ; 0x30
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
30009180: 13a02020 movne r2, #32
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
30009184: 058d2004 streq r2, [sp, #4]
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
30009188: 158d2004 strne r2, [sp, #4]
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
3000918c: e353002d cmp r3, #45 ; 0x2d
minus = true;
fmt++;
30009190: 05fa3001 ldrbeq r3, [sl, #1]!
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
30009194: 03a09001 moveq r9, #1
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
30009198: e2432030 sub r2, r3, #48 ; 0x30
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
3000919c: 13a09000 movne r9, #0
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
300091a0: e3520009 cmp r2, #9 300091a4: 83a06000 movhi r6, #0
300091a8: 8a000009 bhi 300091d4 <vprintk+0x90> * console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
300091ac: e28a2001 add r2, sl, #1 300091b0: e3a06000 mov r6, #0
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
300091b4: e0866106 add r6, r6, r6, lsl #2
width += ((unsigned) *fmt - '0');
300091b8: e0836086 add r6, r3, r6, lsl #1 300091bc: e1a0a002 mov sl, r2
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
300091c0: e4d23001 ldrb r3, [r2], #1
width *= 10;
width += ((unsigned) *fmt - '0');
300091c4: e2466030 sub r6, r6, #48 ; 0x30
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
300091c8: e2431030 sub r1, r3, #48 ; 0x30 300091cc: e3510009 cmp r1, #9
300091d0: 9afffff7 bls 300091b4 <vprintk+0x70>
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
300091d4: e353006c cmp r3, #108 ; 0x6c
lflag = true;
c = *++fmt;
300091d8: 05fa3001 ldrbeq r3, [sl, #1]!
}
if ( c == 'c' ) {
300091dc: e3530063 cmp r3, #99 ; 0x63
300091e0: 0a00008c beq 30009418 <vprintk+0x2d4>
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
BSP_output_char(chr);
continue;
}
if ( c == 's' ) {
300091e4: e3530073 cmp r3, #115 ; 0x73
300091e8: 0a000054 beq 30009340 <vprintk+0x1fc>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
300091ec: e353006f cmp r3, #111 ; 0x6f 300091f0: 1353004f cmpne r3, #79 ; 0x4f
base = 8; sign = false;
300091f4: 03a03000 moveq r3, #0 300091f8: 03a09008 moveq r9, #8
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
300091fc: 0a000009 beq 30009228 <vprintk+0xe4>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
30009200: e3530069 cmp r3, #105 ; 0x69 30009204: 13530049 cmpne r3, #73 ; 0x49
30009208: 0a000004 beq 30009220 <vprintk+0xdc>
c == 'd' || c == 'D' ) {
3000920c: e3530064 cmp r3, #100 ; 0x64 30009210: 13530044 cmpne r3, #68 ; 0x44 30009214: 13a01000 movne r1, #0 30009218: 03a01001 moveq r1, #1
3000921c: 1a000087 bne 30009440 <vprintk+0x2fc>
base = 10; sign = true;
30009220: e3a03001 mov r3, #1 30009224: e3a0900a mov r9, #10
} else {
BSP_output_char(c);
continue;
}
printNum(
30009228: e59d2000 ldr r2, [sp]
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
3000922c: e3530000 cmp r3, #0
} else {
BSP_output_char(c);
continue;
}
printNum(
30009230: e5927000 ldr r7, [r2]
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
30009234: e2822004 add r2, r2, #4 30009238: e58d2000 str r2, [sp]
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
3000923c: 0a000001 beq 30009248 <vprintk+0x104>
30009240: e3570000 cmp r7, #0
30009244: ba000090 blt 3000948c <vprintk+0x348>
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
30009248: e1a00007 mov r0, r7 3000924c: e1a01009 mov r1, r9 30009250: eb00314a bl 30015780 <__aeabi_uidiv> 30009254: e3500000 cmp r0, #0 30009258: e1a04000 mov r4, r0 3000925c: e1a05000 mov r5, r0 30009260: 01a04007 moveq r4, r7 30009264: 03a07001 moveq r7, #1
30009268: 0a000010 beq 300092b0 <vprintk+0x16c>
3000926c: e20930ff and r3, r9, #255 ; 0xff 30009270: e1a02007 mov r2, r7
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
30009274: e3a05000 mov r5, #0 30009278: e1a07003 mov r7, r3 3000927c: ea000001 b 30009288 <vprintk+0x144>
while ((n = unsigned_num / base) > 0) {
30009280: e1a02004 mov r2, r4 30009284: e1a04000 mov r4, r0
toPrint[count++] = (char) (unsigned_num - (n * base));
30009288: e0030794 mul r3, r4, r7 3000928c: e0633002 rsb r3, r3, r2 30009290: e7cb3005 strb r3, [fp, r5]
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
30009294: e1a00004 mov r0, r4 30009298: e1a01009 mov r1, r9 3000929c: eb003137 bl 30015780 <__aeabi_uidiv> 300092a0: e3500000 cmp r0, #0
toPrint[count++] = (char) (unsigned_num - (n * base));
300092a4: e2855001 add r5, r5, #1
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
300092a8: 1afffff4 bne 30009280 <vprintk+0x13c>
300092ac: e2857001 add r7, r5, #1
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
300092b0: e28d301c add r3, sp, #28 300092b4: e0835005 add r5, r3, r5
for (n=maxwidth ; n > count; n-- )
300092b8: e1570006 cmp r7, r6
count = 0;
while ((n = unsigned_num / base) > 0) {
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
300092bc: e5454014 strb r4, [r5, #-20]
for (n=maxwidth ; n > count; n-- )
300092c0: 2a000006 bcs 300092e0 <vprintk+0x19c>
300092c4: e59d4004 ldr r4, [sp, #4]
BSP_output_char(lead);
300092c8: e1a00004 mov r0, r4
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
300092cc: e2466001 sub r6, r6, #1
BSP_output_char(lead);
300092d0: e1a0e00f mov lr, pc 300092d4: e598f000 ldr pc, [r8]
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
300092d8: e1570006 cmp r7, r6
300092dc: 3afffff9 bcc 300092c8 <vprintk+0x184>
BSP_output_char(lead);
for (n = 0; n < count; n++) {
300092e0: e3570000 cmp r7, #0
300092e4: 0a000009 beq 30009310 <vprintk+0x1cc> * console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
300092e8: e08b5007 add r5, fp, r7 300092ec: e3a04000 mov r4, #0
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
300092f0: e5753001 ldrb r3, [r5, #-1]! 300092f4: e59f21b0 ldr r2, [pc, #432] ; 300094ac <vprintk+0x368>
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
300092f8: e2844001 add r4, r4, #1
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
300092fc: e7d20003 ldrb r0, [r2, r3] 30009300: e1a0e00f mov lr, pc 30009304: e598f000 ldr pc, [r8]
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
30009308: e1570004 cmp r7, r4
3000930c: 8afffff7 bhi 300092f0 <vprintk+0x1ac>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30009310: e5fa0001 ldrb r0, [sl, #1]! 30009314: e3500000 cmp r0, #0
30009318: 1affff92 bne 30009168 <vprintk+0x24>
sign,
width,
lead
);
}
}
3000931c: e28dd01c add sp, sp, #28
30009320: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
} else {
BSP_output_char(c);
30009324: e1a00003 mov r0, r3 30009328: e1a0e00f mov lr, pc 3000932c: e598f000 ldr pc, [r8]
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30009330: e5fa0001 ldrb r0, [sl, #1]! 30009334: e3500000 cmp r0, #0
30009338: 1affff8a bne 30009168 <vprintk+0x24>
3000933c: eafffff6 b 3000931c <vprintk+0x1d8>
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
30009340: e59d2000 ldr r2, [sp] 30009344: e5925000 ldr r5, [r2] 30009348: e2823004 add r3, r2, #4
if ( str == NULL ) {
str = "";
3000934c: e59f215c ldr r2, [pc, #348] ; 300094b0 <vprintk+0x36c> 30009350: e3550000 cmp r5, #0 30009354: 01a05002 moveq r5, r2
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
30009358: e58d3000 str r3, [sp]
if ( str == NULL ) {
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
3000935c: e5d54000 ldrb r4, [r5] 30009360: e3540000 cmp r4, #0
30009364: 0a000005 beq 30009380 <vprintk+0x23c>
30009368: e1a03005 mov r3, r5 3000936c: e3a04000 mov r4, #0 30009370: e5f32001 ldrb r2, [r3, #1]! 30009374: e2844001 add r4, r4, #1 30009378: e3520000 cmp r2, #0
3000937c: 1afffffb bne 30009370 <vprintk+0x22c>
;
/* leading spaces */
if ( !minus )
30009380: e3590000 cmp r9, #0
30009384: 1a000008 bne 300093ac <vprintk+0x268>
for ( i=len ; i<width ; i++ )
30009388: e1540006 cmp r4, r6
3000938c: 2a000006 bcs 300093ac <vprintk+0x268>
30009390: e1a07004 mov r7, r4
BSP_output_char(' ');
30009394: e3a00020 mov r0, #32
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
30009398: e2877001 add r7, r7, #1
BSP_output_char(' ');
3000939c: e1a0e00f mov lr, pc 300093a0: e598f000 ldr pc, [r8]
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
300093a4: e1570006 cmp r7, r6
300093a8: 3afffff9 bcc 30009394 <vprintk+0x250>
BSP_output_char(' ');
/* no width option */
if (width == 0) {
300093ac: e3560000 cmp r6, #0
300093b0: 1a000002 bne 300093c0 <vprintk+0x27c>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
300093b4: e3540000 cmp r4, #0
300093b8: 0a000008 beq 300093e0 <vprintk+0x29c>
300093bc: e1a06004 mov r6, r4 300093c0: e5d50000 ldrb r0, [r5] 300093c4: e3500000 cmp r0, #0
300093c8: 0a000004 beq 300093e0 <vprintk+0x29c>
BSP_output_char(*str);
300093cc: e1a0e00f mov lr, pc 300093d0: e598f000 ldr pc, [r8]
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
300093d4: e5f50001 ldrb r0, [r5, #1]! 300093d8: e3500000 cmp r0, #0
300093dc: 1afffffa bne 300093cc <vprintk+0x288>
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
300093e0: e3590000 cmp r9, #0
300093e4: 0affffc9 beq 30009310 <vprintk+0x1cc>
for ( i=len ; i<width ; i++ )
300093e8: e1540006 cmp r4, r6
300093ec: 2affffc7 bcs 30009310 <vprintk+0x1cc>
BSP_output_char(' ');
300093f0: e3a00020 mov r0, #32
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
300093f4: e2844001 add r4, r4, #1
BSP_output_char(' ');
300093f8: e1a0e00f mov lr, pc 300093fc: e598f000 ldr pc, [r8]
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
30009400: e1540006 cmp r4, r6
30009404: 3afffff9 bcc 300093f0 <vprintk+0x2ac>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30009408: e5fa0001 ldrb r0, [sl, #1]! 3000940c: e3500000 cmp r0, #0
30009410: 1affff54 bne 30009168 <vprintk+0x24>
30009414: eaffffc0 b 3000931c <vprintk+0x1d8> <== NOT EXECUTED
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
30009418: e59d3000 ldr r3, [sp] 3000941c: e2834004 add r4, r3, #4
BSP_output_char(chr);
30009420: e5d30000 ldrb r0, [r3] 30009424: e1a0e00f mov lr, pc 30009428: e598f000 ldr pc, [r8]
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
3000942c: e58d4000 str r4, [sp]
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30009430: e5fa0001 ldrb r0, [sl, #1]! 30009434: e3500000 cmp r0, #0
30009438: 1affff4a bne 30009168 <vprintk+0x24>
3000943c: eaffffb6 b 3000931c <vprintk+0x1d8> <== NOT EXECUTED
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
30009440: e3530075 cmp r3, #117 ; 0x75 30009444: 13530055 cmpne r3, #85 ; 0x55 30009448: 13a00000 movne r0, #0 3000944c: 03a00001 moveq r0, #1
base = 10; sign = false;
30009450: 01a03001 moveq r3, r1 30009454: 03a0900a moveq r9, #10
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
30009458: 0affff72 beq 30009228 <vprintk+0xe4>
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
3000945c: e3530078 cmp r3, #120 ; 0x78 30009460: 13530058 cmpne r3, #88 ; 0x58 30009464: 13a01000 movne r1, #0 30009468: 03a01001 moveq r1, #1
base = 16; sign = false;
3000946c: 01a03000 moveq r3, r0 30009470: 03a09010 moveq r9, #16
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
30009474: 0affff6b beq 30009228 <vprintk+0xe4>
base = 16; sign = false;
} else if ( c == 'p' ) {
30009478: e3530070 cmp r3, #112 ; 0x70
3000947c: 1affffa8 bne 30009324 <vprintk+0x1e0>
base = 16; sign = false; lflag = true;
30009480: e1a03001 mov r3, r1 30009484: e3a09010 mov r9, #16 30009488: eaffff66 b 30009228 <vprintk+0xe4>
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
3000948c: e3a0002d mov r0, #45 ; 0x2d 30009490: e1a0e00f mov lr, pc 30009494: e598f000 ldr pc, [r8]
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
30009498: e3560000 cmp r6, #0
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
unsigned_num = (unsigned long) -num;
3000949c: e2677000 rsb r7, r7, #0
if (maxwidth) maxwidth--;
300094a0: 12466001 subne r6, r6, #1 300094a4: eaffff67 b 30009248 <vprintk+0x104>
30009adc <wait>:
#include <rtems/seterr.h>
int wait(
int *stat_loc
)
{
30009adc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009ae0: eb0023bc bl 300129d8 <__errno> <== NOT EXECUTED 30009ae4: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009ae8: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009aec: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009af0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009af4 <waitpid>:
int waitpid(
pid_t pid,
int *stat_loc,
int options
)
{
30009af4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
30009af8: eb0023b6 bl 300129d8 <__errno> <== NOT EXECUTED 30009afc: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30009b00: e5803000 str r3, [r0] <== NOT EXECUTED
}
30009b04: e3e00000 mvn r0, #0 <== NOT EXECUTED
30009b08: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30017b40 <write>:
)
{
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30017b40: e59f30a4 ldr r3, [pc, #164] ; 30017bec <write+0xac>
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
30017b44: e92d4010 push {r4, lr}
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30017b48: e5933000 ldr r3, [r3] 30017b4c: e1500003 cmp r0, r3
30017b50: 2a00001b bcs 30017bc4 <write+0x84> iop = rtems_libio_iop( fd );
30017b54: e59f4094 ldr r4, [pc, #148] ; 30017bf0 <write+0xb0> 30017b58: e0600180 rsb r0, r0, r0, lsl #3 30017b5c: e5944000 ldr r4, [r4] 30017b60: e0844180 add r4, r4, r0, lsl #3
rtems_libio_check_is_open( iop );
30017b64: e5940014 ldr r0, [r4, #20] 30017b68: e3100c01 tst r0, #256 ; 0x100
30017b6c: 0a000014 beq 30017bc4 <write+0x84> rtems_libio_check_buffer( buffer );
30017b70: e3510000 cmp r1, #0
30017b74: 0a000017 beq 30017bd8 <write+0x98> rtems_libio_check_count( count );
30017b78: e3520000 cmp r2, #0
30017b7c: 0a00000e beq 30017bbc <write+0x7c> rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30017b80: e3100004 tst r0, #4
30017b84: 0a000013 beq 30017bd8 <write+0x98>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
30017b88: e5943020 ldr r3, [r4, #32] 30017b8c: e1a00004 mov r0, r4 30017b90: e1a0e00f mov lr, pc 30017b94: e593f00c ldr pc, [r3, #12]
if ( rc > 0 )
30017b98: e3500000 cmp r0, #0
30017b9c: d8bd8010 pople {r4, pc}
iop->offset += rc;
30017ba0: e284300c add r3, r4, #12
30017ba4: e893000c ldm r3, {r2, r3}
30017ba8: e0922000 adds r2, r2, r0
30017bac: e0a33fc0 adc r3, r3, r0, asr #31
30017bb0: e584200c str r2, [r4, #12]
30017bb4: e5843010 str r3, [r4, #16]
30017bb8: e8bd8010 pop {r4, pc}
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
30017bbc: e1a00002 mov r0, r2 <== NOT EXECUTED
if ( rc > 0 )
iop->offset += rc;
return rc;
}
30017bc0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
30017bc4: ebffe92a bl 30012074 <__errno> <== NOT EXECUTED
30017bc8: e3a03009 mov r3, #9 <== NOT EXECUTED
30017bcc: e5803000 str r3, [r0] <== NOT EXECUTED
30017bd0: e3e00000 mvn r0, #0 <== NOT EXECUTED
30017bd4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30017bd8: ebffe925 bl 30012074 <__errno> <== NOT EXECUTED
30017bdc: e3a03016 mov r3, #22 <== NOT EXECUTED
30017be0: e5803000 str r3, [r0] <== NOT EXECUTED
30017be4: e3e00000 mvn r0, #0 <== NOT EXECUTED
30017be8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a944 <writev>:
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
3000a944: e59f3158 ldr r3, [pc, #344] ; 3000aaa4 <writev+0x160> <== NOT EXECUTED
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
3000a948: 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 );
3000a94c: e5933000 ldr r3, [r3] <== NOT EXECUTED
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
3000a950: e1a05002 mov r5, r2 <== NOT EXECUTED
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
3000a954: e1500003 cmp r0, r3 <== NOT EXECUTED 3000a958: 2a00004a bcs 3000aa88 <writev+0x144> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
3000a95c: e59f3144 ldr r3, [pc, #324] ; 3000aaa8 <writev+0x164> <== NOT EXECUTED 3000a960: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 3000a964: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a968: e0838180 add r8, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
3000a96c: e5983014 ldr r3, [r8, #20] <== NOT EXECUTED 3000a970: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3000a974: 0a000043 beq 3000aa88 <writev+0x144> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000a978: e3130004 tst r3, #4 <== NOT EXECUTED 3000a97c: 0a00003b beq 3000aa70 <writev+0x12c> <== NOT EXECUTED
/*
* Argument validation on IO vector
*/
if ( !iov )
3000a980: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a984: 0a000039 beq 3000aa70 <writev+0x12c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
3000a988: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a98c: da000037 ble 3000aa70 <writev+0x12c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
3000a990: e3520b01 cmp r2, #1024 ; 0x400 <== NOT EXECUTED 3000a994: ca000035 bgt 3000aa70 <writev+0x12c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000a998: e1a04001 mov r4, 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 )
3000a99c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a9a0: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a9a4: e3a06001 mov r6, #1 <== NOT EXECUTED 3000a9a8: e1a07001 mov r7, r1 <== NOT EXECUTED
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
3000a9ac: e59fc0f8 ldr ip, [pc, #248] ; 3000aaac <writev+0x168> <== NOT EXECUTED 3000a9b0: ea000000 b 3000a9b8 <writev+0x74> <== NOT EXECUTED
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
3000a9b4: e1a07003 mov r7, r3 <== 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 )
3000a9b8: e5923000 ldr r3, [r2] <== 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++ ) {
3000a9bc: e2811001 add r1, r1, #1 <== 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 )
3000a9c0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a9c4: 0a000029 beq 3000aa70 <writev+0x12c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
3000a9c8: e5920004 ldr r0, [r2, #4] <== 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++ ) {
3000a9cc: e2822008 add r2, r2, #8 <== NOT EXECUTED
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
3000a9d0: e0873000 add r3, r7, r0 <== NOT EXECUTED
*/
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
3000a9d4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a9d8: 13a06000 movne r6, #0 <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
3000a9dc: e1570003 cmp r7, r3 <== NOT EXECUTED 3000a9e0: d153000c cmple r3, ip <== NOT EXECUTED 3000a9e4: d3a07000 movle r7, #0 <== NOT EXECUTED 3000a9e8: c3a07001 movgt r7, #1 <== NOT EXECUTED 3000a9ec: ca00001f bgt 3000aa70 <writev+0x12c> <== 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++ ) {
3000a9f0: e1550001 cmp r5, r1 <== NOT EXECUTED 3000a9f4: caffffee bgt 3000a9b4 <writev+0x70> <== NOT EXECUTED
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
3000a9f8: e3560000 cmp r6, #0 <== NOT EXECUTED 3000a9fc: 1a00001f bne 3000aa80 <writev+0x13c> <== NOT EXECUTED 3000aa00: e1a07006 mov r7, r6 <== NOT EXECUTED 3000aa04: ea000003 b 3000aa18 <writev+0xd4> <== NOT EXECUTED
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3000aa08: e2866001 add r6, r6, #1 <== NOT EXECUTED 3000aa0c: e1550006 cmp r5, r6 <== NOT EXECUTED 3000aa10: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000aa14: da000019 ble 3000aa80 <writev+0x13c> <== NOT EXECUTED
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
3000aa18: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000aa1c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000aa20: 0afffff8 beq 3000aa08 <writev+0xc4> <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
3000aa24: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000aa28: e5983020 ldr r3, [r8, #32] <== NOT EXECUTED 3000aa2c: e1a00008 mov r0, r8 <== NOT EXECUTED 3000aa30: e1a0e00f mov lr, pc <== NOT EXECUTED 3000aa34: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
3000aa38: e3500000 cmp r0, #0 <== NOT EXECUTED 3000aa3c: ba000016 blt 3000aa9c <writev+0x158> <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
3000aa40: 0a000006 beq 3000aa60 <writev+0x11c> <== NOT EXECUTED
iop->offset += bytes;
3000aa44: e288300c add r3, r8, #12 <== NOT EXECUTED
3000aa48: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000aa4c: e0922000 adds r2, r2, r0 <== NOT EXECUTED
3000aa50: e0a33fc0 adc r3, r3, r0, asr #31 <== NOT EXECUTED
3000aa54: e588200c str r2, [r8, #12] <== NOT EXECUTED
3000aa58: e5883010 str r3, [r8, #16] <== NOT EXECUTED
total += bytes;
3000aa5c: e0877000 add r7, r7, r0 <== NOT EXECUTED
}
if (bytes != iov[ v ].iov_len)
3000aa60: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3000aa64: e1500003 cmp r0, r3 <== NOT EXECUTED 3000aa68: 0affffe6 beq 3000aa08 <writev+0xc4> <== NOT EXECUTED 3000aa6c: ea000003 b 3000aa80 <writev+0x13c> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
3000aa70: eb0021a9 bl 3001311c <__errno> <== NOT EXECUTED 3000aa74: e3a03016 mov r3, #22 <== NOT EXECUTED 3000aa78: e5803000 str r3, [r0] <== NOT EXECUTED 3000aa7c: e3e07000 mvn r7, #0 <== NOT EXECUTED
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
3000aa80: e1a00007 mov r0, r7 <== NOT EXECUTED
3000aa84: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
3000aa88: eb0021a3 bl 3001311c <__errno> <== NOT EXECUTED 3000aa8c: e3a03009 mov r3, #9 <== NOT EXECUTED 3000aa90: e5803000 str r3, [r0] <== NOT EXECUTED 3000aa94: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000aa98: eafffff8 b 3000aa80 <writev+0x13c> <== NOT EXECUTED
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
3000aa9c: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000aaa0: eafffff6 b 3000aa80 <writev+0x13c> <== NOT EXECUTED