00016b50 <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
16b50: 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
)
{
16b54: 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 ) {
16b58: 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
)
{
16b5c: e1a07000 mov r7, r0 16b60: e1a05002 mov r5, r2 16b64: e1a08001 mov r8, r1 16b68: 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 ) {
16b6c: 3a000016 bcc 16bcc <_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 ) {
16b70: e5906048 ldr r6, [r0, #72] ; 0x48 16b74: e3560000 cmp r6, #0
*count = 0;
16b78: 13a00000 movne r0, #0 16b7c: 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 ) {
16b80: 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 =
16b84: e1a00007 mov r0, r7 16b88: eb000a60 bl 19510 <_Thread_queue_Dequeue> 16b8c: e2504000 subs r4, r0, #0
16b90: 0a00000a beq 16bc0 <_CORE_message_queue_Broadcast+0x70>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
16b94: e594002c ldr r0, [r4, #44] ; 0x2c 16b98: e1a01008 mov r1, r8 16b9c: e1a02005 mov r2, r5 16ba0: eb00246b bl 1fd54 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
16ba4: 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 =
16ba8: e1a00007 mov r0, r7
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
16bac: 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 =
16bb0: eb000a56 bl 19510 <_Thread_queue_Dequeue> 16bb4: e2504000 subs r4, r0, #0
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
16bb8: 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 =
16bbc: 1afffff4 bne 16b94 <_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;
16bc0: e58a6000 str r6, [sl]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
16bc4: e1a00004 mov r0, r4
16bc8: 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;
16bcc: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
16bd0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0000b46c <_Chain_Initialize>:
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
b46c: e3520000 cmp r2, #0
Chain_Node *current;
Chain_Node *next;
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
b470: e3a0c000 mov ip, #0
next = starting_address;
while ( count-- ) {
b474: 12422001 subne r2, r2, #1
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
b478: e92d0070 push {r4, r5, r6}
Chain_Node *current;
Chain_Node *next;
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
b47c: e580c004 str ip, [r0, #4]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return (Chain_Node *) the_chain;
b480: e1a04000 mov r4, r0
next = starting_address;
while ( count-- ) {
b484: 11a06002 movne r6, r2
Chain_Node *next;
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
b488: 11a0c001 movne ip, r1
while ( count-- ) {
b48c: 1a000003 bne b4a0 <_Chain_Initialize+0x34>
b490: ea000008 b b4b8 <_Chain_Initialize+0x4c> <== NOT EXECUTED
b494: e1a0400c mov r4, ip
b498: e2422001 sub r2, r2, #1
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
b49c: e1a0c005 mov ip, r5
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
b4a0: e3520000 cmp r2, #0
current->next = next;
b4a4: e584c000 str ip, [r4]
next->previous = current;
b4a8: e58c4004 str r4, [ip, #4]
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
b4ac: e08c5003 add r5, ip, r3
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
b4b0: 1afffff7 bne b494 <_Chain_Initialize+0x28>
b4b4: e0241396 mla r4, r6, r3, r1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
b4b8: e2803004 add r3, r0, #4
next->previous = current;
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = _Chain_Tail( the_chain );
b4bc: e5843000 str r3, [r4]
the_chain->last = current;
b4c0: e5804008 str r4, [r0, #8]
}
b4c4: e8bd0070 pop {r4, r5, r6}
b4c8: e12fff1e bx lr
0000b6ac <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
b6ac: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
b6b0: 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;
b6b4: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
b6b8: e24dd01c sub sp, sp, #28
b6bc: 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 ) {
b6c0: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
b6c4: 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 ) {
b6c8: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
b6cc: 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;
b6d0: 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 ) {
b6d4: 2a00007a bcs b8c4 <_Heap_Allocate_aligned_with_boundary+0x218>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
b6d8: e3530000 cmp r3, #0
b6dc: 1a000076 bne b8bc <_Heap_Allocate_aligned_with_boundary+0x210>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
b6e0: 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 ) {
b6e4: e1570009 cmp r7, r9
b6e8: 0a000075 beq b8c4 <_Heap_Allocate_aligned_with_boundary+0x218>
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
b6ec: e59d300c ldr r3, [sp, #12]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
b6f0: 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
b6f4: e2833007 add r3, r3, #7
b6f8: e58d3010 str r3, [sp, #16]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
b6fc: e58d1014 str r1, [sp, #20]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
b700: e3a06001 mov r6, #1
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
b704: e599a004 ldr sl, [r9, #4]
b708: e59d2000 ldr r2, [sp]
b70c: e152000a cmp r2, sl
b710: 2a000050 bcs b858 <_Heap_Allocate_aligned_with_boundary+0x1ac>
if ( alignment == 0 ) {
b714: 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;
b718: 02894008 addeq r4, r9, #8
b71c: 0a000053 beq b870 <_Heap_Allocate_aligned_with_boundary+0x1c4>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
b720: 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;
b724: 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;
b728: 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;
b72c: 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;
b730: 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;
b734: e081400a add r4, r1, sl
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
b738: 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;
b73c: e0633002 rsb r3, r3, r2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
b740: 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
b744: e083a00a add sl, r3, sl
b748: 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;
b74c: e2893008 add r3, r9, #8
b750: e58d3008 str r3, [sp, #8]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
b754: eb001697 bl 111b8 <__umodsi3>
b758: 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 ) {
b75c: e15a0004 cmp sl, r4
b760: 2a000003 bcs b774 <_Heap_Allocate_aligned_with_boundary+0xc8>
b764: e1a0000a mov r0, sl
b768: e1a01008 mov r1, r8
b76c: eb001691 bl 111b8 <__umodsi3>
b770: e060400a rsb r4, r0, sl
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
b774: e35b0000 cmp fp, #0
b778: 0a000026 beq b818 <_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;
b77c: e084a005 add sl, r4, r5
b780: e1a0000a mov r0, sl
b784: e1a0100b mov r1, fp
b788: eb00168a bl 111b8 <__umodsi3>
b78c: e060000a rsb r0, r0, sl
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
b790: e15a0000 cmp sl, r0
b794: 93a0a000 movls sl, #0
b798: 83a0a001 movhi sl, #1
b79c: e1540000 cmp r4, r0
b7a0: 23a0a000 movcs sl, #0
b7a4: e35a0000 cmp sl, #0
b7a8: 0a00001a beq b818 <_Heap_Allocate_aligned_with_boundary+0x16c>
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
b7ac: e59d1008 ldr r1, [sp, #8]
b7b0: e0813005 add r3, r1, r5
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
b7b4: e1530000 cmp r3, r0
b7b8: 958d9018 strls r9, [sp, #24]
b7bc: 91a09003 movls r9, r3
b7c0: 9a000002 bls b7d0 <_Heap_Allocate_aligned_with_boundary+0x124>
b7c4: ea000023 b b858 <_Heap_Allocate_aligned_with_boundary+0x1ac>
b7c8: e1590000 cmp r9, r0
b7cc: 8a00003e bhi b8cc <_Heap_Allocate_aligned_with_boundary+0x220>
return 0;
}
alloc_begin = boundary_line - alloc_size;
b7d0: e0654000 rsb r4, r5, r0
b7d4: e1a01008 mov r1, r8
b7d8: e1a00004 mov r0, r4
b7dc: eb001675 bl 111b8 <__umodsi3>
b7e0: e0604004 rsb r4, r0, r4
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
b7e4: e084a005 add sl, r4, r5
b7e8: e1a0000a mov r0, sl
b7ec: e1a0100b mov r1, fp
b7f0: eb001670 bl 111b8 <__umodsi3>
b7f4: e060000a rsb r0, r0, sl
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
b7f8: e15a0000 cmp sl, r0
b7fc: 93a0a000 movls sl, #0
b800: 83a0a001 movhi sl, #1
b804: e1540000 cmp r4, r0
b808: 23a0a000 movcs sl, #0
b80c: e35a0000 cmp sl, #0
b810: 1affffec bne b7c8 <_Heap_Allocate_aligned_with_boundary+0x11c>
b814: e59d9018 ldr r9, [sp, #24]
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
b818: e59d2008 ldr r2, [sp, #8]
b81c: e1520004 cmp r2, r4
b820: 8a00000c bhi b858 <_Heap_Allocate_aligned_with_boundary+0x1ac>
b824: e59d100c ldr r1, [sp, #12]
b828: e1a00004 mov r0, r4
b82c: eb001661 bl 111b8 <__umodsi3>
b830: e269a4ff rsb sl, r9, #-16777216 ; 0xff000000
b834: e28aa8ff add sl, sl, #16711680 ; 0xff0000
b838: e28aacff add sl, sl, #65280 ; 0xff00
b83c: e28aa0f8 add sl, sl, #248 ; 0xf8
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
b840: 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 ) {
b844: e59d1004 ldr r1, [sp, #4]
b848: e060300a rsb r3, r0, sl
b84c: e15a0000 cmp sl, r0
b850: 11510003 cmpne r1, r3
b854: 9a000005 bls b870 <_Heap_Allocate_aligned_with_boundary+0x1c4>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
b858: e5999008 ldr r9, [r9, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
b85c: e1570009 cmp r7, r9
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
b860: 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 ) {
b864: 0a00001d beq b8e0 <_Heap_Allocate_aligned_with_boundary+0x234>
b868: e1a06003 mov r6, r3
b86c: eaffffa4 b b704 <_Heap_Allocate_aligned_with_boundary+0x58>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
b870: e3540000 cmp r4, #0
b874: 0afffff7 beq b858 <_Heap_Allocate_aligned_with_boundary+0x1ac>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
b878: e2872048 add r2, r7, #72 ; 0x48
b87c: e892000c ldm r2, {r2, r3}
b880: e2822001 add r2, r2, #1
stats->searches += search_count;
b884: 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;
b888: e5872048 str r2, [r7, #72] ; 0x48
stats->searches += search_count;
b88c: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
b890: e1a00007 mov r0, r7
b894: e1a01009 mov r1, r9
b898: e1a02004 mov r2, r4
b89c: e1a03005 mov r3, r5
b8a0: ebffebcb bl 67d4 <_Heap_Block_allocate>
b8a4: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
b8a8: e5973044 ldr r3, [r7, #68] ; 0x44
b8ac: e1530006 cmp r3, r6
stats->max_search = search_count;
b8b0: 35876044 strcc r6, [r7, #68] ; 0x44
}
return (void *) alloc_begin;
}
b8b4: e28dd01c add sp, sp, #28
b8b8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
b8bc: e1550003 cmp r5, r3
b8c0: 9a000008 bls b8e8 <_Heap_Allocate_aligned_with_boundary+0x23c>
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
b8c4: e3a00000 mov r0, #0
b8c8: eafffff9 b b8b4 <_Heap_Allocate_aligned_with_boundary+0x208>
b8cc: e59d9018 ldr r9, [sp, #24] <== NOT EXECUTED
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
b8d0: 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 ) {
b8d4: e1570009 cmp r7, r9 <== NOT EXECUTED
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
b8d8: e2863001 add r3, r6, #1 <== 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 ) {
b8dc: 1affffe1 bne b868 <_Heap_Allocate_aligned_with_boundary+0x1bc><== NOT EXECUTED
b8e0: e3a00000 mov r0, #0
b8e4: eaffffef b b8a8 <_Heap_Allocate_aligned_with_boundary+0x1fc>
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
b8e8: e3580000 cmp r8, #0
b8ec: 01a08002 moveq r8, r2
b8f0: eaffff7a b b6e0 <_Heap_Allocate_aligned_with_boundary+0x34>
0000b8f4 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
b8f4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
b8f8: e1a04000 mov r4, r0
b8fc: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
b900: e1a00001 mov r0, r1
b904: e5941010 ldr r1, [r4, #16]
b908: eb00162a bl 111b8 <__umodsi3>
b90c: e2455008 sub r5, 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
b910: 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);
b914: 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;
b918: e1550003 cmp r5, r3
b91c: 3a00002f bcc b9e0 <_Heap_Free+0xec>
b920: e5941024 ldr r1, [r4, #36] ; 0x24
b924: e1550001 cmp r5, r1
b928: 8a00002c bhi b9e0 <_Heap_Free+0xec>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b92c: 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;
b930: 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);
b934: e0852006 add r2, 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;
b938: e1530002 cmp r3, r2
b93c: 8a000027 bhi b9e0 <_Heap_Free+0xec>
b940: e1510002 cmp r1, r2
b944: 3a000027 bcc b9e8 <_Heap_Free+0xf4>
b948: e5927004 ldr r7, [r2, #4]
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
b94c: e2170001 ands r0, r7, #1
b950: 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 ));
b954: e1510002 cmp r1, r2
- 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;
b958: e3c77001 bic r7, r7, #1
b95c: 03a08000 moveq r8, #0
b960: 0a000004 beq b978 <_Heap_Free+0x84>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b964: e0820007 add r0, r2, 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;
b968: e5900004 ldr r0, [r0, #4]
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
b96c: e3100001 tst r0, #1
b970: 13a08000 movne r8, #0
b974: 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 ) ) {
b978: e21c0001 ands r0, ip, #1
b97c: 1a00001b bne b9f0 <_Heap_Free+0xfc>
uintptr_t const prev_size = block->prev_size;
b980: 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);
b984: 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;
b988: e153000a cmp r3, sl
b98c: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
b990: e151000a cmp r1, sl
b994: 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;
b998: 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) ) {
b99c: e2100001 ands r0, r0, #1
b9a0: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
b9a4: e3580000 cmp r8, #0
b9a8: 0a000039 beq ba94 <_Heap_Free+0x1a0>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
b9ac: 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;
b9b0: e0867007 add r7, r6, r7
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b9b4: e5923008 ldr r3, [r2, #8]
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
b9b8: e087c00c add ip, r7, ip
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b9bc: e592200c ldr r2, [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;
b9c0: e2400001 sub r0, r0, #1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
b9c4: 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;
b9c8: e5823008 str r3, [r2, #8]
next->prev = prev;
b9cc: e583200c str r2, [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;
b9d0: e5840038 str r0, [r4, #56] ; 0x38
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
b9d4: 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;
b9d8: e78ac00c str ip, [sl, ip]
b9dc: ea00000f b ba20 <_Heap_Free+0x12c>
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
b9e0: e3a00000 mov r0, #0
b9e4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
b9e8: e3a00000 mov r0, #0 <== NOT EXECUTED
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b9ec: 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 */
b9f0: e3580000 cmp r8, #0
b9f4: 0a000014 beq ba4c <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
b9f8: e5923008 ldr r3, [r2, #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;
b9fc: e0877006 add r7, r7, r6
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ba00: e592200c ldr r2, [r2, #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;
ba04: e3871001 orr r1, r7, #1
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
ba08: e5853008 str r3, [r5, #8]
new_block->prev = prev;
ba0c: e585200c str r2, [r5, #12]
next->prev = new_block;
prev->next = new_block;
ba10: e5825008 str r5, [r2, #8]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
ba14: e583500c str r5, [r3, #12]
ba18: e5851004 str r1, [r5, #4]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
ba1c: e7857007 str r7, [r5, r7]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ba20: e5942040 ldr r2, [r4, #64] ; 0x40
++stats->frees;
ba24: e5943050 ldr r3, [r4, #80] ; 0x50
stats->free_size += block_size;
ba28: e5941030 ldr r1, [r4, #48] ; 0x30
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ba2c: e2422001 sub r2, r2, #1
++stats->frees;
ba30: e2833001 add r3, r3, #1
stats->free_size += block_size;
ba34: e0816006 add r6, r1, r6
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ba38: e5842040 str r2, [r4, #64] ; 0x40
++stats->frees;
ba3c: e5843050 str r3, [r4, #80] ; 0x50
stats->free_size += block_size;
ba40: e5846030 str r6, [r4, #48] ; 0x30
return( true );
ba44: e3a00001 mov r0, #1
ba48: 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;
ba4c: e3863001 orr r3, r6, #1
ba50: e5853004 str r3, [r5, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
ba54: e2843038 add r3, r4, #56 ; 0x38
ba58: e8931008 ldm r3, {r3, ip}
} 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;
ba5c: e5920004 ldr r0, [r2, #4]
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
ba60: e5941008 ldr r1, [r4, #8]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
ba64: e2833001 add r3, r3, #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;
ba68: e3c00001 bic r0, r0, #1
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
ba6c: e153000c cmp r3, ip
new_block->next = next;
ba70: e5851008 str r1, [r5, #8]
new_block->prev = block_before;
ba74: 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;
ba78: e5820004 str r0, [r2, #4]
block_before->next = new_block; next->prev = new_block;
ba7c: e581500c str r5, [r1, #12]
next_block->prev_size = block_size;
ba80: 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;
ba84: e5845008 str r5, [r4, #8]
/* Statistics */
++stats->free_blocks;
ba88: e5843038 str r3, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
stats->max_free_blocks = stats->free_blocks;
ba8c: 8584303c strhi r3, [r4, #60] ; 0x3c
ba90: eaffffe2 b ba20 <_Heap_Free+0x12c>
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;
ba94: e086c00c add ip, r6, ip
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ba98: e38c3001 orr r3, ip, #1
ba9c: e58a3004 str r3, [sl, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
baa0: e5923004 ldr r3, [r2, #4]
baa4: e3c33001 bic r3, r3, #1
baa8: e5823004 str r3, [r2, #4]
next_block->prev_size = size;
baac: e785c006 str ip, [r5, r6]
bab0: eaffffda b ba20 <_Heap_Free+0x12c>
00012fe4 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
12fe4: e92d40f0 push {r4, r5, r6, r7, lr}
12fe8: e1a04000 mov r4, r0
12fec: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
12ff0: e1a00001 mov r0, r1 12ff4: e5941010 ldr r1, [r4, #16] 12ff8: e1a07002 mov r7, r2 12ffc: ebfff86d bl 111b8 <__umodsi3> 13000: 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
13004: 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);
13008: 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;
1300c: e1500003 cmp r0, r3
13010: 3a000010 bcc 13058 <_Heap_Size_of_alloc_area+0x74>
13014: e5942024 ldr r2, [r4, #36] ; 0x24 13018: e1500002 cmp r0, r2
1301c: 8a00000d bhi 13058 <_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;
13020: e5906004 ldr r6, [r0, #4] 13024: 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);
13028: 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;
1302c: e1530006 cmp r3, r6
13030: 8a000008 bhi 13058 <_Heap_Size_of_alloc_area+0x74>
13034: e1520006 cmp r2, r6
13038: 3a000008 bcc 13060 <_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;
1303c: 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 )
13040: e2100001 ands r0, r0, #1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
13044: 12655004 rsbne r5, r5, #4 13048: 10856006 addne r6, r5, r6 1304c: 15876000 strne r6, [r7]
return true;
13050: 13a00001 movne r0, #1
13054: e8bd80f0 pop {r4, r5, r6, r7, pc}
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
13058: e3a00000 mov r0, #0
1305c: e8bd80f0 pop {r4, r5, r6, r7, pc}
13060: e3a00000 mov r0, #0 <== NOT EXECUTED
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
13064: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00007544 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
7544: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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() ) ) {
7548: e59f35cc ldr r3, [pc, #1484] ; 7b1c <_Heap_Walk+0x5d8>
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;
754c: e31200ff tst r2, #255 ; 0xff
if ( !_System_state_Is_up( _System_state_Get() ) ) {
7550: e5933000 ldr r3, [r3]
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;
7554: e59f25c4 ldr r2, [pc, #1476] ; 7b20 <_Heap_Walk+0x5dc>
7558: e59f95c4 ldr r9, [pc, #1476] ; 7b24 <_Heap_Walk+0x5e0>
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
755c: e1a0a001 mov sl, r1
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;
7560: 11a09002 movne r9, r2
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
7564: e5901010 ldr r1, [r0, #16]
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() ) ) {
7568: e3530003 cmp r3, #3
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
756c: e5902014 ldr r2, [r0, #20]
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
7570: e5903024 ldr r3, [r0, #36] ; 0x24
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
7574: e24dd038 sub sp, sp, #56 ; 0x38
7578: e1a04000 mov r4, r0
uintptr_t const page_size = heap->page_size;
757c: e58d1024 str r1, [sp, #36] ; 0x24
uintptr_t const min_block_size = heap->min_block_size;
7580: e58d2028 str r2, [sp, #40] ; 0x28
Heap_Block *const first_block = heap->first_block;
7584: e5908020 ldr r8, [r0, #32]
Heap_Block *const last_block = heap->last_block;
7588: e58d302c str r3, [sp, #44] ; 0x2c
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() ) ) {
758c: 0a000002 beq 759c <_Heap_Walk+0x58>
}
block = next_block;
} while ( block != first_block );
return true;
7590: e3a00001 mov r0, #1
}
7594: e28dd038 add sp, sp, #56 ; 0x38
7598: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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)(
759c: e594101c ldr r1, [r4, #28]
75a0: e5900018 ldr r0, [r0, #24]
75a4: e2842008 add r2, r4, #8
75a8: e892000c ldm r2, {r2, r3}
75ac: e59dc028 ldr ip, [sp, #40] ; 0x28
75b0: e58d1008 str r1, [sp, #8]
75b4: e59d102c ldr r1, [sp, #44] ; 0x2c
75b8: e58d0004 str r0, [sp, #4]
75bc: e58d1010 str r1, [sp, #16]
75c0: e58d2014 str r2, [sp, #20]
75c4: e58d3018 str r3, [sp, #24]
75c8: e59f2558 ldr r2, [pc, #1368] ; 7b28 <_Heap_Walk+0x5e4>
75cc: e58dc000 str ip, [sp]
75d0: e58d800c str r8, [sp, #12]
75d4: e1a0000a mov r0, sl
75d8: e3a01000 mov r1, #0
75dc: e59d3024 ldr r3, [sp, #36] ; 0x24
75e0: e1a0e00f mov lr, pc
75e4: e12fff19 bx r9
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
75e8: e59d2024 ldr r2, [sp, #36] ; 0x24
75ec: e3520000 cmp r2, #0
75f0: 0a000026 beq 7690 <_Heap_Walk+0x14c>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
75f4: e59d3024 ldr r3, [sp, #36] ; 0x24
75f8: e2135003 ands r5, r3, #3
75fc: 1a00002a bne 76ac <_Heap_Walk+0x168>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7600: e59d0028 ldr r0, [sp, #40] ; 0x28
7604: e59d1024 ldr r1, [sp, #36] ; 0x24
7608: ebffe564 bl ba0 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
760c: e250b000 subs fp, r0, #0
7610: 1a00002c bne 76c8 <_Heap_Walk+0x184>
7614: e2880008 add r0, r8, #8
7618: e59d1024 ldr r1, [sp, #36] ; 0x24
761c: ebffe55f bl ba0 <__umodsi3>
);
return false;
}
if (
7620: e2506000 subs r6, r0, #0
7624: 1a00002f bne 76e8 <_Heap_Walk+0x1a4>
block = next_block;
} while ( block != first_block );
return true;
}
7628: e598b004 ldr fp, [r8, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
762c: e21b5001 ands r5, fp, #1
7630: 0a0000cd beq 796c <_Heap_Walk+0x428>
- 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;
7634: e59dc02c ldr ip, [sp, #44] ; 0x2c
7638: e59c3004 ldr r3, [ip, #4]
763c: e3c33001 bic r3, r3, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
7640: e08c3003 add r3, ip, r3
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;
7644: e5935004 ldr r5, [r3, #4]
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
7648: e2155001 ands r5, r5, #1
764c: 0a000008 beq 7674 <_Heap_Walk+0x130>
);
return false;
}
if (
7650: e1580003 cmp r8, r3
7654: 0a00002b beq 7708 <_Heap_Walk+0x1c4>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
7658: e1a0000a mov r0, sl <== NOT EXECUTED
765c: e3a01001 mov r1, #1 <== NOT EXECUTED
7660: e59f24c4 ldr r2, [pc, #1220] ; 7b2c <_Heap_Walk+0x5e8> <== NOT EXECUTED
7664: e1a0e00f mov lr, pc <== NOT EXECUTED
7668: 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;
766c: e1a00006 mov r0, r6 <== NOT EXECUTED
7670: eaffffc7 b 7594 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
7674: e1a0000a mov r0, sl
7678: e3a01001 mov r1, #1
767c: e59f24ac ldr r2, [pc, #1196] ; 7b30 <_Heap_Walk+0x5ec>
7680: e1a0e00f mov lr, pc
7684: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7688: e1a00005 mov r0, r5
768c: eaffffc0 b 7594 <_Heap_Walk+0x50>
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
7690: e1a0000a mov r0, sl
7694: e3a01001 mov r1, #1
7698: e59f2494 ldr r2, [pc, #1172] ; 7b34 <_Heap_Walk+0x5f0>
769c: e1a0e00f mov lr, pc
76a0: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
76a4: e59d0024 ldr r0, [sp, #36] ; 0x24
76a8: eaffffb9 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
76ac: e1a0000a mov r0, sl
76b0: e3a01001 mov r1, #1
76b4: e59f247c ldr r2, [pc, #1148] ; 7b38 <_Heap_Walk+0x5f4>
76b8: e1a0e00f mov lr, pc
76bc: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
76c0: e3a00000 mov r0, #0
76c4: eaffffb2 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
76c8: e1a0000a mov r0, sl
76cc: e3a01001 mov r1, #1
76d0: e59f2464 ldr r2, [pc, #1124] ; 7b3c <_Heap_Walk+0x5f8>
76d4: e59d3028 ldr r3, [sp, #40] ; 0x28
76d8: e1a0e00f mov lr, pc
76dc: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
76e0: e1a00005 mov r0, r5
76e4: eaffffaa b 7594 <_Heap_Walk+0x50>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
76e8: e1a0000a mov r0, sl
76ec: e3a01001 mov r1, #1
76f0: e59f2448 ldr r2, [pc, #1096] ; 7b40 <_Heap_Walk+0x5fc>
76f4: e1a03008 mov r3, r8
76f8: e1a0e00f mov lr, pc
76fc: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7700: e1a0000b mov r0, fp
7704: eaffffa2 b 7594 <_Heap_Walk+0x50>
block = next_block;
} while ( block != first_block );
return true;
}
7708: e5945008 ldr r5, [r4, #8]
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 ) {
770c: e1540005 cmp r4, r5
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
7710: e5947010 ldr r7, [r4, #16]
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 ) {
7714: 05943020 ldreq r3, [r4, #32]
7718: 0a00000d beq 7754 <_Heap_Walk+0x210>
block = next_block;
} while ( block != first_block );
return true;
}
771c: e5943020 ldr r3, [r4, #32]
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;
7720: e1530005 cmp r3, r5
7724: 9a000097 bls 7988 <_Heap_Walk+0x444>
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
7728: e1a0000a mov r0, sl
772c: e3a01001 mov r1, #1
7730: e59f240c ldr r2, [pc, #1036] ; 7b44 <_Heap_Walk+0x600>
7734: e1a03005 mov r3, r5
7738: e1a0e00f mov lr, pc
773c: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7740: e3a00000 mov r0, #0
7744: eaffff92 b 7594 <_Heap_Walk+0x50>
7748: e1a03008 mov r3, r8
774c: e28d8030 add r8, sp, #48 ; 0x30
7750: e8980900 ldm r8, {r8, fp}
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
7754: e1a06008 mov r6, r8
- 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;
7758: e3cb7001 bic r7, fp, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
775c: e0875006 add r5, r7, 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;
7760: e1530005 cmp r3, r5
7764: 9a000008 bls 778c <_Heap_Walk+0x248>
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)(
7768: e1a0000a mov r0, sl
776c: e58d5000 str r5, [sp]
7770: e3a01001 mov r1, #1
7774: e59f23cc ldr r2, [pc, #972] ; 7b48 <_Heap_Walk+0x604>
7778: e1a03006 mov r3, r6
777c: e1a0e00f mov lr, pc
7780: e12fff19 bx r9
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
7784: e3a00000 mov r0, #0
7788: eaffff81 b 7594 <_Heap_Walk+0x50>
778c: e5943024 ldr r3, [r4, #36] ; 0x24
7790: e1530005 cmp r3, r5
7794: 3afffff3 bcc 7768 <_Heap_Walk+0x224>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7798: e59d1024 ldr r1, [sp, #36] ; 0x24
779c: e1a00007 mov r0, r7
77a0: ebffe4fe bl ba0 <__umodsi3>
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;
77a4: e59d102c ldr r1, [sp, #44] ; 0x2c
77a8: e0563001 subs r3, r6, r1
77ac: 13a03001 movne r3, #1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
77b0: e3500000 cmp r0, #0
77b4: 0a000001 beq 77c0 <_Heap_Walk+0x27c>
77b8: e3530000 cmp r3, #0
77bc: 1a0000aa bne 7a6c <_Heap_Walk+0x528>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
77c0: e59d2028 ldr r2, [sp, #40] ; 0x28
77c4: e1520007 cmp r2, r7
77c8: 9a000001 bls 77d4 <_Heap_Walk+0x290>
77cc: e3530000 cmp r3, #0
77d0: 1a0000ae bne 7a90 <_Heap_Walk+0x54c>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
77d4: e1560005 cmp r6, r5
77d8: 3a000001 bcc 77e4 <_Heap_Walk+0x2a0>
77dc: e3530000 cmp r3, #0
77e0: 1a0000b4 bne 7ab8 <_Heap_Walk+0x574>
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;
77e4: e5953004 ldr r3, [r5, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
77e8: e3130001 tst r3, #1
77ec: e20bb001 and fp, fp, #1
77f0: 0a000018 beq 7858 <_Heap_Walk+0x314>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
77f4: e35b0000 cmp fp, #0
77f8: 0a00000c beq 7830 <_Heap_Walk+0x2ec>
(*printer)(
77fc: e58d7000 str r7, [sp]
7800: e1a0000a mov r0, sl
7804: e3a01000 mov r1, #0
7808: e59f233c ldr r2, [pc, #828] ; 7b4c <_Heap_Walk+0x608>
780c: e1a03006 mov r3, r6
7810: e1a0e00f mov lr, pc
7814: e12fff19 bx r9
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
7818: e1580005 cmp r8, r5
781c: 0affff5b beq 7590 <_Heap_Walk+0x4c>
7820: e595b004 ldr fp, [r5, #4]
7824: e5943020 ldr r3, [r4, #32]
7828: e1a06005 mov r6, r5
782c: eaffffc9 b 7758 <_Heap_Walk+0x214>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
7830: e58d7000 str r7, [sp]
7834: e5963000 ldr r3, [r6]
7838: e1a0000a mov r0, sl
783c: e58d3004 str r3, [sp, #4]
7840: e1a0100b mov r1, fp
7844: e59f2304 ldr r2, [pc, #772] ; 7b50 <_Heap_Walk+0x60c>
7848: e1a03006 mov r3, r6
784c: e1a0e00f mov lr, pc
7850: e12fff19 bx r9
7854: eaffffef b 7818 <_Heap_Walk+0x2d4>
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 ?
7858: e596200c ldr r2, [r6, #12]
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)(
785c: e5943008 ldr r3, [r4, #8]
7860: e1530002 cmp r3, r2
block = next_block;
} while ( block != first_block );
return true;
}
7864: e594100c ldr r1, [r4, #12]
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)(
7868: 059f02e4 ldreq r0, [pc, #740] ; 7b54 <_Heap_Walk+0x610>
786c: 0a000003 beq 7880 <_Heap_Walk+0x33c>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
7870: e59f32e0 ldr r3, [pc, #736] ; 7b58 <_Heap_Walk+0x614>
7874: e1540002 cmp r4, r2
7878: e59f02dc ldr r0, [pc, #732] ; 7b5c <_Heap_Walk+0x618>
787c: 01a00003 moveq r0, r3
block->next,
block->next == last_free_block ?
7880: e5963008 ldr r3, [r6, #8]
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)(
7884: e1510003 cmp r1, r3
7888: 059f12d0 ldreq r1, [pc, #720] ; 7b60 <_Heap_Walk+0x61c>
788c: 0a000003 beq 78a0 <_Heap_Walk+0x35c>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
7890: e59fc2cc ldr ip, [pc, #716] ; 7b64 <_Heap_Walk+0x620>
7894: e1540003 cmp r4, r3
7898: e59f12bc ldr r1, [pc, #700] ; 7b5c <_Heap_Walk+0x618>
789c: 01a0100c moveq r1, ip
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)(
78a0: e58d2004 str r2, [sp, #4]
78a4: e58d0008 str r0, [sp, #8]
78a8: e58d300c str r3, [sp, #12]
78ac: e58d1010 str r1, [sp, #16]
78b0: e1a03006 mov r3, r6
78b4: e58d7000 str r7, [sp]
78b8: e1a0000a mov r0, sl
78bc: e3a01000 mov r1, #0
78c0: e59f22a0 ldr r2, [pc, #672] ; 7b68 <_Heap_Walk+0x624>
78c4: e1a0e00f mov lr, pc
78c8: e12fff19 bx r9
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
78cc: e5953000 ldr r3, [r5]
78d0: e1570003 cmp r7, r3
78d4: 1a000011 bne 7920 <_Heap_Walk+0x3dc>
);
return false;
}
if ( !prev_used ) {
78d8: e35b0000 cmp fp, #0
78dc: 0a00001a beq 794c <_Heap_Walk+0x408>
block = next_block;
} while ( block != first_block );
return true;
}
78e0: e5943008 ldr r3, [r4, #8]
)
{
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 ) {
78e4: e1540003 cmp r4, r3
78e8: 0a000004 beq 7900 <_Heap_Walk+0x3bc>
if ( free_block == block ) {
78ec: e1560003 cmp r6, r3
78f0: 0affffc8 beq 7818 <_Heap_Walk+0x2d4>
return true;
}
free_block = free_block->next;
78f4: e5933008 ldr r3, [r3, #8]
)
{
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 ) {
78f8: e1540003 cmp r4, r3
78fc: 1afffffa bne 78ec <_Heap_Walk+0x3a8>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
7900: e1a0000a mov r0, sl
7904: e3a01001 mov r1, #1
7908: e59f225c ldr r2, [pc, #604] ; 7b6c <_Heap_Walk+0x628>
790c: e1a03006 mov r3, r6
7910: e1a0e00f mov lr, pc
7914: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
7918: e3a00000 mov r0, #0
791c: eaffff1c b 7594 <_Heap_Walk+0x50>
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
7920: e58d3004 str r3, [sp, #4]
7924: e1a0000a mov r0, sl
7928: e58d7000 str r7, [sp]
792c: e58d5008 str r5, [sp, #8]
7930: e3a01001 mov r1, #1
7934: e59f2234 ldr r2, [pc, #564] ; 7b70 <_Heap_Walk+0x62c>
7938: e1a03006 mov r3, r6
793c: e1a0e00f mov lr, pc
7940: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
7944: e3a00000 mov r0, #0
7948: eaffff11 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( !prev_used ) {
(*printer)(
794c: e1a0000a mov r0, sl
7950: e3a01001 mov r1, #1
7954: e59f2218 ldr r2, [pc, #536] ; 7b74 <_Heap_Walk+0x630>
7958: e1a03006 mov r3, r6
795c: e1a0e00f mov lr, pc
7960: e12fff19 bx r9
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
7964: e1a0000b mov r0, fp
7968: eaffff09 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
796c: e1a0000a mov r0, sl
7970: e3a01001 mov r1, #1
7974: e59f21fc ldr r2, [pc, #508] ; 7b78 <_Heap_Walk+0x634>
7978: e1a0e00f mov lr, pc
797c: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7980: e1a00005 mov r0, r5
7984: eaffff02 b 7594 <_Heap_Walk+0x50>
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;
7988: e594c024 ldr ip, [r4, #36] ; 0x24
798c: e15c0005 cmp ip, r5
7990: 3affff64 bcc 7728 <_Heap_Walk+0x1e4>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7994: e2850008 add r0, r5, #8
7998: e1a01007 mov r1, r7
799c: e58d3020 str r3, [sp, #32]
79a0: e58dc01c str ip, [sp, #28]
79a4: ebffe47d bl ba0 <__umodsi3>
);
return false;
}
if (
79a8: e3500000 cmp r0, #0
79ac: e59d3020 ldr r3, [sp, #32]
79b0: e59dc01c ldr ip, [sp, #28]
79b4: 1a000048 bne 7adc <_Heap_Walk+0x598>
- 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;
79b8: e5952004 ldr r2, [r5, #4]
79bc: e3c22001 bic r2, r2, #1
block = next_block;
} while ( block != first_block );
return true;
}
79c0: e0852002 add r2, r5, r2
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;
79c4: e5922004 ldr r2, [r2, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
79c8: e3120001 tst r2, #1
79cc: 1a00004a bne 7afc <_Heap_Walk+0x5b8>
79d0: e58d8030 str r8, [sp, #48] ; 0x30
79d4: e58db034 str fp, [sp, #52] ; 0x34
79d8: e1a01004 mov r1, r4
79dc: e1a06005 mov r6, r5
79e0: e1a08003 mov r8, r3
79e4: e1a0b00c mov fp, ip
79e8: ea000013 b 7a3c <_Heap_Walk+0x4f8>
return false;
}
prev_block = free_block;
free_block = free_block->next;
79ec: e5955008 ldr r5, [r5, #8]
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 ) {
79f0: e1540005 cmp r4, r5
79f4: 0affff53 beq 7748 <_Heap_Walk+0x204>
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;
79f8: e1580005 cmp r8, r5
79fc: 8affff49 bhi 7728 <_Heap_Walk+0x1e4>
7a00: e155000b cmp r5, fp
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7a04: e2850008 add r0, r5, #8
7a08: e1a01007 mov r1, r7
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;
7a0c: 8affff45 bhi 7728 <_Heap_Walk+0x1e4>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
7a10: ebffe462 bl ba0 <__umodsi3>
);
return false;
}
if (
7a14: e3500000 cmp r0, #0
7a18: 1a00002f bne 7adc <_Heap_Walk+0x598>
- 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;
7a1c: e5953004 ldr r3, [r5, #4]
7a20: e3c33001 bic r3, r3, #1
block = next_block;
} while ( block != first_block );
return true;
}
7a24: e0833005 add r3, r3, r5
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;
7a28: e5933004 ldr r3, [r3, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
7a2c: e3130001 tst r3, #1
7a30: 1a000031 bne 7afc <_Heap_Walk+0x5b8>
7a34: e1a01006 mov r1, r6
7a38: e1a06005 mov r6, r5
);
return false;
}
if ( free_block->prev != prev_block ) {
7a3c: e595200c ldr r2, [r5, #12]
7a40: e1520001 cmp r2, r1
7a44: 0affffe8 beq 79ec <_Heap_Walk+0x4a8>
(*printer)(
7a48: e58d2000 str r2, [sp]
7a4c: e1a0000a mov r0, sl
7a50: e3a01001 mov r1, #1
7a54: e59f2120 ldr r2, [pc, #288] ; 7b7c <_Heap_Walk+0x638>
7a58: e1a03005 mov r3, r5
7a5c: e1a0e00f mov lr, pc
7a60: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7a64: e3a00000 mov r0, #0
7a68: eafffec9 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
7a6c: e1a0000a mov r0, sl
7a70: e58d7000 str r7, [sp]
7a74: e3a01001 mov r1, #1
7a78: e59f2100 ldr r2, [pc, #256] ; 7b80 <_Heap_Walk+0x63c>
7a7c: e1a03006 mov r3, r6
7a80: e1a0e00f mov lr, pc
7a84: e12fff19 bx r9
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
7a88: e3a00000 mov r0, #0
7a8c: eafffec0 b 7594 <_Heap_Walk+0x50>
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
7a90: e58d2004 str r2, [sp, #4]
7a94: e1a0000a mov r0, sl
7a98: e58d7000 str r7, [sp]
7a9c: e3a01001 mov r1, #1
7aa0: e59f20dc ldr r2, [pc, #220] ; 7b84 <_Heap_Walk+0x640>
7aa4: e1a03006 mov r3, r6
7aa8: e1a0e00f mov lr, pc
7aac: e12fff19 bx r9
block,
block_size,
min_block_size
);
return false;
7ab0: e3a00000 mov r0, #0
7ab4: eafffeb6 b 7594 <_Heap_Walk+0x50>
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
7ab8: e1a0000a mov r0, sl
7abc: e58d5000 str r5, [sp]
7ac0: e3a01001 mov r1, #1
7ac4: e59f20bc ldr r2, [pc, #188] ; 7b88 <_Heap_Walk+0x644>
7ac8: e1a03006 mov r3, r6
7acc: e1a0e00f mov lr, pc
7ad0: e12fff19 bx r9
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
7ad4: e3a00000 mov r0, #0
7ad8: eafffead b 7594 <_Heap_Walk+0x50>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
7adc: e1a0000a mov r0, sl
7ae0: e3a01001 mov r1, #1
7ae4: e59f20a0 ldr r2, [pc, #160] ; 7b8c <_Heap_Walk+0x648>
7ae8: e1a03005 mov r3, r5
7aec: e1a0e00f mov lr, pc
7af0: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7af4: e3a00000 mov r0, #0
7af8: eafffea5 b 7594 <_Heap_Walk+0x50>
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
7afc: e1a0000a mov r0, sl
7b00: e3a01001 mov r1, #1
7b04: e59f2084 ldr r2, [pc, #132] ; 7b90 <_Heap_Walk+0x64c>
7b08: e1a03005 mov r3, r5
7b0c: e1a0e00f mov lr, pc
7b10: e12fff19 bx r9
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
7b14: e3a00000 mov r0, #0
7b18: eafffe9d b 7594 <_Heap_Walk+0x50>
00006a20 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
6a20: 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 )
6a24: e5904034 ldr r4, [r0, #52] ; 0x34
6a28: e3540000 cmp r4, #0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
6a2c: e24dd014 sub sp, sp, #20
6a30: 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 );
6a34: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
6a38: 0a00009b beq 6cac <_Objects_Extend_information+0x28c>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
6a3c: e1d081b4 ldrh r8, [r0, #20]
6a40: e1d0a1b0 ldrh sl, [r0, #16]
6a44: e1a01008 mov r1, r8
6a48: e1a0000a mov r0, sl
6a4c: eb002993 bl 110a0 <__aeabi_uidiv>
6a50: e1a03800 lsl r3, r0, #16
for ( ; block < block_count; block++ ) {
6a54: e1b03823 lsrs r3, r3, #16
6a58: 0a000099 beq 6cc4 <_Objects_Extend_information+0x2a4>
if ( information->object_blocks[ block ] == NULL ) {
6a5c: e5949000 ldr r9, [r4]
6a60: e3590000 cmp r9, #0
6a64: 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 );
6a68: 01a06007 moveq r6, r7
index_base = minimum_index; block = 0;
6a6c: 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 ) {
6a70: 0a00000c beq 6aa8 <_Objects_Extend_information+0x88>
6a74: e1a02004 mov r2, r4
6a78: 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 );
6a7c: e1a06007 mov r6, r7
index_base = minimum_index; block = 0;
6a80: e3a04000 mov r4, #0
6a84: ea000002 b 6a94 <_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 ) {
6a88: e5b29004 ldr r9, [r2, #4]!
6a8c: e3590000 cmp r9, #0
6a90: 0a000004 beq 6aa8 <_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++ ) {
6a94: e2844001 add r4, r4, #1
6a98: e1530004 cmp r3, r4
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
6a9c: 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++ ) {
6aa0: 8afffff8 bhi 6a88 <_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;
6aa4: e3a09001 mov r9, #1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
6aa8: 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 ) {
6aac: e35a0801 cmp sl, #65536 ; 0x10000
6ab0: 2a000063 bcs 6c44 <_Objects_Extend_information+0x224>
/*
* 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 ) {
6ab4: 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;
6ab8: e5950018 ldr r0, [r5, #24]
if ( information->auto_extend ) {
6abc: 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;
6ac0: e0000091 mul r0, r1, r0
if ( information->auto_extend ) {
6ac4: 1a000060 bne 6c4c <_Objects_Extend_information+0x22c>
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
6ac8: e58d3000 str r3, [sp]
6acc: eb000838 bl 8bb4 <_Workspace_Allocate_or_fatal_error>
6ad0: e59d3000 ldr r3, [sp]
6ad4: e1a08000 mov r8, r0
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
6ad8: e3590000 cmp r9, #0
6adc: 0a000039 beq 6bc8 <_Objects_Extend_information+0x1a8>
*/
/*
* Up the block count and maximum
*/
block_count++;
6ae0: e283b001 add fp, r3, #1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
6ae4: e08b008b add r0, fp, fp, lsl #1
((maximum + minimum_index) * sizeof(Objects_Control *));
6ae8: e08a0000 add r0, sl, r0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
6aec: e0800007 add r0, r0, r7
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
6af0: e1a00100 lsl r0, r0, #2
6af4: e58d3000 str r3, [sp]
6af8: eb000823 bl 8b8c <_Workspace_Allocate>
if ( !object_blocks ) {
6afc: e2509000 subs r9, r0, #0
6b00: e59d3000 ldr r3, [sp]
6b04: 0a000073 beq 6cd8 <_Objects_Extend_information+0x2b8>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
6b08: e1d521b0 ldrh r2, [r5, #16]
6b0c: e1570002 cmp r7, r2
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
6b10: e089c10b add ip, r9, fp, lsl #2
6b14: e089b18b add fp, r9, fp, lsl #3
6b18: 3a000051 bcc 6c64 <_Objects_Extend_information+0x244>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6b1c: e3570000 cmp r7, #0
6b20: 13a02000 movne r2, #0
6b24: 11a0100b movne r1, fp
local_table[ index ] = NULL;
6b28: 11a00002 movne r0, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6b2c: 0a000003 beq 6b40 <_Objects_Extend_information+0x120>
6b30: e2822001 add r2, r2, #1
6b34: e1570002 cmp r7, r2
local_table[ index ] = NULL;
6b38: e4810004 str r0, [r1], #4
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6b3c: 8afffffb bhi 6b30 <_Objects_Extend_information+0x110>
6b40: 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 );
6b44: e1d511b4 ldrh r1, [r5, #20]
6b48: e0861001 add r1, r6, r1
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
6b4c: e3a00000 mov r0, #0
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6b50: e1560001 cmp r6, r1
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
6b54: e7890003 str r0, [r9, r3]
inactive_per_block[block_count] = 0;
6b58: e78c0003 str r0, [ip, r3]
for ( index=index_base ;
6b5c: 2a000005 bcs 6b78 <_Objects_Extend_information+0x158>
6b60: e08b2106 add r2, fp, r6, lsl #2
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
6b64: 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++ ) {
6b68: 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 ;
6b6c: e1530001 cmp r3, r1
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
6b70: 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 ;
6b74: 3afffffb bcc 6b68 <_Objects_Extend_information+0x148>
6b78: e10f3000 mrs r3, CPSR
6b7c: e3832080 orr r2, r3, #128 ; 0x80
6b80: e129f002 msr CPSR_fc, r2
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
6b84: 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(
6b88: e1d510b4 ldrh r1, [r5, #4]
6b8c: 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;
6b90: e1a0a80a lsl sl, sl, #16
6b94: e3822801 orr r2, r2, #65536 ; 0x10000
6b98: e1a0a82a lsr sl, sl, #16
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
6b9c: 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) |
6ba0: e182200a orr r2, r2, sl
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
6ba4: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
6ba8: e585c030 str ip, [r5, #48] ; 0x30
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
6bac: e5859034 str r9, [r5, #52] ; 0x34
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
6bb0: e585b01c str fp, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
6bb4: e1c5a1b0 strh sl, [r5, #16]
information->maximum_id = _Objects_Build_id(
6bb8: e585200c str r2, [r5, #12]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
6bbc: e129f003 msr CPSR_fc, r3
information->maximum
);
_ISR_Enable( level );
if ( old_tables )
6bc0: e3500000 cmp r0, #0
_Workspace_Free( old_tables );
6bc4: 1b0007f6 blne 8ba4 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6bc8: e5953034 ldr r3, [r5, #52] ; 0x34
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
6bcc: e28d7008 add r7, sp, #8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6bd0: e7838104 str r8, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
6bd4: e1a01008 mov r1, r8
6bd8: e1a00007 mov r0, r7
6bdc: e1d521b4 ldrh r2, [r5, #20]
6be0: e5953018 ldr r3, [r5, #24]
6be4: eb001220 bl b46c <_Chain_Initialize>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6be8: e1a04104 lsl r4, r4, #2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
6bec: 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 ) {
6bf0: ea000009 b 6c1c <_Objects_Extend_information+0x1fc>
6bf4: e5953000 ldr r3, [r5]
the_object->id = _Objects_Build_id(
6bf8: e1d520b4 ldrh r2, [r5, #4]
6bfc: e1a03c03 lsl r3, r3, #24
6c00: e3833801 orr r3, r3, #65536 ; 0x10000
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
6c04: 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) |
6c08: e1833006 orr r3, r3, r6
6c0c: e5813008 str r3, [r1, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
6c10: e1a00008 mov r0, r8
6c14: ebfffce6 bl 5fb4 <_Chain_Append>
index++;
6c18: 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 ) {
6c1c: e1a00007 mov r0, r7
6c20: ebfffcf6 bl 6000 <_Chain_Get>
6c24: e2501000 subs r1, r0, #0
6c28: 1afffff1 bne 6bf4 <_Objects_Extend_information+0x1d4>
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
6c2c: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
6c30: e1d531b4 ldrh r3, [r5, #20]
6c34: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
6c38: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
6c3c: e7813004 str r3, [r1, r4]
information->inactive =
6c40: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
6c44: e28dd014 add sp, sp, #20
6c48: 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 );
6c4c: e58d3000 str r3, [sp]
6c50: eb0007cd bl 8b8c <_Workspace_Allocate>
if ( !new_object_block )
6c54: e2508000 subs r8, r0, #0
6c58: e59d3000 ldr r3, [sp]
6c5c: 1affff9d bne 6ad8 <_Objects_Extend_information+0xb8>
6c60: eafffff7 b 6c44 <_Objects_Extend_information+0x224>
/*
* 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,
6c64: e1a03103 lsl r3, r3, #2
6c68: e5951034 ldr r1, [r5, #52] ; 0x34
6c6c: e1a02003 mov r2, r3
6c70: e88d1008 stm sp, {r3, ip}
6c74: eb001d98 bl e2dc <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
6c78: e89d1008 ldm sp, {r3, ip}
6c7c: e1a0000c mov r0, ip
6c80: e1a02003 mov r2, r3
6c84: e5951030 ldr r1, [r5, #48] ; 0x30
6c88: eb001d93 bl e2dc <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
6c8c: e1d521b0 ldrh r2, [r5, #16]
6c90: 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,
6c94: e1a0000b mov r0, fp
6c98: e595101c ldr r1, [r5, #28]
6c9c: e1a02102 lsl r2, r2, #2
6ca0: eb001d8d bl e2dc <memcpy>
6ca4: e89d1008 ldm sp, {r3, ip}
6ca8: eaffffa5 b 6b44 <_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 )
6cac: e1d0a1b0 ldrh sl, [r0, #16]
6cb0: 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 );
6cb4: 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;
6cb8: e3a09001 mov r9, #1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
6cbc: e1a03004 mov r3, r4
6cc0: eaffff78 b 6aa8 <_Objects_Extend_information+0x88>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
6cc4: 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 );
6cc8: 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;
6ccc: e3a09001 mov r9, #1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
6cd0: e1a04003 mov r4, r3 <== NOT EXECUTED
6cd4: eaffff73 b 6aa8 <_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 );
6cd8: e1a00008 mov r0, r8
6cdc: eb0007b0 bl 8ba4 <_Workspace_Free>
return;
6ce0: eaffffd7 b 6c44 <_Objects_Extend_information+0x224>
00007050 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
7050: 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 );
7054: e1d040b8 ldrh r4, [r0, #8]
block_count = (information->maximum - index_base) /
7058: e1d051b4 ldrh r5, [r0, #20]
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
705c: 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) /
7060: e1d001b0 ldrh r0, [r0, #16]
7064: e1a01005 mov r1, r5
7068: e0640000 rsb r0, r4, r0
706c: eb00280b bl 110a0 <__aeabi_uidiv>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
7070: e3500000 cmp r0, #0
7074: 08bd80f0 popeq {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
7078: e5962030 ldr r2, [r6, #48] ; 0x30
707c: e5923000 ldr r3, [r2]
7080: 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++ ) {
7084: 13a03000 movne r3, #0
if ( information->inactive_per_block[ block ] ==
7088: 1a000005 bne 70a4 <_Objects_Shrink_information+0x54>
708c: ea000008 b 70b4 <_Objects_Shrink_information+0x64> <== NOT EXECUTED
7090: e5b21004 ldr r1, [r2, #4]!
7094: e1550001 cmp r5, r1
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
7098: e0844005 add r4, r4, r5
709c: 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 ] ==
70a0: 0a000004 beq 70b8 <_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++ ) {
70a4: e2833001 add r3, r3, #1
70a8: e1500003 cmp r0, r3
70ac: 8afffff7 bhi 7090 <_Objects_Shrink_information+0x40>
70b0: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
70b4: e3a07000 mov r7, #0 <== NOT EXECUTED
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) information->Inactive.first;
70b8: e5960020 ldr r0, [r6, #32]
70bc: ea000002 b 70cc <_Objects_Shrink_information+0x7c>
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
70c0: e3550000 cmp r5, #0
70c4: 0a00000b beq 70f8 <_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;
70c8: e1a00005 mov r0, r5
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) information->Inactive.first;
do {
index = _Objects_Get_index( the_object->id );
70cc: e1d030b8 ldrh r3, [r0, #8]
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
70d0: e1530004 cmp r3, r4
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
70d4: e5905000 ldr r5, [r0]
if ((index >= index_base) &&
70d8: 3afffff8 bcc 70c0 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
70dc: e1d621b4 ldrh r2, [r6, #20]
70e0: 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) &&
70e4: e1530002 cmp r3, r2
70e8: 2afffff4 bcs 70c0 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
70ec: ebfffbbb bl 5fe0 <_Chain_Extract>
}
}
while ( the_object );
70f0: e3550000 cmp r5, #0
70f4: 1afffff3 bne 70c8 <_Objects_Shrink_information+0x78>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
70f8: e5963034 ldr r3, [r6, #52] ; 0x34
70fc: e7930007 ldr r0, [r3, r7]
7100: eb0006a7 bl 8ba4 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
7104: e1d602bc ldrh r0, [r6, #44] ; 0x2c
7108: 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;
710c: e5961034 ldr r1, [r6, #52] ; 0x34
information->inactive_per_block[ block ] = 0;
7110: e5962030 ldr r2, [r6, #48] ; 0x30
information->inactive -= information->allocation_size;
7114: 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;
7118: e7815007 str r5, [r1, r7]
information->inactive_per_block[ block ] = 0;
711c: e7825007 str r5, [r2, r7]
information->inactive -= information->allocation_size;
7120: e1c632bc strh r3, [r6, #44] ; 0x2c
return;
7124: e8bd80f0 pop {r4, r5, r6, r7, pc}
0000d9a0 <_POSIX_signals_Clear_process_signals>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
d9a0: e10f2000 mrs r2, CPSR
d9a4: e3823080 orr r3, r2, #128 ; 0x80
d9a8: e129f003 msr CPSR_fc, r3
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
d9ac: e59f1050 ldr r1, [pc, #80] ; da04 <_POSIX_signals_Clear_process_signals+0x64>
d9b0: e0803080 add r3, r0, r0, lsl #1
d9b4: e7911103 ldr r1, [r1, r3, lsl #2]
d9b8: e3510002 cmp r1, #2
d9bc: e1a01103 lsl r1, r3, #2
d9c0: 0a000007 beq d9e4 <_POSIX_signals_Clear_process_signals+0x44>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
d9c4: e59f303c ldr r3, [pc, #60] ; da08 <_POSIX_signals_Clear_process_signals+0x68>
d9c8: e5931000 ldr r1, [r3]
d9cc: e3a0c001 mov ip, #1
d9d0: e2400001 sub r0, r0, #1
d9d4: e1c1001c bic r0, r1, ip, lsl r0
d9d8: e5830000 str r0, [r3]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
d9dc: e129f002 msr CPSR_fc, r2
}
_ISR_Enable( level );
}
d9e0: e12fff1e bx lr
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
d9e4: e59fc020 ldr ip, [pc, #32] ; da0c <_POSIX_signals_Clear_process_signals+0x6c>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
d9e8: e2811004 add r1, r1, #4
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
d9ec: e79c3103 ldr r3, [ip, r3, lsl #2]
d9f0: e081c00c add ip, r1, ip
d9f4: e153000c cmp r3, ip
d9f8: 0afffff1 beq d9c4 <_POSIX_signals_Clear_process_signals+0x24>
d9fc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
}
da00: e12fff1e bx lr <== NOT EXECUTED
00021e84 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
21e84: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
21e88: e5905010 ldr r5, [r0, #16] 21e8c: e3c534ef bic r3, r5, #-285212672 ; 0xef000000 21e90: e3c338ff bic r3, r3, #16711680 ; 0xff0000 21e94: e3c33c7f bic r3, r3, #32512 ; 0x7f00 21e98: e3a0c201 mov ip, #268435456 ; 0x10000000 21e9c: e3c330ff bic r3, r3, #255 ; 0xff 21ea0: e28cc902 add ip, ip, #32768 ; 0x8000 21ea4: e2417001 sub r7, r1, #1 21ea8: e3a06001 mov r6, #1 21eac: e153000c cmp r3, ip
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
21eb0: e1a04000 mov r4, r0
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
21eb4: e5903108 ldr r3, [r0, #264] ; 0x108 21eb8: e1a07716 lsl r7, r6, r7
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
21ebc: 0a00001b beq 21f30 <_POSIX_signals_Unblock_thread+0xac>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
21ec0: e59330d0 ldr r3, [r3, #208] ; 0xd0 21ec4: e1d77003 bics r7, r7, r3
21ec8: 0a000016 beq 21f28 <_POSIX_signals_Unblock_thread+0xa4>
* 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 ) ) {
21ecc: e2157201 ands r7, r5, #268435456 ; 0x10000000
21ed0: 0a000012 beq 21f20 <_POSIX_signals_Unblock_thread+0x9c>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
21ed4: e3c564ff bic r6, r5, #-16777216 ; 0xff000000 21ed8: e3c6673f bic r6, r6, #16515072 ; 0xfc0000 21edc: e3c66c41 bic r6, r6, #16640 ; 0x4100 21ee0: e3c6601f bic r6, r6, #31
the_thread->Wait.return_code = EINTR;
21ee4: e3a03004 mov r3, #4
/*
* 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) )
21ee8: e3560000 cmp r6, #0
* 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;
21eec: e5803034 str r3, [r0, #52] ; 0x34
/*
* 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) )
21ef0: 1a00002e bne 21fb0 <_POSIX_signals_Unblock_thread+0x12c>
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
21ef4: e2150008 ands r0, r5, #8
21ef8: 08bd80f0 popeq {r4, r5, r6, r7, pc}
(void) _Watchdog_Remove( &the_thread->Timer );
21efc: e2840048 add r0, r4, #72 ; 0x48 21f00: ebffb040 bl e008 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
21f04: e3a01201 mov r1, #268435456 ; 0x10000000 21f08: e2811bff add r1, r1, #261120 ; 0x3fc00 21f0c: e1a00004 mov r0, r4 21f10: e2811ffe add r1, r1, #1016 ; 0x3f8 21f14: ebffaaa8 bl c9bc <_Thread_Clear_state>
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
21f18: e1a00006 mov r0, r6
21f1c: e8bd80f0 pop {r4, r5, r6, r7, pc}
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 ) {
21f20: e3550000 cmp r5, #0
21f24: 0a000016 beq 21f84 <_POSIX_signals_Unblock_thread+0x100>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
21f28: e1a00007 mov r0, r7
21f2c: e8bd80f0 pop {r4, r5, r6, r7, pc}
* 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) ) {
21f30: e5900030 ldr r0, [r0, #48] ; 0x30 21f34: e1170000 tst r7, r0
21f38: 0a00000d beq 21f74 <_POSIX_signals_Unblock_thread+0xf0>
the_thread->Wait.return_code = EINTR;
21f3c: e3a03004 mov r3, #4
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
21f40: e3520000 cmp r2, #0
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
the_thread->Wait.return_code = EINTR;
21f44: e5843034 str r3, [r4, #52] ; 0x34
the_info = (siginfo_t *) the_thread->Wait.return_argument;
21f48: e5943028 ldr r3, [r4, #40] ; 0x28
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
21f4c: 18920007 ldmne r2, {r0, r1, r2}
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
21f50: 05831000 streq r1, [r3]
the_info->si_code = SI_USER;
21f54: 03a01001 moveq r1, #1
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
21f58: 18830007 stmne r3, {r0, r1, r2}
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
the_info->si_code = SI_USER;
21f5c: 05831004 streq r1, [r3, #4]
the_info->si_value.sival_int = 0;
21f60: 05832008 streq r2, [r3, #8]
} else {
*the_info = *info;
}
_Thread_queue_Extract_with_proxy( the_thread );
21f64: e1a00004 mov r0, r4 21f68: ebffad5b bl d4dc <_Thread_queue_Extract_with_proxy>
return true;
21f6c: e3a00001 mov r0, #1
21f70: e8bd80f0 pop {r4, r5, r6, r7, pc}
* 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) ) {
21f74: e59300d0 ldr r0, [r3, #208] ; 0xd0 21f78: e1d70000 bics r0, r7, r0
21f7c: 1affffee bne 21f3c <_POSIX_signals_Unblock_thread+0xb8>
21f80: e8bd80f0 pop {r4, r5, r6, r7, pc}
(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 ) )
21f84: e59f2030 ldr r2, [pc, #48] ; 21fbc <_POSIX_signals_Unblock_thread+0x138>
21f88: e5920000 ldr r0, [r2]
21f8c: e3500000 cmp r0, #0
21f90: 08bd80f0 popeq {r4, r5, r6, r7, pc}
21f94: e5923004 ldr r3, [r2, #4]
21f98: e1540003 cmp r4, r3
_Thread_Dispatch_necessary = true;
21f9c: 05c26010 strbeq r6, [r2, #16]
}
}
return false;
21fa0: 01a00005 moveq r0, r5
(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 ) )
21fa4: 08bd80f0 popeq {r4, r5, r6, r7, pc}
_Thread_Dispatch_necessary = true;
}
}
return false;
21fa8: e1a00005 mov r0, r5 <== NOT EXECUTED
}
21fac: 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 );
21fb0: ebffad49 bl d4dc <_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;
21fb4: e3a00000 mov r0, #0 <== NOT EXECUTED
21fb8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00006640 <_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();
6640: e59f30b8 ldr r3, [pc, #184] ; 6700 <_TOD_Validate+0xc0>
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
6644: 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) ||
6648: 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();
664c: 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;
6650: 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) ||
6654: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
6658: e3a0093d mov r0, #999424 ; 0xf4000
665c: e2800d09 add r0, r0, #576 ; 0x240
6660: eb0048d4 bl 189b8 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
6664: e5943018 ldr r3, [r4, #24]
6668: e1500003 cmp r0, r3
666c: 9a00001f bls 66f0 <_TOD_Validate+0xb0>
(the_tod->ticks >= ticks_per_second) ||
6670: e5943014 ldr r3, [r4, #20]
6674: e353003b cmp r3, #59 ; 0x3b
6678: 8a00001c bhi 66f0 <_TOD_Validate+0xb0>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
667c: e5943010 ldr r3, [r4, #16]
6680: e353003b cmp r3, #59 ; 0x3b
6684: 8a000019 bhi 66f0 <_TOD_Validate+0xb0>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
6688: e594300c ldr r3, [r4, #12]
668c: e3530017 cmp r3, #23
6690: 8a000016 bhi 66f0 <_TOD_Validate+0xb0>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
6694: 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) ||
6698: e3500000 cmp r0, #0
669c: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
66a0: e350000c cmp r0, #12
66a4: 8a000011 bhi 66f0 <_TOD_Validate+0xb0>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
66a8: e5942000 ldr r2, [r4]
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
66ac: e3a03d1f mov r3, #1984 ; 0x7c0
66b0: e2833003 add r3, r3, #3
66b4: e1520003 cmp r2, r3
66b8: 9a00000c bls 66f0 <_TOD_Validate+0xb0>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
66bc: 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) ||
66c0: e3540000 cmp r4, #0
66c4: 0a00000b beq 66f8 <_TOD_Validate+0xb8>
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
66c8: e3120003 tst r2, #3
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
66cc: 059f3030 ldreq r3, [pc, #48] ; 6704 <_TOD_Validate+0xc4>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
66d0: 159f302c ldrne r3, [pc, #44] ; 6704 <_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 ];
66d4: 0280000d addeq r0, r0, #13
66d8: 07930100 ldreq r0, [r3, r0, lsl #2]
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
66dc: 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(
66e0: e1500004 cmp r0, r4
66e4: 33a00000 movcc r0, #0
66e8: 23a00001 movcs r0, #1
66ec: 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;
66f0: e3a00000 mov r0, #0
66f4: e8bd8010 pop {r4, pc}
66f8: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
66fc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00007cf8 <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
7cf8: 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
)
{
7cfc: e92d0ff0 push {r4, r5, r6, r7, r8, r9, sl, fp}
7d00: e281403c add r4, r1, #60 ; 0x3c
Chain_Node *previous_node;
Chain_Node *search_node;
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
7d04: e281c038 add ip, r1, #56 ; 0x38
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
7d08: 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 ) )
7d0c: e3130020 tst r3, #32
the_chain->permanent_null = NULL;
7d10: e3a04000 mov r4, #0
7d14: e581403c str r4, [r1, #60] ; 0x3c
the_chain->last = _Chain_Head(the_chain);
7d18: 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);
7d1c: e1a08323 lsr r8, 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;
7d20: e5905038 ldr r5, [r0, #56] ; 0x38
if ( _Thread_queue_Is_reverse_search( priority ) )
7d24: 1a00001f bne 7da8 <_Thread_queue_Enqueue_priority+0xb0>
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
7d28: e0888088 add r8, r8, r8, lsl #1
7d2c: e1a09108 lsl r9, r8, #2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
7d30: e2898004 add r8, r9, #4
7d34: e0808008 add r8, r0, r8
7d38: e0809009 add r9, r0, r9
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
7d3c: e10f7000 mrs r7, CPSR
7d40: e387c080 orr ip, r7, #128 ; 0x80
7d44: e129f00c msr CPSR_fc, ip
7d48: e1a0a007 mov sl, r7
7d4c: e599c000 ldr ip, [r9]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
7d50: e15c0008 cmp ip, r8
7d54: 1a000009 bne 7d80 <_Thread_queue_Enqueue_priority+0x88>
7d58: ea000054 b 7eb0 <_Thread_queue_Enqueue_priority+0x1b8>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
7d5c: e10f6000 mrs r6, CPSR
7d60: e129f007 msr CPSR_fc, r7
7d64: 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);
7d68: 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) ) {
7d6c: e1150006 tst r5, r6
7d70: 0a000036 beq 7e50 <_Thread_queue_Enqueue_priority+0x158>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
7d74: e59cc000 ldr ip, [ip]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
7d78: e15c0008 cmp ip, r8
7d7c: 0a000002 beq 7d8c <_Thread_queue_Enqueue_priority+0x94>
search_priority = search_thread->current_priority;
7d80: e59c4014 ldr r4, [ip, #20]
if ( priority <= search_priority )
7d84: e1530004 cmp r3, r4
7d88: 8afffff3 bhi 7d5c <_Thread_queue_Enqueue_priority+0x64>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
7d8c: e5905030 ldr r5, [r0, #48] ; 0x30
7d90: e3550001 cmp r5, #1
7d94: 0a00002f beq 7e58 <_Thread_queue_Enqueue_priority+0x160>
* 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;
7d98: e582a000 str sl, [r2]
return the_thread_queue->sync_state; }
7d9c: e1a00005 mov r0, r5
7da0: e8bd0ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp}
7da4: e12fff1e bx lr
_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 ];
7da8: e0888088 add r8, r8, r8, lsl #1
7dac: e0808108 add r8, r0, r8, lsl #2
7db0: e59f9100 ldr r9, [pc, #256] ; 7eb8 <_Thread_queue_Enqueue_priority+0x1c0>
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
7db4: e1a0b008 mov fp, r8
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
7db8: e5d94000 ldrb r4, [r9]
7dbc: e2844001 add r4, r4, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
7dc0: e10f7000 mrs r7, CPSR
7dc4: e387c080 orr ip, r7, #128 ; 0x80
7dc8: e129f00c msr CPSR_fc, ip
7dcc: e1a0a007 mov sl, r7
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
7dd0: e59bc008 ldr ip, [fp, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
7dd4: e15c0008 cmp ip, r8
7dd8: 1a000009 bne 7e04 <_Thread_queue_Enqueue_priority+0x10c>
7ddc: ea00000b b 7e10 <_Thread_queue_Enqueue_priority+0x118>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
7de0: e10f6000 mrs r6, CPSR
7de4: e129f007 msr CPSR_fc, r7
7de8: e129f006 msr CPSR_fc, r6
7dec: 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) ) {
7df0: e1150006 tst r5, r6
7df4: 0a000013 beq 7e48 <_Thread_queue_Enqueue_priority+0x150>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
7df8: e59cc004 ldr ip, [ip, #4]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
7dfc: e15c0008 cmp ip, r8
7e00: 0a000002 beq 7e10 <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
7e04: e59c4014 ldr r4, [ip, #20]
if ( priority >= search_priority )
7e08: e1530004 cmp r3, r4
7e0c: 3afffff3 bcc 7de0 <_Thread_queue_Enqueue_priority+0xe8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
7e10: e5905030 ldr r5, [r0, #48] ; 0x30
7e14: e3550001 cmp r5, #1
7e18: 1affffde bne 7d98 <_Thread_queue_Enqueue_priority+0xa0>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
7e1c: 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;
7e20: e3a03000 mov r3, #0
7e24: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
7e28: 0a000016 beq 7e88 <_Thread_queue_Enqueue_priority+0x190>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
7e2c: e59c3000 ldr r3, [ip]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
7e30: e8811008 stm r1, {r3, ip}
search_node->next = the_node; next_node->previous = the_node;
7e34: 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;
7e38: e58c1000 str r1, [ip]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
7e3c: e5810044 str r0, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
7e40: e129f007 msr CPSR_fc, r7
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
7e44: eaffffd4 b 7d9c <_Thread_queue_Enqueue_priority+0xa4>
7e48: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
7e4c: eaffffd9 b 7db8 <_Thread_queue_Enqueue_priority+0xc0> <== NOT EXECUTED
7e50: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
7e54: eaffffb8 b 7d3c <_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 )
7e58: 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;
7e5c: e3a03000 mov r3, #0
7e60: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
7e64: 0a000007 beq 7e88 <_Thread_queue_Enqueue_priority+0x190>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
7e68: e59c3004 ldr r3, [ip, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
7e6c: e581c000 str ip, [r1]
the_node->previous = previous_node;
7e70: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
7e74: e5831000 str r1, [r3]
search_node->previous = the_node;
7e78: e58c1004 str r1, [ip, #4]
the_thread->Wait.queue = the_thread_queue;
7e7c: e5810044 str r0, [r1, #68] ; 0x44
7e80: e129f007 msr CPSR_fc, r7
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
7e84: eaffffc4 b 7d9c <_Thread_queue_Enqueue_priority+0xa4>
7e88: e28cc03c add ip, ip, #60 ; 0x3c
_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;
7e8c: e59c3004 ldr r3, [ip, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
7e90: e581c000 str ip, [r1]
the_node->previous = previous_node;
7e94: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
7e98: e5831000 str r1, [r3]
search_node->previous = the_node;
7e9c: e58c1004 str r1, [ip, #4]
the_thread->Wait.queue = the_thread_queue;
7ea0: e5810044 str r0, [r1, #68] ; 0x44
7ea4: e129f00a msr CPSR_fc, sl
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
7ea8: e3a05001 mov r5, #1
7eac: eaffffba b 7d9c <_Thread_queue_Enqueue_priority+0xa4>
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
7eb0: e3e04000 mvn r4, #0
7eb4: eaffffb4 b 7d8c <_Thread_queue_Enqueue_priority+0x94>
00015ec4 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
15ec4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
15ec8: e24dd024 sub sp, sp, #36 ; 0x24
15ecc: e28d700c add r7, sp, #12
15ed0: e28d2018 add r2, sp, #24
15ed4: e282a004 add sl, r2, #4
15ed8: e2872004 add r2, r7, #4
15edc: e58d2000 str r2, [sp]
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
15ee0: e28d2018 add r2, sp, #24 15ee4: e58d2020 str r2, [sp, #32]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
15ee8: e59d2000 ldr r2, [sp] 15eec: e58d200c str r2, [sp, #12] 15ef0: e2802008 add r2, r0, #8
the_chain->permanent_null = NULL;
15ef4: e3a03000 mov r3, #0 15ef8: e58d2004 str r2, [sp, #4] 15efc: e2802040 add r2, r0, #64 ; 0x40
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
15f00: e58da018 str sl, [sp, #24]
the_chain->permanent_null = NULL;
15f04: e58d301c str r3, [sp, #28] 15f08: e58d3010 str r3, [sp, #16]
the_chain->last = _Chain_Head(the_chain);
15f0c: e58d7014 str r7, [sp, #20] 15f10: e59f91a8 ldr r9, [pc, #424] ; 160c0 <_Timer_server_Body+0x1fc> 15f14: e59fb1a8 ldr fp, [pc, #424] ; 160c4 <_Timer_server_Body+0x200> 15f18: e58d2008 str r2, [sp, #8] 15f1c: e1a04000 mov r4, r0 15f20: e2806030 add r6, r0, #48 ; 0x30 15f24: e2808068 add r8, r0, #104 ; 0x68
{
/*
* 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;
15f28: e28d3018 add r3, sp, #24 15f2c: e5843078 str r3, [r4, #120] ; 0x78
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
15f30: e5993000 ldr r3, [r9]
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
15f34: e594103c ldr r1, [r4, #60] ; 0x3c
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
15f38: e1a02007 mov r2, r7 15f3c: e1a00006 mov r0, r6
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
15f40: e584303c str r3, [r4, #60] ; 0x3c
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
15f44: e0611003 rsb r1, r1, r3 15f48: eb0011d1 bl 1a694 <_Watchdog_Adjust_to_chain>
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
15f4c: e59b5000 ldr r5, [fp]
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
15f50: e5942074 ldr r2, [r4, #116] ; 0x74
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
15f54: e1550002 cmp r5, r2
15f58: 8a000022 bhi 15fe8 <_Timer_server_Body+0x124>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
15f5c: 3a000018 bcc 15fc4 <_Timer_server_Body+0x100>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
15f60: e5845074 str r5, [r4, #116] ; 0x74
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
15f64: e5940078 ldr r0, [r4, #120] ; 0x78 15f68: eb0002d3 bl 16abc <_Chain_Get>
if ( timer == NULL ) {
15f6c: e2501000 subs r1, r0, #0
15f70: 0a00000b beq 15fa4 <_Timer_server_Body+0xe0>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
15f74: e5913038 ldr r3, [r1, #56] ; 0x38 15f78: e3530001 cmp r3, #1
15f7c: 0a000015 beq 15fd8 <_Timer_server_Body+0x114>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
15f80: e3530003 cmp r3, #3
15f84: 1afffff6 bne 15f64 <_Timer_server_Body+0xa0>
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
15f88: e2811010 add r1, r1, #16 15f8c: e1a00008 mov r0, r8 15f90: eb0011e9 bl 1a73c <_Watchdog_Insert>
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
15f94: e5940078 ldr r0, [r4, #120] ; 0x78 15f98: eb0002c7 bl 16abc <_Chain_Get>
if ( timer == NULL ) {
15f9c: e2501000 subs r1, r0, #0
15fa0: 1afffff3 bne 15f74 <_Timer_server_Body+0xb0>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
15fa4: e10f2000 mrs r2, CPSR 15fa8: e3823080 orr r3, r2, #128 ; 0x80 15fac: e129f003 msr CPSR_fc, r3
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
15fb0: e59d3018 ldr r3, [sp, #24] 15fb4: e15a0003 cmp sl, r3
15fb8: 0a00000f beq 15ffc <_Timer_server_Body+0x138>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
15fbc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 15fc0: eaffffda b 15f30 <_Timer_server_Body+0x6c> <== 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 );
15fc4: e1a00008 mov r0, r8 15fc8: e3a01001 mov r1, #1 15fcc: e0652002 rsb r2, r5, r2 15fd0: eb001180 bl 1a5d8 <_Watchdog_Adjust> 15fd4: eaffffe1 b 15f60 <_Timer_server_Body+0x9c>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
15fd8: e1a00006 mov r0, r6 15fdc: e2811010 add r1, r1, #16 15fe0: eb0011d5 bl 1a73c <_Watchdog_Insert> 15fe4: eaffffde b 15f64 <_Timer_server_Body+0xa0>
/*
* 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 );
15fe8: e0621005 rsb r1, r2, r5 15fec: e1a00008 mov r0, r8 15ff0: e1a02007 mov r2, r7 15ff4: eb0011a6 bl 1a694 <_Watchdog_Adjust_to_chain> 15ff8: eaffffd8 b 15f60 <_Timer_server_Body+0x9c>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
15ffc: e5841078 str r1, [r4, #120] ; 0x78 16000: e129f002 msr CPSR_fc, r2
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
16004: e59d300c ldr r3, [sp, #12] 16008: e59d2000 ldr r2, [sp] 1600c: e1520003 cmp r2, r3
16010: 0a000015 beq 1606c <_Timer_server_Body+0x1a8>
16014: e1a05004 mov r5, r4 16018: e59d4000 ldr r4, [sp] 1601c: ea000009 b 16048 <_Timer_server_Body+0x184>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
16020: e5932000 ldr r2, [r3]
the_chain->first = new_first; new_first->previous = _Chain_Head(the_chain);
16024: e5827004 str r7, [r2, #4]
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
the_chain->first = new_first;
16028: e58d200c str r2, [sp, #12]
* 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;
1602c: e3a02000 mov r2, #0 16030: e5832008 str r2, [r3, #8] 16034: e129f001 msr CPSR_fc, r1
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
16038: e2830020 add r0, r3, #32
1603c: e8900003 ldm r0, {r0, r1}
16040: e1a0e00f mov lr, pc
16044: e593f01c ldr pc, [r3, #28]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
16048: e10f1000 mrs r1, CPSR 1604c: e3813080 orr r3, r1, #128 ; 0x80 16050: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
16054: e59d300c ldr r3, [sp, #12]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
16058: e1540003 cmp r4, r3
1605c: 1affffef bne 16020 <_Timer_server_Body+0x15c>
16060: e1a04005 mov r4, r5
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
16064: e129f001 msr CPSR_fc, r1 16068: eaffffae b 15f28 <_Timer_server_Body+0x64>
}
} else {
ts->active = false;
1606c: e3a03000 mov r3, #0 16070: e5c4307c strb r3, [r4, #124] ; 0x7c 16074: e59f204c ldr r2, [pc, #76] ; 160c8 <_Timer_server_Body+0x204> 16078: e5923000 ldr r3, [r2] 1607c: e2833001 add r3, r3, #1 16080: e5823000 str r3, [r2]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
16084: e3a01008 mov r1, #8 16088: e5940000 ldr r0, [r4] 1608c: eb000ee7 bl 19c30 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
16090: e1a00004 mov r0, r4 16094: ebffff5e bl 15e14 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
16098: e1a00004 mov r0, r4 1609c: ebffff72 bl 15e6c <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
160a0: eb000c44 bl 191b8 <_Thread_Enable_dispatch>
ts->active = true;
160a4: e3a03001 mov r3, #1 160a8: e5c4307c strb r3, [r4, #124] ; 0x7c
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
160ac: e59d0004 ldr r0, [sp, #4] 160b0: eb001204 bl 1a8c8 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
160b4: e59d0008 ldr r0, [sp, #8] 160b8: eb001202 bl 1a8c8 <_Watchdog_Remove> 160bc: eaffff99 b 15f28 <_Timer_server_Body+0x64>
00008720 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
8720: e92d40f0 push {r4, r5, r6, r7, lr}
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
8724: e59f5050 ldr r5, [pc, #80] ; 877c <_User_extensions_Thread_create+0x5c>
8728: e4954004 ldr r4, [r5], #4
872c: e1540005 cmp r4, r5
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
8730: e1a06000 mov r6, r0
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
8734: 0a00000e beq 8774 <_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)(
8738: e59f7040 ldr r7, [pc, #64] ; 8780 <_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 ) {
873c: e5943014 ldr r3, [r4, #20]
8740: e3530000 cmp r3, #0
status = (*the_extension->Callouts.thread_create)(
8744: 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 ) {
8748: 0a000004 beq 8760 <_User_extensions_Thread_create+0x40>
status = (*the_extension->Callouts.thread_create)(
874c: e5970004 ldr r0, [r7, #4]
8750: e1a0e00f mov lr, pc
8754: e12fff13 bx r3
_Thread_Executing,
the_thread
);
if ( !status )
8758: e3500000 cmp r0, #0
875c: 08bd80f0 popeq {r4, r5, r6, r7, pc}
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
8760: e5944000 ldr r4, [r4]
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
8764: e1540005 cmp r4, r5
8768: 1afffff3 bne 873c <_User_extensions_Thread_create+0x1c>
if ( !status )
return false;
}
}
return true;
876c: e3a00001 mov r0, #1
8770: e8bd80f0 pop {r4, r5, r6, r7, pc}
8774: e3a00001 mov r0, #1 <== NOT EXECUTED
}
8778: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0000a704 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
a704: e92d41f0 push {r4, r5, r6, r7, r8, lr}
a708: e1a04000 mov r4, r0
a70c: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a710: e10f3000 mrs r3, CPSR
a714: e3832080 orr r2, r3, #128 ; 0x80
a718: e129f002 msr CPSR_fc, r2
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
a71c: e1a07000 mov r7, r0
a720: e4972004 ldr r2, [r7], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
a724: e1520007 cmp r2, r7
a728: 0a000018 beq a790 <_Watchdog_Adjust+0x8c>
switch ( direction ) {
a72c: e3510000 cmp r1, #0
a730: 1a000018 bne a798 <_Watchdog_Adjust+0x94>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
a734: e3550000 cmp r5, #0
a738: 0a000014 beq a790 <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
a73c: e5926010 ldr r6, [r2, #16]
a740: e1550006 cmp r5, r6
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
a744: 23a08001 movcs r8, #1
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
a748: 2a000005 bcs a764 <_Watchdog_Adjust+0x60>
a74c: ea000018 b a7b4 <_Watchdog_Adjust+0xb0> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
a750: e0555006 subs r5, r5, r6
a754: 0a00000d beq a790 <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
a758: e5926010 ldr r6, [r2, #16]
a75c: e1560005 cmp r6, r5
a760: 8a000013 bhi a7b4 <_Watchdog_Adjust+0xb0>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
a764: e5828010 str r8, [r2, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a768: e129f003 msr CPSR_fc, r3
_ISR_Enable( level );
_Watchdog_Tickle( header );
a76c: e1a00004 mov r0, r4
a770: eb0000a0 bl a9f8 <_Watchdog_Tickle>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a774: e10f3000 mrs r3, CPSR
a778: e3832080 orr r2, r3, #128 ; 0x80
a77c: e129f002 msr CPSR_fc, r2
a780: e5941000 ldr r1, [r4]
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
a784: e1570001 cmp r7, r1
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) header->first );
a788: e1a02001 mov r2, r1
a78c: 1affffef bne a750 <_Watchdog_Adjust+0x4c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a790: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
a794: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
a798: e3510001 cmp r1, #1
a79c: 1afffffb bne a790 <_Watchdog_Adjust+0x8c>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
a7a0: e5921010 ldr r1, [r2, #16]
a7a4: e0815005 add r5, r1, r5
a7a8: e5825010 str r5, [r2, #16]
a7ac: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
a7b0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
a7b4: e0655006 rsb r5, r5, r6
a7b8: e5825010 str r5, [r2, #16]
break;
a7bc: eafffff3 b a790 <_Watchdog_Adjust+0x8c>
000059fc <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
59fc: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
5a00: e59f41bc ldr r4, [pc, #444] ; 5bc4 <aio_cancel+0x1c8>
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
5a04: e1a05001 mov r5, r1
5a08: e1a07000 mov r7, r0
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
5a0c: e1a00004 mov r0, r4
5a10: eb000406 bl 6a30 <pthread_mutex_lock>
if (aiocbp == NULL)
5a14: e3550000 cmp r5, #0
5a18: 0a00002e beq 5ad8 <aio_cancel+0xdc>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
}
else
{
if (aiocbp->aio_fildes != fildes) {
5a1c: e5956000 ldr r6, [r5]
5a20: e1560007 cmp r6, r7
5a24: 1a000024 bne 5abc <aio_cancel+0xc0>
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,
5a28: e2840048 add r0, r4, #72 ; 0x48
5a2c: e1a01006 mov r1, r6
5a30: e3a02000 mov r2, #0
5a34: eb0000a6 bl 5cd4 <rtems_aio_search_fd>
fildes,
0);
if (r_chain == NULL)
5a38: e2507000 subs r7, r0, #0
5a3c: 0a00000c beq 5a74 <aio_cancel+0x78>
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
pthread_mutex_lock (&r_chain->mutex);
5a40: e287401c add r4, r7, #28 <== NOT EXECUTED
5a44: e1a00004 mov r0, r4 <== NOT EXECUTED
5a48: eb0003f8 bl 6a30 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
5a4c: e1a01005 mov r1, r5 <== NOT EXECUTED
5a50: e2870008 add r0, r7, #8 <== NOT EXECUTED
5a54: eb00019a bl 60c4 <rtems_aio_remove_req> <== NOT EXECUTED
5a58: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
5a5c: e1a00004 mov r0, r4 <== NOT EXECUTED
5a60: eb000413 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
5a64: e59f0158 ldr r0, [pc, #344] ; 5bc4 <aio_cancel+0x1c8> <== NOT EXECUTED
5a68: eb000411 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
5a6c: e1a00005 mov r0, r5
5a70: e8bd80f0 pop {r4, r5, r6, r7, pc}
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))
5a74: e5942054 ldr r2, [r4, #84] ; 0x54
5a78: e2843058 add r3, r4, #88 ; 0x58
5a7c: e1520003 cmp r2, r3
5a80: 0affffee beq 5a40 <aio_cancel+0x44>
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
5a84: e2840054 add r0, r4, #84 ; 0x54
5a88: e1a01006 mov r1, r6
5a8c: e1a02007 mov r2, r7
5a90: eb00008f bl 5cd4 <rtems_aio_search_fd>
fildes, 0); if (r_chain == NULL)
5a94: e3500000 cmp r0, #0
5a98: 0a000007 beq 5abc <aio_cancel+0xc0>
{
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
5a9c: e1a01005 mov r1, r5 <== NOT EXECUTED
5aa0: e2800008 add r0, r0, #8 <== NOT EXECUTED
5aa4: eb000186 bl 60c4 <rtems_aio_remove_req> <== NOT EXECUTED
5aa8: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
5aac: e1a00004 mov r0, r4 <== NOT EXECUTED
5ab0: eb0003ff bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
5ab4: e1a00005 mov r0, r5 <== NOT EXECUTED
5ab8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
fildes,
0);
if (r_chain == NULL)
{
pthread_mutex_unlock (&aio_request_queue.mutex);
5abc: e1a00004 mov r0, r4
5ac0: eb0003fb bl 6ab4 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
5ac4: eb0029df bl 10248 <__errno>
5ac8: e3a03016 mov r3, #22
5acc: e5803000 str r3, [r0]
5ad0: e3e05000 mvn r5, #0
5ad4: eaffffe4 b 5a6c <aio_cancel+0x70>
pthread_mutex_lock (&aio_request_queue.mutex);
if (aiocbp == NULL)
{
if (fcntl (fildes, F_GETFL) < 0) {
5ad8: e1a00007 mov r0, r7 <== NOT EXECUTED
5adc: e3a01003 mov r1, #3 <== NOT EXECUTED
5ae0: eb001ad0 bl c628 <fcntl> <== NOT EXECUTED
5ae4: e3500000 cmp r0, #0 <== NOT EXECUTED
5ae8: ba00002e blt 5ba8 <aio_cancel+0x1ac> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
5aec: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED
5af0: e1a01007 mov r1, r7 <== NOT EXECUTED
5af4: e1a02005 mov r2, r5 <== NOT EXECUTED
5af8: eb000075 bl 5cd4 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
5afc: e2506000 subs r6, r0, #0 <== NOT EXECUTED
5b00: 0a00000b beq 5b34 <aio_cancel+0x138> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_ALLDONE;
}
pthread_mutex_lock (&r_chain->mutex);
5b04: e286701c add r7, r6, #28 <== NOT EXECUTED
5b08: e1a00007 mov r0, r7 <== NOT EXECUTED
5b0c: eb0003c7 bl 6a30 <pthread_mutex_lock> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
5b10: e2860008 add r0, r6, #8 <== NOT EXECUTED
5b14: eb000a33 bl 83e8 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
5b18: e1a00006 mov r0, r6 <== NOT EXECUTED
5b1c: eb000152 bl 606c <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
5b20: e1a00007 mov r0, r7 <== NOT EXECUTED
5b24: eb0003e2 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
5b28: e1a00004 mov r0, r4 <== NOT EXECUTED
5b2c: eb0003e0 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
5b30: eaffffcd b 5a6c <aio_cancel+0x70> <== 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))
5b34: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED
5b38: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED
5b3c: e1520003 cmp r2, r3 <== NOT EXECUTED
5b40: 0a000014 beq 5b98 <aio_cancel+0x19c> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
5b44: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED
5b48: e1a01007 mov r1, r7 <== NOT EXECUTED
5b4c: e1a02006 mov r2, r6 <== NOT EXECUTED
5b50: eb00005f bl 5cd4 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL) {
5b54: e2505000 subs r5, r0, #0 <== NOT EXECUTED
5b58: 0a00000e beq 5b98 <aio_cancel+0x19c> <== NOT EXECUTED
5b5c: e2850008 add r0, r5, #8 <== NOT EXECUTED
return AIO_ALLDONE;
}
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
pthread_mutex_destroy (&r_chain->mutex);
5b60: e285701c add r7, r5, #28 <== NOT EXECUTED
5b64: eb000a1f bl 83e8 <_Chain_Extract> <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
return AIO_ALLDONE;
}
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
5b68: e1a00005 mov r0, r5 <== NOT EXECUTED
5b6c: eb00013e bl 606c <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
5b70: e1a00007 mov r0, r7 <== NOT EXECUTED
5b74: eb00030a bl 67a4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
5b78: e1a00007 mov r0, r7 <== NOT EXECUTED
5b7c: eb000231 bl 6448 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
5b80: e1a00005 mov r0, r5 <== NOT EXECUTED
5b84: ebfff2fd bl 2780 <free> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
5b88: e1a00004 mov r0, r4 <== NOT EXECUTED
5b8c: eb0003c8 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
5b90: e1a05006 mov r5, r6 <== NOT EXECUTED
5b94: eaffffb4 b 5a6c <aio_cancel+0x70> <== NOT EXECUTED
}
pthread_mutex_unlock (&aio_request_queue.mutex);
5b98: e1a00004 mov r0, r4 <== NOT EXECUTED
5b9c: eb0003c4 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
5ba0: e3a05002 mov r5, #2 <== NOT EXECUTED
5ba4: eaffffb0 b 5a6c <aio_cancel+0x70> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
if (aiocbp == NULL)
{
if (fcntl (fildes, F_GETFL) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
5ba8: e1a00004 mov r0, r4 <== NOT EXECUTED
5bac: eb0003c0 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one (EBADF);
5bb0: eb0029a4 bl 10248 <__errno> <== NOT EXECUTED
5bb4: e3a03009 mov r3, #9 <== NOT EXECUTED
5bb8: e5803000 str r3, [r0] <== NOT EXECUTED
5bbc: e3e05000 mvn r5, #0 <== NOT EXECUTED
5bc0: eaffffa9 b 5a6c <aio_cancel+0x70> <== NOT EXECUTED
0000631c <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
631c: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6320: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
6324: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6328: e5900000 ldr r0, [r0]
632c: eb0018b9 bl c618 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6330: e2000003 and r0, r0, #3
6334: e3500002 cmp r0, #2
6338: 13500000 cmpne r0, #0
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
633c: 13a05009 movne r5, #9
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6340: 1a00000f bne 6384 <aio_read+0x68>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
6344: e5943014 ldr r3, [r4, #20]
6348: e3530000 cmp r3, #0
634c: 1a000013 bne 63a0 <aio_read+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
6350: e5943008 ldr r3, [r4, #8]
6354: e3530000 cmp r3, #0
6358: ba000010 blt 63a0 <aio_read+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
635c: e3a00018 mov r0, #24
6360: ebfff224 bl 2bf8 <malloc>
if (req == NULL)
6364: e2503000 subs r3, r0, #0
6368: 0a000004 beq 6380 <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
636c: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_READ;
6370: e3a03001 mov r3, #1
6374: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
6378: e8bd4030 pop {r4, r5, lr}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
637c: eaffff65 b 6118 <rtems_aio_enqueue>
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);
6380: e3a0500b mov r5, #11 <== NOT EXECUTED
6384: e3e03000 mvn r3, #0
6388: e5845030 str r5, [r4, #48] ; 0x30
638c: e5843034 str r3, [r4, #52] ; 0x34
6390: eb0027a8 bl 10238 <__errno>
6394: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
6398: e3e00000 mvn r0, #0
639c: e8bd8030 pop {r4, r5, pc}
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);
63a0: e3a05016 mov r5, #22 <== NOT EXECUTED
63a4: eafffff6 b 6384 <aio_read+0x68> <== NOT EXECUTED
00006334 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
6334: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6338: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
633c: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6340: e5900000 ldr r0, [r0]
6344: eb0018b7 bl c628 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6348: e2000003 and r0, r0, #3
634c: e2400001 sub r0, r0, #1
6350: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
6354: 83a05009 movhi r5, #9
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6358: 8a00000f bhi 639c <aio_write+0x68>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
635c: e5943014 ldr r3, [r4, #20]
6360: e3530000 cmp r3, #0
6364: 1a000013 bne 63b8 <aio_write+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
6368: e5943008 ldr r3, [r4, #8]
636c: e3530000 cmp r3, #0
6370: ba000010 blt 63b8 <aio_write+0x84>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
6374: e3a00018 mov r0, #24
6378: ebfff222 bl 2c08 <malloc>
if (req == NULL)
637c: e2503000 subs r3, r0, #0
6380: 0a000004 beq 6398 <aio_write+0x64>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
6384: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
6388: e3a03002 mov r3, #2
638c: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
6390: e8bd4030 pop {r4, r5, lr}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
6394: eaffff63 b 6128 <rtems_aio_enqueue>
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);
6398: e3a0500b mov r5, #11 <== NOT EXECUTED
639c: e3e03000 mvn r3, #0
63a0: e5845030 str r5, [r4, #48] ; 0x30
63a4: e5843034 str r3, [r4, #52] ; 0x34
63a8: eb0027a6 bl 10248 <__errno>
63ac: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
63b0: e3e00000 mvn r0, #0
63b4: e8bd8030 pop {r4, r5, pc}
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);
63b8: e3a05016 mov r5, #22 <== NOT EXECUTED
63bc: eafffff6 b 639c <aio_write+0x68> <== NOT EXECUTED
00021b80 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
21b80: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
21b84: e24dd00c sub sp, sp, #12
21b88: e1a04000 mov r4, r0
21b8c: e1a05001 mov r5, r1
21b90: e1a08002 mov r8, r2
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
21b94: ebffff40 bl 2189c <getpid> 21b98: e1500004 cmp r0, r4
21b9c: 1a000095 bne 21df8 <killinfo+0x278>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
21ba0: e3550000 cmp r5, #0
21ba4: 0a000098 beq 21e0c <killinfo+0x28c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
21ba8: e2454001 sub r4, r5, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
21bac: e354001f cmp r4, #31
21bb0: 8a000095 bhi 21e0c <killinfo+0x28c>
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 )
21bb4: e59f627c ldr r6, [pc, #636] ; 21e38 <killinfo+0x2b8> 21bb8: e1a07085 lsl r7, r5, #1 21bbc: e0873005 add r3, r7, r5 21bc0: e0863103 add r3, r6, r3, lsl #2 21bc4: e5933008 ldr r3, [r3, #8] 21bc8: e3530001 cmp r3, #1
return 0;
21bcc: 03a00000 moveq r0, #0
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 )
21bd0: 0a000038 beq 21cb8 <killinfo+0x138>
/*
* 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 ) )
21bd4: e3550008 cmp r5, #8 21bd8: 13550004 cmpne r5, #4
21bdc: 0a000037 beq 21cc0 <killinfo+0x140>
21be0: e355000b cmp r5, #11
21be4: 0a000035 beq 21cc0 <killinfo+0x140>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
21be8: e3a03001 mov r3, #1
/* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER;
21bec: e58d3004 str r3, [sp, #4]
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
21bf0: e58d5000 str r5, [sp]
siginfo->si_code = SI_USER;
if ( !value ) {
21bf4: e3580000 cmp r8, #0 21bf8: e1a04413 lsl r4, r3, r4
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
21bfc: 15983000 ldrne r3, [r8] 21c00: 158d3008 strne r3, [sp, #8] 21c04: e59f3230 ldr r3, [pc, #560] ; 21e3c <killinfo+0x2bc> 21c08: e5932000 ldr r2, [r3] 21c0c: e2822001 add r2, r2, #1
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
21c10: 058d8008 streq r8, [sp, #8] 21c14: e5832000 str r2, [r3]
/*
* Is the currently executing thread interested? If so then it will
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Thread_Executing;
21c18: e59f3220 ldr r3, [pc, #544] ; 21e40 <killinfo+0x2c0> 21c1c: e5930004 ldr r0, [r3, #4]
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
21c20: e5903108 ldr r3, [r0, #264] ; 0x108 21c24: e59330d0 ldr r3, [r3, #208] ; 0xd0 21c28: e1d43003 bics r3, r4, r3
21c2c: 1a000014 bne 21c84 <killinfo+0x104>
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
21c30: e59f120c ldr r1, [pc, #524] ; 21e44 <killinfo+0x2c4> 21c34: e4913004 ldr r3, [r1], #4 21c38: e1530001 cmp r3, r1
21c3c: 0a000030 beq 21d04 <killinfo+0x184>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
21c40: e5932030 ldr r2, [r3, #48] ; 0x30 21c44: e1140002 tst r4, r2
for ( the_node = the_chain->first ;
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
21c48: e1a00003 mov r0, r3
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
21c4c: e5932108 ldr r2, [r3, #264] ; 0x108
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
21c50: 0a000008 beq 21c78 <killinfo+0xf8>
21c54: ea00000a b 21c84 <killinfo+0x104>
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
21c58: e5933000 ldr r3, [r3]
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = the_chain->first ;
21c5c: e1530001 cmp r3, r1
21c60: 0a000027 beq 21d04 <killinfo+0x184>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
21c64: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED 21c68: e1140002 tst r4, r2 <== NOT EXECUTED
for ( the_node = the_chain->first ;
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
21c6c: e1a00003 mov r0, r3 <== NOT EXECUTED
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
21c70: e5932108 ldr r2, [r3, #264] ; 0x108 <== NOT EXECUTED
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
21c74: 1a000002 bne 21c84 <killinfo+0x104> <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
21c78: e59220d0 ldr r2, [r2, #208] ; 0xd0 21c7c: e1d42002 bics r2, r4, r2
21c80: 0afffff4 beq 21c58 <killinfo+0xd8>
/*
* 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 ) ) {
21c84: e1a01005 mov r1, r5 21c88: e1a0200d mov r2, sp 21c8c: eb00007c bl 21e84 <_POSIX_signals_Unblock_thread> 21c90: e3500000 cmp r0, #0
21c94: 1a000005 bne 21cb0 <killinfo+0x130>
/*
* 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 );
21c98: e1a00004 mov r0, r4
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
21c9c: e0875005 add r5, r7, r5
/*
* 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 );
21ca0: eb00006d bl 21e5c <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
21ca4: e7963105 ldr r3, [r6, r5, lsl #2] 21ca8: e3530002 cmp r3, #2
21cac: 0a000007 beq 21cd0 <killinfo+0x150>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
21cb0: ebffac38 bl cd98 <_Thread_Enable_dispatch>
return 0;
21cb4: e3a00000 mov r0, #0
}
21cb8: e28dd00c add sp, sp, #12
21cbc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* 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 );
21cc0: eb0000f7 bl 220a4 <pthread_self> 21cc4: e1a01005 mov r1, r5 21cc8: eb0000bc bl 21fc0 <pthread_kill> 21ccc: eafffff9 b 21cb8 <killinfo+0x138>
_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 );
21cd0: e59f0170 ldr r0, [pc, #368] ; 21e48 <killinfo+0x2c8> 21cd4: ebffa63b bl b5c8 <_Chain_Get>
if ( !psiginfo ) {
21cd8: e250c000 subs ip, r0, #0
21cdc: 0a00004f beq 21e20 <killinfo+0x2a0>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
21ce0: e1a0300d mov r3, sp
21ce4: e8930007 ldm r3, {r0, r1, r2}
21ce8: e28c3008 add r3, ip, #8
21cec: e8830007 stm r3, {r0, r1, r2}
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
21cf0: e59f0154 ldr r0, [pc, #340] ; 21e4c <killinfo+0x2cc> 21cf4: e1a0100c mov r1, ip 21cf8: e0800105 add r0, r0, r5, lsl #2 21cfc: ebffa61e bl b57c <_Chain_Append> 21d00: eaffffea b 21cb0 <killinfo+0x130>
* NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1;
21d04: e59f3144 ldr r3, [pc, #324] ; 21e50 <killinfo+0x2d0> 21d08: e5d3e000 ldrb lr, [r3] 21d0c: e59fa140 ldr sl, [pc, #320] ; 21e54 <killinfo+0x2d4> 21d10: e28ee001 add lr, lr, #1
* * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL;
21d14: e3a08000 mov r8, #0
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
21d18: e5ba3004 ldr r3, [sl, #4]! 21d1c: e3530000 cmp r3, #0
21d20: 0a000022 beq 21db0 <killinfo+0x230>
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
21d24: e5933004 ldr r3, [r3, #4]
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
21d28: e1d3c1b0 ldrh ip, [r3, #16]
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
21d2c: e35c0000 cmp ip, #0
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
21d30: e593101c ldr r1, [r3, #28]
for ( index = 1 ; index <= maximum ; index++ ) {
21d34: 0a00001d beq 21db0 <killinfo+0x230>
21d38: e3a02001 mov r2, #1
the_thread = (Thread_Control *) object_table[ index ];
21d3c: e5b13004 ldr r3, [r1, #4]!
if ( !the_thread )
21d40: e3530000 cmp r3, #0
21d44: 0a000016 beq 21da4 <killinfo+0x224>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
21d48: e5930014 ldr r0, [r3, #20] 21d4c: e150000e cmp r0, lr
21d50: 8a000013 bhi 21da4 <killinfo+0x224>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
21d54: e5939108 ldr r9, [r3, #264] ; 0x108 21d58: e59990d0 ldr r9, [r9, #208] ; 0xd0 21d5c: e1d49009 bics r9, r4, r9
21d60: 0a00000f beq 21da4 <killinfo+0x224>
*
* 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 ) {
21d64: e150000e cmp r0, lr
21d68: 3a00001c bcc 21de0 <killinfo+0x260>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
21d6c: e3580000 cmp r8, #0
21d70: 0a00000b beq 21da4 <killinfo+0x224>
21d74: e5989010 ldr r9, [r8, #16] 21d78: e3590000 cmp r9, #0
21d7c: 0a000008 beq 21da4 <killinfo+0x224>
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
21d80: e593b010 ldr fp, [r3, #16] 21d84: e35b0000 cmp fp, #0
21d88: 0a000014 beq 21de0 <killinfo+0x260>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
21d8c: e3190201 tst r9, #268435456 ; 0x10000000
21d90: 1a000003 bne 21da4 <killinfo+0x224>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
21d94: e20bb201 and fp, fp, #268435456 ; 0x10000000
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
21d98: e35b0000 cmp fp, #0 21d9c: 11a0e000 movne lr, r0 21da0: 11a08003 movne r8, r3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
21da4: e2822001 add r2, r2, #1 21da8: e15c0002 cmp ip, r2
21dac: 2affffe2 bcs 21d3c <killinfo+0x1bc>
* + 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++) {
21db0: e59f30a0 ldr r3, [pc, #160] ; 21e58 <killinfo+0x2d8> 21db4: e15a0003 cmp sl, r3
21db8: 1affffd6 bne 21d18 <killinfo+0x198>
}
}
}
}
if ( interested ) {
21dbc: e3580000 cmp r8, #0
21dc0: 0affffb4 beq 21c98 <killinfo+0x118>
21dc4: e1a00008 mov r0, r8
/*
* 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 ) ) {
21dc8: e1a01005 mov r1, r5 21dcc: e1a0200d mov r2, sp 21dd0: eb00002b bl 21e84 <_POSIX_signals_Unblock_thread> 21dd4: e3500000 cmp r0, #0
21dd8: 0affffae beq 21c98 <killinfo+0x118>
21ddc: eaffffb3 b 21cb0 <killinfo+0x130> <== NOT EXECUTED
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
21de0: e2822001 add r2, r2, #1 21de4: e15c0002 cmp ip, r2
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
21de8: e1a0e000 mov lr, r0 21dec: e1a08003 mov r8, r3
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
21df0: 2affffd1 bcs 21d3c <killinfo+0x1bc>
21df4: eaffffed b 21db0 <killinfo+0x230>
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
21df8: ebffc4d3 bl 1314c <__errno> 21dfc: e3a03003 mov r3, #3 21e00: e5803000 str r3, [r0] 21e04: e3e00000 mvn r0, #0 21e08: eaffffaa b 21cb8 <killinfo+0x138>
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
21e0c: ebffc4ce bl 1314c <__errno> 21e10: e3a03016 mov r3, #22 21e14: e5803000 str r3, [r0] 21e18: e3e00000 mvn r0, #0 21e1c: eaffffa5 b 21cb8 <killinfo+0x138>
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();
21e20: ebffabdc bl cd98 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
21e24: ebffc4c8 bl 1314c <__errno> 21e28: e3a0300b mov r3, #11 21e2c: e5803000 str r3, [r0] 21e30: e3e00000 mvn r0, #0 21e34: eaffff9f b 21cb8 <killinfo+0x138>
0000a86c <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
a86c: e3500000 cmp r0, #0
a870: 0a00000e beq a8b0 <pthread_attr_setschedpolicy+0x44>
a874: e5903000 ldr r3, [r0]
a878: e3530000 cmp r3, #0
a87c: 0a00000b beq a8b0 <pthread_attr_setschedpolicy+0x44>
return EINVAL;
switch ( policy ) {
a880: e3510004 cmp r1, #4
a884: 9a000001 bls a890 <pthread_attr_setschedpolicy+0x24>
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
a888: e3a00086 mov r0, #134 ; 0x86
} }
a88c: e12fff1e bx lr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
a890: e3a03001 mov r3, #1
a894: e1a03113 lsl r3, r3, r1
a898: e3130017 tst r3, #23
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
a89c: 15801014 strne r1, [r0, #20]
return 0;
a8a0: 13a00000 movne r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
a8a4: 112fff1e bxne lr
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
a8a8: e3a00086 mov r0, #134 ; 0x86 <== NOT EXECUTED
} }
a8ac: e12fff1e bx lr <== NOT EXECUTED
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
a8b0: e3a00016 mov r0, #22
a8b4: e12fff1e bx lr
00007724 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
7724: e3500000 cmp r0, #0
7728: 0a000008 beq 7750 <pthread_mutexattr_setpshared+0x2c>
772c: e5903000 ldr r3, [r0]
7730: e3530000 cmp r3, #0
7734: 0a000005 beq 7750 <pthread_mutexattr_setpshared+0x2c>
return EINVAL;
switch ( pshared ) {
7738: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
773c: 95801004 strls r1, [r0, #4]
return 0;
7740: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
7744: 912fff1e bxls lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
7748: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
774c: e12fff1e bx lr <== NOT EXECUTED
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
7750: e3a00016 mov r0, #22
7754: e12fff1e bx lr
00006998 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
6998: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
699c: e2505000 subs r5, r0, #0
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
69a0: e24dd00c sub sp, sp, #12
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
69a4: 0a00001d beq 6a20 <pthread_rwlock_timedrdlock+0x88>
*
* 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 );
69a8: e1a00001 mov r0, r1
69ac: e28d1004 add r1, sp, #4
69b0: eb0019bf bl d0b4 <_POSIX_Absolute_timeout_to_ticks>
69b4: e5951000 ldr r1, [r5]
69b8: e1a04000 mov r4, r0
69bc: e28d2008 add r2, sp, #8
69c0: e59f0098 ldr r0, [pc, #152] ; 6a60 <pthread_rwlock_timedrdlock+0xc8>
69c4: eb000aac bl 947c <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
69c8: e59d3008 ldr r3, [sp, #8]
69cc: e3530000 cmp r3, #0
69d0: 1a000012 bne 6a20 <pthread_rwlock_timedrdlock+0x88>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
69d4: e5951000 ldr r1, [r5]
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,
69d8: e3540003 cmp r4, #3
69dc: 13a05000 movne r5, #0
69e0: 03a05001 moveq r5, #1
69e4: e58d3000 str r3, [sp]
69e8: e2800010 add r0, r0, #16
69ec: e1a02005 mov r2, r5
69f0: e59d3004 ldr r3, [sp, #4]
69f4: eb000738 bl 86dc <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
69f8: eb000ccb bl 9d2c <_Thread_Enable_dispatch>
if ( !do_wait ) {
69fc: e3550000 cmp r5, #0
6a00: 1a000011 bne 6a4c <pthread_rwlock_timedrdlock+0xb4>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
6a04: e59f3058 ldr r3, [pc, #88] ; 6a64 <pthread_rwlock_timedrdlock+0xcc>
6a08: e5933004 ldr r3, [r3, #4]
6a0c: e5930034 ldr r0, [r3, #52] ; 0x34
6a10: e3500002 cmp r0, #2
6a14: 0a000004 beq 6a2c <pthread_rwlock_timedrdlock+0x94>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6a18: eb000046 bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code>
6a1c: ea000000 b 6a24 <pthread_rwlock_timedrdlock+0x8c>
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
6a20: e3a00016 mov r0, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
6a24: e28dd00c add sp, sp, #12
6a28: e8bd8030 pop {r4, r5, pc}
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
6a2c: e3540000 cmp r4, #0
6a30: 0afffffa beq 6a20 <pthread_rwlock_timedrdlock+0x88>
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
6a34: e2444001 sub r4, r4, #1
6a38: e3540001 cmp r4, #1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
6a3c: 93a00074 movls r0, #116 ; 0x74
_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 ||
6a40: 9afffff7 bls 6a24 <pthread_rwlock_timedrdlock+0x8c>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6a44: eb00003b bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED
6a48: eafffff5 b 6a24 <pthread_rwlock_timedrdlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
6a4c: e59f3010 ldr r3, [pc, #16] ; 6a64 <pthread_rwlock_timedrdlock+0xcc>
6a50: e5933004 ldr r3, [r3, #4]
6a54: e5930034 ldr r0, [r3, #52] ; 0x34
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6a58: eb000036 bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code>
6a5c: eafffff0 b 6a24 <pthread_rwlock_timedrdlock+0x8c>
00006a68 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
6a68: e92d4030 push {r4, r5, lr}
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
6a6c: e2505000 subs r5, r0, #0
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
6a70: e24dd00c sub sp, sp, #12
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
6a74: 0a00001d beq 6af0 <pthread_rwlock_timedwrlock+0x88>
*
* 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 );
6a78: e1a00001 mov r0, r1
6a7c: e28d1004 add r1, sp, #4
6a80: eb00198b bl d0b4 <_POSIX_Absolute_timeout_to_ticks>
6a84: e5951000 ldr r1, [r5]
6a88: e1a04000 mov r4, r0
6a8c: e28d2008 add r2, sp, #8
6a90: e59f0098 ldr r0, [pc, #152] ; 6b30 <pthread_rwlock_timedwrlock+0xc8>
6a94: eb000a78 bl 947c <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
6a98: e59d3008 ldr r3, [sp, #8]
6a9c: e3530000 cmp r3, #0
6aa0: 1a000012 bne 6af0 <pthread_rwlock_timedwrlock+0x88>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
6aa4: e5951000 ldr r1, [r5]
(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,
6aa8: e3540003 cmp r4, #3
6aac: 13a05000 movne r5, #0
6ab0: 03a05001 moveq r5, #1
6ab4: e58d3000 str r3, [sp]
6ab8: e2800010 add r0, r0, #16
6abc: e1a02005 mov r2, r5
6ac0: e59d3004 ldr r3, [sp, #4]
6ac4: eb00073b bl 87b8 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
6ac8: eb000c97 bl 9d2c <_Thread_Enable_dispatch>
if ( !do_wait &&
6acc: e3550000 cmp r5, #0
6ad0: 1a000011 bne 6b1c <pthread_rwlock_timedwrlock+0xb4>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
6ad4: e59f3058 ldr r3, [pc, #88] ; 6b34 <pthread_rwlock_timedwrlock+0xcc>
6ad8: e5933004 ldr r3, [r3, #4]
6adc: e5930034 ldr r0, [r3, #52] ; 0x34
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
6ae0: e3500002 cmp r0, #2
6ae4: 0a000004 beq 6afc <pthread_rwlock_timedwrlock+0x94>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6ae8: eb000012 bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code>
6aec: ea000000 b 6af4 <pthread_rwlock_timedwrlock+0x8c>
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
6af0: e3a00016 mov r0, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
6af4: e28dd00c add sp, sp, #12
6af8: e8bd8030 pop {r4, r5, pc}
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
6afc: e3540000 cmp r4, #0
6b00: 0afffffa beq 6af0 <pthread_rwlock_timedwrlock+0x88>
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
6b04: e2444001 sub r4, r4, #1
6b08: e3540001 cmp r4, #1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT;
6b0c: 93a00074 movls r0, #116 ; 0x74
_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 ||
6b10: 9afffff7 bls 6af4 <pthread_rwlock_timedwrlock+0x8c>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6b14: eb000007 bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code><== NOT EXECUTED
6b18: eafffff5 b 6af4 <pthread_rwlock_timedwrlock+0x8c> <== NOT EXECUTED
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
6b1c: e59f3010 ldr r3, [pc, #16] ; 6b34 <pthread_rwlock_timedwrlock+0xcc>
6b20: e5933004 ldr r3, [r3, #4]
6b24: e5930034 ldr r0, [r3, #52] ; 0x34
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
6b28: eb000002 bl 6b38 <_POSIX_RWLock_Translate_core_RWLock_return_code>
6b2c: eafffff0 b 6af4 <pthread_rwlock_timedwrlock+0x8c>
000072d0 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
72d0: e3500000 cmp r0, #0
72d4: 0a000008 beq 72fc <pthread_rwlockattr_setpshared+0x2c>
return EINVAL;
if ( !attr->is_initialized )
72d8: e5903000 ldr r3, [r0]
72dc: e3530000 cmp r3, #0
72e0: 0a000005 beq 72fc <pthread_rwlockattr_setpshared+0x2c>
return EINVAL;
switch ( pshared ) {
72e4: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
72e8: 95801004 strls r1, [r0, #4]
return 0;
72ec: 93a00000 movls r0, #0
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
72f0: 912fff1e bxls lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
72f4: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
72f8: e12fff1e bx lr <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
72fc: e3a00016 mov r0, #22
7300: e12fff1e bx lr
00006128 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
6128: e92d40f0 push {r4, r5, r6, r7, lr}
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized != AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
612c: e59f41e4 ldr r4, [pc, #484] ; 6318 <rtems_aio_enqueue+0x1f0>
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
6130: e24dd024 sub sp, sp, #36 ; 0x24
6134: e1a06000 mov r6, r0
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized != AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
6138: e1a00004 mov r0, r4
613c: eb00023b bl 6a30 <pthread_mutex_lock>
if (result != 0) {
6140: e2505000 subs r5, r0, #0
6144: 1a00002a bne 61f4 <rtems_aio_enqueue+0xcc>
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);
6148: eb00046b bl 72fc <pthread_self> <== NOT EXECUTED
614c: e28d101c add r1, sp, #28 <== NOT EXECUTED
6150: e1a0200d mov r2, sp <== NOT EXECUTED
6154: eb000365 bl 6ef0 <pthread_getschedparam> <== NOT EXECUTED
req->caller_thread = pthread_self ();
6158: eb000467 bl 72fc <pthread_self> <== NOT EXECUTED
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
615c: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
6160: e59dc000 ldr ip, [sp] <== NOT EXECUTED
6164: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED
6168: e062200c rsb r2, r2, ip <== NOT EXECUTED
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
616c: 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;
6170: e5862004 str r2, [r6, #4] <== NOT EXECUTED
req->policy = policy;
6174: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
6178: 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;
617c: e5862000 str r2, [r6] <== NOT EXECUTED
req->aiocbp->error_code = EINPROGRESS;
6180: 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 ();
6184: e5860010 str r0, [r6, #16] <== NOT EXECUTED
req->priority = param.sched_priority - req->aiocbp->aio_reqprio; req->policy = policy; req->aiocbp->error_code = EINPROGRESS;
6188: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = 0;
618c: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
6190: 1a000002 bne 61a0 <rtems_aio_enqueue+0x78> <== NOT EXECUTED
6194: e5942064 ldr r2, [r4, #100] ; 0x64 <== NOT EXECUTED
6198: e3520004 cmp r2, #4 <== NOT EXECUTED
619c: da000017 ble 6200 <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,
61a0: e59f0174 ldr r0, [pc, #372] ; 631c <rtems_aio_enqueue+0x1f4><== NOT EXECUTED
61a4: e5931000 ldr r1, [r3] <== NOT EXECUTED
61a8: e3a02000 mov r2, #0 <== NOT EXECUTED
61ac: ebfffec8 bl 5cd4 <rtems_aio_search_fd> <== NOT EXECUTED
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
61b0: e2504000 subs r4, r0, #0 <== NOT EXECUTED
61b4: 0a000024 beq 624c <rtems_aio_enqueue+0x124> <== NOT EXECUTED
{
pthread_mutex_lock (&r_chain->mutex);
61b8: e284701c add r7, r4, #28 <== NOT EXECUTED
61bc: e1a00007 mov r0, r7 <== NOT EXECUTED
61c0: eb00021a bl 6a30 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
61c4: e2840010 add r0, r4, #16 <== NOT EXECUTED
61c8: e1a01006 mov r1, r6 <== NOT EXECUTED
61cc: ebffff91 bl 6018 <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
61d0: e2840020 add r0, r4, #32 <== NOT EXECUTED
61d4: eb0000ff bl 65d8 <pthread_cond_signal> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
61d8: e1a00007 mov r0, r7 <== NOT EXECUTED
61dc: eb000234 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
61e0: e59f0130 ldr r0, [pc, #304] ; 6318 <rtems_aio_enqueue+0x1f0><== NOT EXECUTED
61e4: eb000232 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
return 0; }
61e8: e1a00005 mov r0, r5
61ec: e28dd024 add sp, sp, #36 ; 0x24
61f0: e8bd80f0 pop {r4, r5, r6, r7, pc}
/* 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);
61f4: e1a00006 mov r0, r6
61f8: ebfff160 bl 2780 <free>
return result;
61fc: eafffff9 b 61e8 <rtems_aio_enqueue+0xc0>
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);
6200: e5931000 ldr r1, [r3] <== NOT EXECUTED
6204: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED
6208: e3a02001 mov r2, #1 <== NOT EXECUTED
620c: ebfffeb0 bl 5cd4 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain->new_fd == 1) {
6210: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED
6214: e3530001 cmp r3, #1 <== 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);
6218: e1a07000 mov r7, r0 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
621c: 0a000017 beq 6280 <rtems_aio_enqueue+0x158> <== NOT EXECUTED
}
++aio_request_queue.active_threads;
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
6220: e280401c add r4, r0, #28 <== NOT EXECUTED
6224: e1a00004 mov r0, r4 <== NOT EXECUTED
6228: eb000200 bl 6a30 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
622c: e2870010 add r0, r7, #16 <== NOT EXECUTED
6230: e1a01006 mov r1, r6 <== NOT EXECUTED
6234: ebffff77 bl 6018 <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
6238: e2870020 add r0, r7, #32 <== NOT EXECUTED
623c: eb0000e5 bl 65d8 <pthread_cond_signal> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
6240: e1a00004 mov r0, r4 <== NOT EXECUTED
6244: eb00021a bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
6248: eaffffe4 b 61e0 <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);
624c: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
6250: e59f00c8 ldr r0, [pc, #200] ; 6320 <rtems_aio_enqueue+0x1f8><== NOT EXECUTED
6254: e5931000 ldr r1, [r3] <== NOT EXECUTED
6258: e3a02001 mov r2, #1 <== NOT EXECUTED
625c: ebfffe9c bl 5cd4 <rtems_aio_search_fd> <== NOT EXECUTED
if (r_chain->new_fd == 1) {
6260: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED
6264: e3530001 cmp r3, #1 <== 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);
6268: e1a07000 mov r7, r0 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
626c: 0a000018 beq 62d4 <rtems_aio_enqueue+0x1ac> <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL); pthread_cond_init (&r_chain->cond, NULL); pthread_cond_signal (&aio_request_queue.new_req); } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
6270: e2800010 add r0, r0, #16 <== NOT EXECUTED
6274: e1a01006 mov r1, r6 <== NOT EXECUTED
6278: ebffff66 bl 6018 <rtems_aio_insert_prio> <== NOT EXECUTED
627c: eaffffd7 b 61e0 <rtems_aio_enqueue+0xb8> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
6280: e2861008 add r1, r6, #8 <== NOT EXECUTED
6284: e2800010 add r0, r0, #16 <== NOT EXECUTED
6288: eb00086b bl 843c <_Chain_Insert> <== NOT EXECUTED
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;
pthread_mutex_init (&r_chain->mutex, NULL);
628c: 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;
6290: e5875004 str r5, [r7, #4] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
6294: e287001c add r0, r7, #28 <== NOT EXECUTED
6298: eb000191 bl 68e4 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
629c: e1a01005 mov r1, r5 <== NOT EXECUTED
62a0: e2870020 add r0, r7, #32 <== NOT EXECUTED
62a4: eb00009a bl 6514 <pthread_cond_init> <== NOT EXECUTED
AIO_printf ("New thread");
result = pthread_create (&thid, &aio_request_queue.attr,
62a8: e28d0020 add r0, sp, #32 <== NOT EXECUTED
62ac: e2841008 add r1, r4, #8 <== NOT EXECUTED
62b0: e59f206c ldr r2, [pc, #108] ; 6324 <rtems_aio_enqueue+0x1fc><== NOT EXECUTED
62b4: e1a03007 mov r3, r7 <== NOT EXECUTED
62b8: eb000263 bl 6c4c <pthread_create> <== NOT EXECUTED
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
62bc: e2506000 subs r6, r0, #0 <== NOT EXECUTED
62c0: 1a000010 bne 6308 <rtems_aio_enqueue+0x1e0> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
62c4: e5943064 ldr r3, [r4, #100] ; 0x64 <== NOT EXECUTED
62c8: e2833001 add r3, r3, #1 <== NOT EXECUTED
62cc: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED
62d0: eaffffc2 b 61e0 <rtems_aio_enqueue+0xb8> <== NOT EXECUTED
62d4: e2861008 add r1, r6, #8 <== NOT EXECUTED
62d8: e2800010 add r0, r0, #16 <== NOT EXECUTED
62dc: eb000856 bl 843c <_Chain_Insert> <== 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 */
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
62e0: e1a01004 mov r1, r4 <== NOT EXECUTED
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
62e4: e5874004 str r4, [r7, #4] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
62e8: e287001c add r0, r7, #28 <== NOT EXECUTED
62ec: eb00017c bl 68e4 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
62f0: e2870020 add r0, r7, #32 <== NOT EXECUTED
62f4: e1a01004 mov r1, r4 <== NOT EXECUTED
62f8: eb000085 bl 6514 <pthread_cond_init> <== NOT EXECUTED
pthread_cond_signal (&aio_request_queue.new_req);
62fc: e59f0024 ldr r0, [pc, #36] ; 6328 <rtems_aio_enqueue+0x200><== NOT EXECUTED
6300: eb0000b4 bl 65d8 <pthread_cond_signal> <== NOT EXECUTED
6304: eaffffb5 b 61e0 <rtems_aio_enqueue+0xb8> <== NOT EXECUTED
AIO_printf ("New thread");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
6308: e1a00004 mov r0, r4 <== NOT EXECUTED
630c: eb0001e8 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
6310: e1a05006 mov r5, r6 <== NOT EXECUTED
6314: eaffffb3 b 61e8 <rtems_aio_enqueue+0xc0> <== NOT EXECUTED
00005d98 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
5d98: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
5d9c: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
5da0: e1a05000 mov r5, r0 <== NOT EXECUTED
5da4: e280601c add r6, r0, #28 <== NOT EXECUTED
node = chain->first;
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
5da8: e28d8028 add r8, sp, #40 ; 0x28 <== NOT EXECUTED
5dac: e28d7004 add r7, sp, #4 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
5db0: e3e0b000 mvn fp, #0 <== NOT EXECUTED
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
req->aiocbp->error_code = 0;
5db4: 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);
5db8: e1a00006 mov r0, r6 <== NOT EXECUTED
5dbc: eb00031b bl 6a30 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
5dc0: e250a000 subs sl, r0, #0 <== NOT EXECUTED
5dc4: 1a000021 bne 5e50 <rtems_aio_handle+0xb8> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
5dc8: e5954010 ldr r4, [r5, #16] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
5dcc: e2853014 add r3, r5, #20 <== 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)) {
5dd0: e1540003 cmp r4, r3 <== NOT EXECUTED
5dd4: 0a000038 beq 5ebc <rtems_aio_handle+0x124> <== NOT EXECUTED
node = chain->first;
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
5dd8: eb000547 bl 72fc <pthread_self> <== NOT EXECUTED
5ddc: e1a01008 mov r1, r8 <== NOT EXECUTED
5de0: e1a02007 mov r2, r7 <== NOT EXECUTED
5de4: eb000441 bl 6ef0 <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
5de8: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
5dec: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
5df0: eb000541 bl 72fc <pthread_self> <== NOT EXECUTED
5df4: e5941000 ldr r1, [r4] <== NOT EXECUTED
5df8: e1a02007 mov r2, r7 <== NOT EXECUTED
5dfc: eb000543 bl 7310 <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
5e00: e1a00004 mov r0, r4 <== NOT EXECUTED
5e04: eb000977 bl 83e8 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
5e08: e1a00006 mov r0, r6 <== NOT EXECUTED
5e0c: eb000328 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
5e10: e594a014 ldr sl, [r4, #20] <== NOT EXECUTED
5e14: e59a302c ldr r3, [sl, #44] ; 0x2c <== NOT EXECUTED
5e18: e3530002 cmp r3, #2 <== NOT EXECUTED
5e1c: 0a00001e beq 5e9c <rtems_aio_handle+0x104> <== NOT EXECUTED
5e20: e3530003 cmp r3, #3 <== NOT EXECUTED
5e24: 0a000019 beq 5e90 <rtems_aio_handle+0xf8> <== NOT EXECUTED
5e28: e3530001 cmp r3, #1 <== NOT EXECUTED
5e2c: 0a00000a beq 5e5c <rtems_aio_handle+0xc4> <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
5e30: e58ab034 str fp, [sl, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = errno;
5e34: eb002903 bl 10248 <__errno> <== NOT EXECUTED
5e38: 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);
5e3c: e1a00006 mov r0, r6 <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
5e40: 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);
5e44: eb0002f9 bl 6a30 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
5e48: e250a000 subs sl, r0, #0 <== NOT EXECUTED
5e4c: 0affffdd beq 5dc8 <rtems_aio_handle+0x30> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
5e50: e3a00000 mov r0, #0 <== NOT EXECUTED
5e54: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
5e58: 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:
result = pread (req->aiocbp->aio_fildes,
5e5c: e59ac008 ldr ip, [sl, #8] <== NOT EXECUTED
5e60: e59a0000 ldr r0, [sl] <== NOT EXECUTED
5e64: e28a100c add r1, sl, #12 <== NOT EXECUTED
5e68: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
5e6c: e59a3004 ldr r3, [sl, #4] <== NOT EXECUTED
5e70: e58dc000 str ip, [sp] <== NOT EXECUTED
5e74: eb002bf5 bl 10e50 <pread> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
5e78: e3700001 cmn r0, #1 <== NOT EXECUTED
5e7c: 0a00005c beq 5ff4 <rtems_aio_handle+0x25c> <== NOT EXECUTED
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
5e80: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
5e84: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = 0;
5e88: e5839030 str r9, [r3, #48] ; 0x30 <== NOT EXECUTED
5e8c: eaffffc9 b 5db8 <rtems_aio_handle+0x20> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
result = fsync (req->aiocbp->aio_fildes);
5e90: e59a0000 ldr r0, [sl] <== NOT EXECUTED
5e94: eb001a61 bl c820 <fsync> <== NOT EXECUTED
break;
5e98: eafffff6 b 5e78 <rtems_aio_handle+0xe0> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
result = pwrite (req->aiocbp->aio_fildes,
5e9c: e59ac008 ldr ip, [sl, #8] <== NOT EXECUTED
5ea0: e59a0000 ldr r0, [sl] <== NOT EXECUTED
5ea4: e28a100c add r1, sl, #12 <== NOT EXECUTED
5ea8: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
5eac: e59a3004 ldr r3, [sl, #4] <== NOT EXECUTED
5eb0: e58dc000 str ip, [sp] <== NOT EXECUTED
5eb4: eb002c2d bl 10f70 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
5eb8: eaffffee b 5e78 <rtems_aio_handle+0xe0> <== NOT EXECUTED
wait for a signal on chain, this will unlock the queue.
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
5ebc: e1a00006 mov r0, r6 <== NOT EXECUTED
5ec0: eb0002fb bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
5ec4: e59f013c ldr r0, [pc, #316] ; 6008 <rtems_aio_handle+0x270><== NOT EXECUTED
5ec8: eb0002d8 bl 6a30 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
5ecc: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
5ed0: e1540003 cmp r4, r3 <== NOT EXECUTED
5ed4: 1affffb7 bne 5db8 <rtems_aio_handle+0x20> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
5ed8: e28d1020 add r1, sp, #32 <== NOT EXECUTED
5edc: e3a00001 mov r0, #1 <== NOT EXECUTED
5ee0: eb000136 bl 63c0 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
5ee4: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
5ee8: e2854020 add r4, r5, #32 <== 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);
timeout.tv_sec += 3;
5eec: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
5ef0: e1a00004 mov r0, r4 <== NOT EXECUTED
5ef4: e59f110c ldr r1, [pc, #268] ; 6008 <rtems_aio_handle+0x270><== NOT EXECUTED
5ef8: e28d2020 add r2, sp, #32 <== 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);
timeout.tv_sec += 3;
5efc: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
5f00: e58da024 str sl, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
5f04: eb0001cd bl 6640 <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) {
5f08: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED
5f0c: 1affffa9 bne 5db8 <rtems_aio_handle+0x20> <== NOT EXECUTED
5f10: e2850008 add r0, r5, #8 <== NOT EXECUTED
5f14: eb000933 bl 83e8 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
5f18: e1a00006 mov r0, r6 <== NOT EXECUTED
5f1c: eb000220 bl 67a4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
5f20: e1a00004 mov r0, r4 <== NOT EXECUTED
5f24: eb000147 bl 6448 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
5f28: e1a00005 mov r0, r5 <== NOT EXECUTED
5f2c: ebfff213 bl 2780 <free> <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
5f30: e59f20d0 ldr r2, [pc, #208] ; 6008 <rtems_aio_handle+0x270><== NOT EXECUTED
5f34: e5923054 ldr r3, [r2, #84] ; 0x54 <== NOT EXECUTED
5f38: e59f20cc ldr r2, [pc, #204] ; 600c <rtems_aio_handle+0x274><== NOT EXECUTED
5f3c: e1530002 cmp r3, r2 <== NOT EXECUTED
5f40: 0a000002 beq 5f50 <rtems_aio_handle+0x1b8> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; } else /* 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);
5f44: e59f00bc ldr r0, [pc, #188] ; 6008 <rtems_aio_handle+0x270><== NOT EXECUTED
5f48: eb0002d9 bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
5f4c: eaffff99 b 5db8 <rtems_aio_handle+0x20> <== NOT EXECUTED
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)) {
++aio_request_queue.idle_threads;
5f50: e59f20b0 ldr r2, [pc, #176] ; 6008 <rtems_aio_handle+0x270><== NOT EXECUTED
5f54: e5923068 ldr r3, [r2, #104] ; 0x68 <== NOT EXECUTED
5f58: e2833001 add r3, r3, #1 <== NOT EXECUTED
5f5c: e5823068 str r3, [r2, #104] ; 0x68 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
5f60: e28d1020 add r1, sp, #32 <== NOT EXECUTED
5f64: e3a00001 mov r0, #1 <== NOT EXECUTED
5f68: eb000114 bl 63c0 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
5f6c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&aio_request_queue.new_req,
5f70: e59f0098 ldr r0, [pc, #152] ; 6010 <rtems_aio_handle+0x278><== 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_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
5f74: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&aio_request_queue.new_req,
5f78: e59f1088 ldr r1, [pc, #136] ; 6008 <rtems_aio_handle+0x270><== NOT EXECUTED
5f7c: e28d2020 add r2, 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_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
5f80: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
5f84: e58da024 str sl, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
5f88: eb0001ac bl 6640 <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) {
5f8c: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED
5f90: 0a000019 beq 5ffc <rtems_aio_handle+0x264> <== NOT EXECUTED
return NULL; } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads;
5f94: e59f206c ldr r2, [pc, #108] ; 6008 <rtems_aio_handle+0x270><== NOT EXECUTED
5f98: e5923068 ldr r3, [r2, #104] ; 0x68 <== NOT EXECUTED
node = aio_request_queue.idle_req.first;
5f9c: e5924054 ldr r4, [r2, #84] ; 0x54 <== NOT EXECUTED
return NULL; } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads;
5fa0: e2433001 sub r3, r3, #1 <== NOT EXECUTED
5fa4: e5823068 str r3, [r2, #104] ; 0x68 <== NOT EXECUTED
5fa8: e1a00004 mov r0, r4 <== NOT EXECUTED
5fac: eb00090d bl 83e8 <_Chain_Extract> <== NOT EXECUTED
node = aio_request_queue.idle_req.first; rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
5fb0: e3a02001 mov r2, #1 <== NOT EXECUTED
5fb4: e4941010 ldr r1, [r4], #16 <== NOT EXECUTED
5fb8: e59f0054 ldr r0, [pc, #84] ; 6014 <rtems_aio_handle+0x27c> <== NOT EXECUTED
5fbc: ebffff44 bl 5cd4 <rtems_aio_search_fd> <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
5fc0: e280601c add r6, r0, #28 <== NOT EXECUTED
/* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; node = aio_request_queue.idle_req.first; rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
5fc4: e1a05000 mov r5, r0 <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
5fc8: e1a0100a mov r1, sl <== NOT EXECUTED
node = aio_request_queue.idle_req.first; rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, ((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0;
5fcc: e580a004 str sl, [r0, #4] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
5fd0: e1a00006 mov r0, r6 <== NOT EXECUTED
5fd4: eb000242 bl 68e4 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
5fd8: e1a0100a mov r1, sl <== NOT EXECUTED
5fdc: e2850020 add r0, r5, #32 <== NOT EXECUTED
5fe0: eb00014b bl 6514 <pthread_cond_init> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
5fe4: e8940007 ldm r4, {r0, r1, r2} <== NOT EXECUTED
5fe8: e2853010 add r3, r5, #16 <== NOT EXECUTED
5fec: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
5ff0: eaffff70 b 5db8 <rtems_aio_handle+0x20> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
5ff4: e594a014 ldr sl, [r4, #20] <== NOT EXECUTED
5ff8: eaffff8c b 5e30 <rtems_aio_handle+0x98> <== NOT EXECUTED
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
pthread_mutex_unlock (&aio_request_queue.mutex);
5ffc: e59f0004 ldr r0, [pc, #4] ; 6008 <rtems_aio_handle+0x270> <== NOT EXECUTED
6000: eb0002ab bl 6ab4 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
6004: eaffff91 b 5e50 <rtems_aio_handle+0xb8> <== NOT EXECUTED
00005bd0 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
5bd0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
5bd4: e59f00e8 ldr r0, [pc, #232] ; 5cc4 <rtems_aio_init+0xf4> <== NOT EXECUTED
5bd8: eb0003fb bl 6bcc <pthread_attr_init> <== NOT EXECUTED
if (result != 0)
5bdc: e2505000 subs r5, r0, #0 <== NOT EXECUTED
5be0: 0a000001 beq 5bec <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;
}
5be4: e1a00005 mov r0, r5 <== NOT EXECUTED
5be8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
5bec: e59f00d0 ldr r0, [pc, #208] ; 5cc4 <rtems_aio_init+0xf4> <== NOT EXECUTED
5bf0: e1a01005 mov r1, r5 <== NOT EXECUTED
5bf4: eb000407 bl 6c18 <pthread_attr_setdetachstate> <== NOT EXECUTED
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
5bf8: e3500000 cmp r0, #0 <== NOT EXECUTED
5bfc: 1a00001c bne 5c74 <rtems_aio_init+0xa4> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
5c00: e59f40c0 ldr r4, [pc, #192] ; 5cc8 <rtems_aio_init+0xf8> <== NOT EXECUTED
5c04: e3a01000 mov r1, #0 <== NOT EXECUTED
5c08: e1a00004 mov r0, r4 <== NOT EXECUTED
5c0c: eb000334 bl 68e4 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
5c10: e3500000 cmp r0, #0 <== NOT EXECUTED
5c14: 1a00001e bne 5c94 <rtems_aio_init+0xc4> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
5c18: e59f00ac ldr r0, [pc, #172] ; 5ccc <rtems_aio_init+0xfc> <== NOT EXECUTED
5c1c: e3a01000 mov r1, #0 <== NOT EXECUTED
5c20: eb00023b bl 6514 <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
5c24: e2505000 subs r5, r0, #0 <== NOT EXECUTED
5c28: 1a000020 bne 5cb0 <rtems_aio_init+0xe0> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
5c2c: e59f209c ldr r2, [pc, #156] ; 5cd0 <rtems_aio_init+0x100> <== 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;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
5c30: e3a01a0b mov r1, #45056 ; 0xb000 <== NOT EXECUTED
the_chain->permanent_null = NULL;
5c34: e3a03000 mov r3, #0 <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
5c38: e2820008 add r0, r2, #8 <== NOT EXECUTED
5c3c: e2426004 sub r6, r2, #4 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
5c40: e282c00c add ip, r2, #12 <== NOT EXECUTED
5c44: e281100b add r1, r1, #11 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
5c48: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
5c4c: e5842048 str r2, [r4, #72] ; 0x48 <== NOT EXECUTED
the_chain->permanent_null = NULL;
5c50: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
5c54: e5846050 str r6, [r4, #80] ; 0x50 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
5c58: e584c054 str ip, [r4, #84] ; 0x54 <== NOT EXECUTED
the_chain->permanent_null = NULL;
5c5c: 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;
5c60: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED
aio_request_queue.idle_threads = 0;
5c64: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
5c68: e5841060 str r1, [r4, #96] ; 0x60 <== NOT EXECUTED
return result;
}
5c6c: e1a00005 mov r0, r5 <== NOT EXECUTED
5c70: e8bd8070 pop {r4, r5, r6, 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);
5c74: e59f404c ldr r4, [pc, #76] ; 5cc8 <rtems_aio_init+0xf8> <== NOT EXECUTED
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
5c78: e59f0044 ldr r0, [pc, #68] ; 5cc4 <rtems_aio_init+0xf4> <== NOT EXECUTED
5c7c: eb0003c9 bl 6ba8 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
5c80: e3a01000 mov r1, #0 <== NOT EXECUTED
5c84: e1a00004 mov r0, r4 <== NOT EXECUTED
5c88: eb000315 bl 68e4 <pthread_mutex_init> <== NOT EXECUTED
if (result != 0)
5c8c: e3500000 cmp r0, #0 <== NOT EXECUTED
5c90: 0affffe0 beq 5c18 <rtems_aio_init+0x48> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
5c94: e2840008 add r0, r4, #8 <== NOT EXECUTED
5c98: eb0003c2 bl 6ba8 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
5c9c: e59f0028 ldr r0, [pc, #40] ; 5ccc <rtems_aio_init+0xfc> <== NOT EXECUTED
5ca0: e3a01000 mov r1, #0 <== NOT EXECUTED
5ca4: eb00021a bl 6514 <pthread_cond_init> <== NOT EXECUTED
if (result != 0) {
5ca8: e2505000 subs r5, r0, #0 <== NOT EXECUTED
5cac: 0affffde beq 5c2c <rtems_aio_init+0x5c> <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
5cb0: e59f0010 ldr r0, [pc, #16] ; 5cc8 <rtems_aio_init+0xf8> <== NOT EXECUTED
5cb4: eb0002ba bl 67a4 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
5cb8: e59f0004 ldr r0, [pc, #4] ; 5cc4 <rtems_aio_init+0xf4> <== NOT EXECUTED
5cbc: eb0003b9 bl 6ba8 <pthread_attr_destroy> <== NOT EXECUTED
5cc0: eaffffd9 b 5c2c <rtems_aio_init+0x5c> <== NOT EXECUTED
00006018 <rtems_aio_insert_prio>:
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = chain->first;
6018: e1a02000 mov r2, r0 <== NOT EXECUTED
601c: e4923004 ldr r3, [r2], #4 <== NOT EXECUTED
if (rtems_chain_is_empty (chain)) {
6020: e1530002 cmp r3, r2 <== NOT EXECUTED
6024: 0a00000e beq 6064 <rtems_aio_insert_prio+0x4c> <== 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 &&
6028: e591c014 ldr ip, [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;
602c: e5930014 ldr r0, [r3, #20] <== NOT EXECUTED
while (req->aiocbp->aio_reqprio > prio &&
6030: e59cc014 ldr ip, [ip, #20] <== NOT EXECUTED
6034: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED
6038: e150000c cmp r0, ip <== NOT EXECUTED
603c: ba000002 blt 604c <rtems_aio_insert_prio+0x34> <== NOT EXECUTED
6040: ea000006 b 6060 <rtems_aio_insert_prio+0x48> <== NOT EXECUTED
6044: e1530002 cmp r3, r2 <== NOT EXECUTED
6048: 0a000004 beq 6060 <rtems_aio_insert_prio+0x48> <== NOT EXECUTED
!rtems_chain_is_tail (chain, node)) {
node = node->next;
604c: e5933000 ldr r3, [r3] <== NOT EXECUTED
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
6050: e5930014 ldr r0, [r3, #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 &&
6054: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED
6058: e150000c cmp r0, ip <== NOT EXECUTED
605c: bafffff8 blt 6044 <rtems_aio_insert_prio+0x2c> <== 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 );
6060: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
6064: e2811008 add r1, r1, #8 <== NOT EXECUTED
6068: ea0008f3 b 843c <_Chain_Insert> <== NOT EXECUTED
0000606c <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
606c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = chain->first;
6070: e5904010 ldr r4, [r0, #16] <== NOT EXECUTED
6074: e2800014 add r0, r0, #20 <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
6078: e1540000 cmp r4, r0 <== NOT EXECUTED
607c: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
6080: e1a00004 mov r0, r4 <== NOT EXECUTED
6084: eb0008d7 bl 83e8 <_Chain_Extract> <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
6088: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
608c: e3a0608c mov r6, #140 ; 0x8c <== NOT EXECUTED
req->aiocbp->return_value = -1;
6090: e3e05000 mvn r5, #0 <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
6094: e5836030 str r6, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
6098: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
609c: e1a00004 mov r0, r4 <== NOT EXECUTED
60a0: ebfff1b6 bl 2780 <free> <== NOT EXECUTED
60a4: e1a00004 mov r0, r4 <== NOT EXECUTED
60a8: eb0008ce bl 83e8 <_Chain_Extract> <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
60ac: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
req->aiocbp->return_value = -1;
free (req);
60b0: 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;
req->aiocbp->error_code = ECANCELED;
60b4: e5836030 str r6, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
60b8: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
60bc: ebfff1af bl 2780 <free> <== NOT EXECUTED
60c0: eafffff7 b 60a4 <rtems_aio_remove_fd+0x38> <== NOT EXECUTED
000060c4 <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)
{
60c4: e92d4010 push {r4, lr} <== NOT EXECUTED
rtems_chain_node *node = chain->first;
60c8: e4904004 ldr r4, [r0], #4 <== NOT EXECUTED
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
60cc: e1540000 cmp r4, r0 <== NOT EXECUTED
node = node->next;
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
60d0: 03a00001 moveq r0, #1 <== NOT EXECUTED
rtems_chain_node *node = chain->first;
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
60d4: 1a000003 bne 60e8 <rtems_aio_remove_req+0x24> <== NOT EXECUTED
60d8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
node = node->next;
60dc: e5944000 ldr r4, [r4] <== NOT EXECUTED
rtems_chain_node *node = chain->first;
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
60e0: e1540000 cmp r4, r0 <== NOT EXECUTED
60e4: 0a00000d beq 6120 <rtems_aio_remove_req+0x5c> <== NOT EXECUTED
60e8: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
60ec: e1530001 cmp r3, r1 <== NOT EXECUTED
60f0: 1afffff9 bne 60dc <rtems_aio_remove_req+0x18> <== NOT EXECUTED
60f4: e1a00004 mov r0, r4 <== NOT EXECUTED
60f8: eb0008ba bl 83e8 <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
60fc: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
6100: e3a0208c mov r2, #140 ; 0x8c <== NOT EXECUTED
6104: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
current->aiocbp->return_value = -1;
6108: e3e02000 mvn r2, #0 <== NOT EXECUTED
free (current);
610c: e1a00004 mov r0, r4 <== NOT EXECUTED
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
6110: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
free (current);
6114: ebfff199 bl 2780 <free> <== NOT EXECUTED
}
return AIO_CANCELED;
6118: e3a00000 mov r0, #0 <== NOT EXECUTED
611c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
node = node->next;
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
6120: e3a00001 mov r0, #1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
6124: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00005cd4 <rtems_aio_search_fd>:
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
5cd4: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_aio_request_chain *r_chain;
rtems_chain_node *node;
node = chain->first;
5cd8: e5904000 ldr r4, [r0]
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
5cdc: e5943000 ldr r3, [r4]
5ce0: e1510003 cmp r1, r3
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
5ce4: e1a05000 mov r5, r0
rtems_aio_request_chain *r_chain;
rtems_chain_node *node;
node = chain->first;
r_chain = (rtems_aio_request_chain *) node;
5ce8: e1a06004 mov r6, r4
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
5cec: da00001f ble 5d70 <rtems_aio_search_fd+0x9c>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
5cf0: e2800004 add r0, r0, #4
5cf4: ea000004 b 5d0c <rtems_aio_search_fd+0x38>
node = node->next;
5cf8: e5944000 ldr r4, [r4]
rtems_chain_node *node;
node = chain->first;
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
5cfc: e5943000 ldr r3, [r4]
5d00: e1530001 cmp r3, r1
node = node->next;
r_chain = (rtems_aio_request_chain *) node;
5d04: e1a06004 mov r6, r4
rtems_chain_node *node;
node = chain->first;
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
5d08: aa000018 bge 5d70 <rtems_aio_search_fd+0x9c>
5d0c: e1540000 cmp r4, r0
5d10: 1afffff8 bne 5cf8 <rtems_aio_search_fd+0x24>
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
5d14: e3520000 cmp r2, #0
r_chain = NULL;
5d18: 01a06002 moveq r6, r2
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
5d1c: 0a000017 beq 5d80 <rtems_aio_search_fd+0xac>
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
5d20: e3a00024 mov r0, #36 ; 0x24 <== NOT EXECUTED
5d24: ebfff3b7 bl 2c08 <malloc> <== NOT EXECUTED
5d28: e1a07000 mov r7, r0 <== NOT EXECUTED
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
5d2c: e5950000 ldr r0, [r5] <== NOT EXECUTED
5d30: e2872014 add r2, r7, #20 <== NOT EXECUTED
5d34: e2851004 add r1, r5, #4 <== NOT EXECUTED
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
rtems_chain_initialize_empty (&r_chain->perfd);
5d38: e2873010 add r3, r7, #16 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
5d3c: e5872010 str r2, [r7, #16] <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
5d40: e1500001 cmp r0, r1 <== NOT EXECUTED
the_chain->permanent_null = NULL;
5d44: 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));
5d48: e1a06007 mov r6, r7 <== NOT EXECUTED
5d4c: e5872014 str r2, [r7, #20] <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
5d50: e5873018 str r3, [r7, #24] <== NOT EXECUTED
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
5d54: 0a00000b beq 5d88 <rtems_aio_search_fd+0xb4> <== 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 );
5d58: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
5d5c: e2871008 add r1, r7, #8 <== NOT EXECUTED
5d60: eb0009b5 bl 843c <_Chain_Insert> <== NOT EXECUTED
rtems_chain_prepend (chain, &r_chain->next_fd);
else
rtems_chain_insert (node->previous, &r_chain->next_fd);
r_chain->new_fd = 1;
5d64: e3a03001 mov r3, #1 <== NOT EXECUTED
5d68: e5873004 str r3, [r7, #4] <== NOT EXECUTED
5d6c: ea000003 b 5d80 <rtems_aio_search_fd+0xac> <== NOT EXECUTED
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
node = node->next;
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
5d70: e1510003 cmp r1, r3
r_chain->new_fd = 0;
5d74: 03a03000 moveq r3, #0
5d78: 05843004 streq r3, [r4, #4]
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
node = node->next;
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
5d7c: 1affffe4 bne 5d14 <rtems_aio_search_fd+0x40>
r_chain->new_fd = 1;
}
}
return r_chain;
}
5d80: e1a00006 mov r0, r6
5d84: e8bd80f0 pop {r4, r5, r6, r7, pc}
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
5d88: e1a00005 mov r0, r5 <== NOT EXECUTED
5d8c: e2871008 add r1, r7, #8 <== NOT EXECUTED
5d90: eb0009a9 bl 843c <_Chain_Insert> <== NOT EXECUTED
5d94: eafffff2 b 5d64 <rtems_aio_search_fd+0x90> <== NOT EXECUTED
00006fac <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() )
6fac: e59f3150 ldr r3, [pc, #336] ; 7104 <rtems_io_register_driver+0x158>
6fb0: e593c000 ldr ip, [r3]
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;
6fb4: e59f314c ldr r3, [pc, #332] ; 7108 <rtems_io_register_driver+0x15c>
if ( rtems_interrupt_is_in_progress() )
6fb8: 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
)
{
6fbc: e92d4030 push {r4, r5, lr}
6fc0: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
6fc4: e5930000 ldr r0, [r3]
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
6fc8: 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() )
6fcc: 18bd8030 popne {r4, r5, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
6fd0: e3520000 cmp r2, #0
6fd4: 0a00003f beq 70d8 <rtems_io_register_driver+0x12c>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
6fd8: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
6fdc: e5820000 str r0, [r2]
if ( driver_table == NULL )
6fe0: 0a00003c beq 70d8 <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;
6fe4: e591c000 ldr ip, [r1]
6fe8: e35c0000 cmp ip, #0
6fec: 0a000036 beq 70cc <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 )
6ff0: e1500004 cmp r0, r4
6ff4: 9a000027 bls 7098 <rtems_io_register_driver+0xec>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
6ff8: e59f010c ldr r0, [pc, #268] ; 710c <rtems_io_register_driver+0x160>
6ffc: e590c000 ldr ip, [r0]
7000: e28cc001 add ip, ip, #1
7004: e580c000 str ip, [r0]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
7008: e3540000 cmp r4, #0
700c: 1a000023 bne 70a0 <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;
7010: e593c000 ldr ip, [r3]
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
7014: e35c0000 cmp ip, #0
7018: 0a000030 beq 70e0 <rtems_io_register_driver+0x134>
701c: e59fe0ec ldr lr, [pc, #236] ; 7110 <rtems_io_register_driver+0x164>
7020: e59e3000 ldr r3, [lr]
7024: ea000003 b 7038 <rtems_io_register_driver+0x8c>
7028: e2844001 add r4, r4, #1
702c: e15c0004 cmp ip, r4
7030: e2833018 add r3, r3, #24
7034: 9a000005 bls 7050 <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;
7038: e5930000 ldr r0, [r3]
703c: e3500000 cmp r0, #0
7040: 1afffff8 bne 7028 <rtems_io_register_driver+0x7c>
7044: e5930004 ldr r0, [r3, #4]
7048: e3500000 cmp r0, #0
704c: 1afffff5 bne 7028 <rtems_io_register_driver+0x7c>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
7050: e15c0004 cmp ip, r4
7054: 1084c084 addne ip, r4, r4, lsl #1
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
7058: e5824000 str r4, [r2]
if ( m != n )
705c: 11a0c18c lslne ip, ip, #3
7060: 0a00001f beq 70e4 <rtems_io_register_driver+0x138>
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
7064: e59e5000 ldr r5, [lr]
7068: e1a0e001 mov lr, r1
706c: e8be000f ldm lr!, {r0, r1, r2, r3}
7070: e085c00c add ip, r5, ip
7074: e8ac000f stmia ip!, {r0, r1, r2, r3}
7078: e89e0003 ldm lr, {r0, r1}
707c: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
7080: eb0006a3 bl 8b14 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
7084: e3a01000 mov r1, #0
7088: e1a00004 mov r0, r4
708c: e1a02001 mov r2, r1
}
7090: e8bd4030 pop {r4, r5, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
7094: ea00210c b f4cc <rtems_io_initialize>
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
7098: e3a0000a mov r0, #10
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
709c: e8bd8030 pop {r4, r5, pc}
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
70a0: e59fe068 ldr lr, [pc, #104] ; 7110 <rtems_io_register_driver+0x164>
70a4: e59e3000 ldr r3, [lr]
70a8: e084c084 add ip, r4, r4, lsl #1
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
70ac: e793018c ldr r0, [r3, ip, lsl #3]
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
70b0: e1a0c18c lsl ip, ip, #3
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
70b4: e3500000 cmp r0, #0
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
70b8: e083300c add r3, r3, ip
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
70bc: 0a00000b beq 70f0 <rtems_io_register_driver+0x144>
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();
70c0: eb000693 bl 8b14 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
70c4: e3a0000c mov r0, #12
70c8: e8bd8030 pop {r4, r5, pc}
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
70cc: e591c004 ldr ip, [r1, #4]
70d0: e35c0000 cmp ip, #0
70d4: 1affffc5 bne 6ff0 <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;
70d8: e3a00009 mov r0, #9
70dc: e8bd8030 pop {r4, r5, pc}
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
70e0: 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();
70e4: eb00068a bl 8b14 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
70e8: e3a00005 mov r0, #5
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
70ec: e8bd8030 pop {r4, r5, pc}
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
70f0: e5933004 ldr r3, [r3, #4]
70f4: e3530000 cmp r3, #0
70f8: 1afffff0 bne 70c0 <rtems_io_register_driver+0x114>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
70fc: e5824000 str r4, [r2]
7100: eaffffd7 b 7064 <rtems_io_register_driver+0xb8>
000058fc <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
58fc: e3500001 cmp r0, #1
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
5900: e52de004 push {lr} ; (str lr, [sp, #-4]!)
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
5904: 0a00000d beq 5940 <rtems_object_get_api_class_name+0x44>
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
5908: e3500002 cmp r0, #2
590c: 0a000004 beq 5924 <rtems_object_get_api_class_name+0x28>
api_assoc = rtems_object_api_classic_assoc;
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
5910: e3500003 cmp r0, #3
api_assoc = rtems_object_api_posix_assoc;
5914: 059f003c ldreq r0, [pc, #60] ; 5958 <rtems_object_get_api_class_name+0x5c>
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 )
5918: 0a000002 beq 5928 <rtems_object_get_api_class_name+0x2c>
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
591c: e59f0038 ldr r0, [pc, #56] ; 595c <rtems_object_get_api_class_name+0x60>
5920: e49df004 pop {pc} ; (ldr pc, [sp], #4)
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;
5924: e59f0034 ldr r0, [pc, #52] ; 5960 <rtems_object_get_api_class_name+0x64>
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 );
5928: eb00133b bl a61c <rtems_assoc_ptr_by_local>
if ( class_assoc )
592c: e3500000 cmp r0, #0
return class_assoc->name;
5930: 15900000 ldrne r0, [r0]
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 )
5934: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
return class_assoc->name;
return "BAD CLASS";
5938: e59f0024 ldr r0, [pc, #36] ; 5964 <rtems_object_get_api_class_name+0x68>
}
593c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
{
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;
5940: e59f0020 ldr r0, [pc, #32] ; 5968 <rtems_object_get_api_class_name+0x6c>
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 );
5944: eb001334 bl a61c <rtems_assoc_ptr_by_local>
if ( class_assoc )
5948: e3500000 cmp r0, #0
return class_assoc->name;
594c: 15900000 ldrne r0, [r0]
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 )
5950: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
5954: eafffff7 b 5938 <rtems_object_get_api_class_name+0x3c> <== NOT EXECUTED
0000d4fc <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
d4fc: 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 )
d500: e2525000 subs r5, r2, #0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
d504: e1a04000 mov r4, r0
d508: 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;
d50c: 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 )
d510: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
d514: e59f9148 ldr r9, [pc, #328] ; d664 <rtems_task_mode+0x168>
d518: 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;
d51c: e5d7a074 ldrb sl, [r7, #116] ; 0x74
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
d520: e5978104 ldr r8, [r7, #260] ; 0x104
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
d524: 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;
d528: 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;
d52c: 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;
d530: 03a0ac01 moveq sl, #256 ; 0x100
d534: 13a0a000 movne sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
d538: e3530000 cmp r3, #0
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
d53c: 138aac02 orrne sl, sl, #512 ; 0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
d540: e35b0000 cmp fp, #0
d544: 03a0bb01 moveq fp, #1024 ; 0x400
d548: 13a0b000 movne fp, #0
old_mode |= _ISR_Get_level();
d54c: ebffee8a bl 8f7c <_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;
d550: e18bb000 orr fp, fp, r0
old_mode |= _ISR_Get_level();
d554: e18ba00a orr sl, fp, sl
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
d558: 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;
d55c: e585a000 str sl, [r5]
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
d560: 0a000003 beq d574 <rtems_task_mode+0x78>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
d564: e3140c01 tst r4, #256 ; 0x100
d568: 13a03000 movne r3, #0
d56c: 03a03001 moveq r3, #1
d570: e5c73074 strb r3, [r7, #116] ; 0x74
if ( mask & RTEMS_TIMESLICE_MASK ) {
d574: e3160c02 tst r6, #512 ; 0x200
d578: 1a000028 bne d620 <rtems_task_mode+0x124>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
d57c: e3160080 tst r6, #128 ; 0x80
d580: 1a00002f bne d644 <rtems_task_mode+0x148>
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
d584: e2166b01 ands r6, r6, #1024 ; 0x400
d588: 0a000012 beq d5d8 <rtems_task_mode+0xdc>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
d58c: 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 ) {
d590: e5d82008 ldrb r2, [r8, #8]
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
d594: 13a03000 movne r3, #0
d598: 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 ) {
d59c: e1520003 cmp r2, r3
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
d5a0: 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 ) {
d5a4: 0a00000b beq d5d8 <rtems_task_mode+0xdc>
asr->is_enabled = is_asr_enabled;
d5a8: e5c83008 strb r3, [r8, #8]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
d5ac: e10f3000 mrs r3, CPSR
d5b0: e3832080 orr r2, r3, #128 ; 0x80
d5b4: e129f002 msr CPSR_fc, r2
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
d5b8: e5981018 ldr r1, [r8, #24]
information->signals_pending = information->signals_posted;
d5bc: e5982014 ldr r2, [r8, #20]
information->signals_posted = _signals;
d5c0: 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;
d5c4: e5882018 str r2, [r8, #24]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
d5c8: e129f003 msr CPSR_fc, r3
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
d5cc: e5986014 ldr r6, [r8, #20]
d5d0: e3560000 cmp r6, #0
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
d5d4: 13a06001 movne r6, #1
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
d5d8: e59f3088 ldr r3, [pc, #136] ; d668 <rtems_task_mode+0x16c>
d5dc: e5933000 ldr r3, [r3]
d5e0: e3530003 cmp r3, #3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
d5e4: 13a00000 movne r0, #0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
d5e8: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
d5ec: e3560000 cmp r6, #0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
d5f0: e5993004 ldr r3, [r9, #4]
if ( are_signals_pending ||
d5f4: 1a000015 bne d650 <rtems_task_mode+0x154>
d5f8: e59f2064 ldr r2, [pc, #100] ; d664 <rtems_task_mode+0x168>
d5fc: e5922008 ldr r2, [r2, #8]
d600: e1530002 cmp r3, r2
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
d604: 01a00006 moveq r0, r6
d608: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
d60c: e5d33074 ldrb r3, [r3, #116] ; 0x74
d610: e3530000 cmp r3, #0
d614: 1a00000d bne d650 <rtems_task_mode+0x154>
d618: e1a00006 mov r0, r6 <== NOT EXECUTED
}
d61c: 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) ) {
d620: e2143c02 ands r3, r4, #512 ; 0x200
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
d624: 159f3040 ldrne r3, [pc, #64] ; d66c <rtems_task_mode+0x170>
d628: 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;
d62c: 13a02001 movne r2, #1
d630: 1587207c strne r2, [r7, #124] ; 0x7c
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
d634: 15873078 strne r3, [r7, #120] ; 0x78
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
d638: 0587307c streq r3, [r7, #124] ; 0x7c
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
d63c: e3160080 tst r6, #128 ; 0x80
d640: 0affffcf beq d584 <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 ) );
d644: e2040080 and r0, r4, #128 ; 0x80
d648: ebffee46 bl 8f68 <_CPU_ISR_Set_level>
d64c: eaffffcc b d584 <rtems_task_mode+0x88>
_Thread_Dispatch_necessary = true;
d650: e3a03001 mov r3, #1
d654: e5c93010 strb r3, [r9, #16]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
d658: ebffe7f4 bl 7630 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
d65c: e3a00000 mov r0, #0
d660: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
000086f4 <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
86f4: e92d4010 push {r4, lr}
86f8: e24dd004 sub sp, sp, #4
86fc: e1a04000 mov r4, r0
* * 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 );
8700: e1a00001 mov r0, r1
8704: e1a0100d mov r1, sp
8708: eb00162f bl dfcc <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
870c: e3500003 cmp r0, #3
8710: 0a000005 beq 872c <sem_timedwait+0x38>
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
8714: e1a00004 mov r0, r4 <== NOT EXECUTED
8718: e3a01000 mov r1, #0 <== NOT EXECUTED
871c: e59d2000 ldr r2, [sp] <== NOT EXECUTED
8720: eb001945 bl ec3c <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
8724: e28dd004 add sp, sp, #4
8728: e8bd8010 pop {r4, pc}
*/
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 );
872c: e1a00004 mov r0, r4
8730: e3a01001 mov r1, #1
8734: e59d2000 ldr r2, [sp]
8738: eb00193f bl ec3c <_POSIX_Semaphore_Wait_support>
873c: eafffff8 b 8724 <sem_timedwait+0x30>
00005f3c <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
5f3c: e2523000 subs r3, r2, #0
*oact = _POSIX_signals_Vectors[ sig ];
5f40: 159f20c4 ldrne r2, [pc, #196] ; 600c <sigaction+0xd0>
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
5f44: e92d4070 push {r4, r5, r6, lr}
5f48: e1a05001 mov r5, r1
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
5f4c: 10801080 addne r1, r0, r0, lsl #1
5f50: 10822101 addne r2, r2, r1, lsl #2
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
5f54: e1a04000 mov r4, r0
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
5f58: 18920007 ldmne r2, {r0, r1, r2}
5f5c: 18830007 stmne r3, {r0, r1, r2}
if ( !sig )
5f60: e3540000 cmp r4, #0
5f64: 0a000023 beq 5ff8 <sigaction+0xbc>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
5f68: e2443001 sub r3, r4, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
5f6c: e353001f cmp r3, #31
5f70: 8a000020 bhi 5ff8 <sigaction+0xbc>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
5f74: e3540009 cmp r4, #9
5f78: 0a00001e beq 5ff8 <sigaction+0xbc>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
5f7c: e3550000 cmp r5, #0
5f80: 0a00001a beq 5ff0 <sigaction+0xb4>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
5f84: e10f6000 mrs r6, CPSR
5f88: e3863080 orr r3, r6, #128 ; 0x80
5f8c: e129f003 msr CPSR_fc, r3
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
5f90: e5953008 ldr r3, [r5, #8]
5f94: e3530000 cmp r3, #0
5f98: 0a000009 beq 5fc4 <sigaction+0x88>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
5f9c: e1a00004 mov r0, r4
5fa0: eb0016ff bl bba4 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
5fa4: e59f3060 ldr r3, [pc, #96] ; 600c <sigaction+0xd0>
5fa8: e8950007 ldm r5, {r0, r1, r2}
5fac: e0844084 add r4, r4, r4, lsl #1
5fb0: e0834104 add r4, r3, r4, lsl #2
5fb4: e8840007 stm r4, {r0, r1, r2}
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
5fb8: e129f006 msr CPSR_fc, r6
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
5fbc: e3a00000 mov r0, #0
5fc0: e8bd8070 pop {r4, r5, r6, pc}
* 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 ];
5fc4: e0844084 add r4, r4, r4, lsl #1
5fc8: e59f3040 ldr r3, [pc, #64] ; 6010 <sigaction+0xd4>
5fcc: e1a04104 lsl r4, r4, #2
5fd0: e0833004 add r3, r3, r4
5fd4: e8930007 ldm r3, {r0, r1, r2}
5fd8: e59f302c ldr r3, [pc, #44] ; 600c <sigaction+0xd0>
5fdc: e0834004 add r4, r3, r4
5fe0: e8840007 stm r4, {r0, r1, r2}
5fe4: e129f006 msr CPSR_fc, r6
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
5fe8: e3a00000 mov r0, #0
5fec: e8bd8070 pop {r4, r5, r6, pc}
5ff0: e1a00005 mov r0, r5 <== NOT EXECUTED
}
5ff4: 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 );
5ff8: eb00234d bl ed34 <__errno>
5ffc: e3a03016 mov r3, #22
6000: e5803000 str r3, [r0]
6004: e3e00000 mvn r0, #0
6008: e8bd8070 pop {r4, r5, r6, pc}
000085bc <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
85bc: e92d4010 push {r4, lr}
85c0: e1a04001 mov r4, r1
int status;
status = sigtimedwait( set, NULL, NULL );
85c4: e3a01000 mov r1, #0
85c8: e1a02001 mov r2, r1
85cc: ebffff7f bl 83d0 <sigtimedwait>
if ( status != -1 ) {
85d0: e3700001 cmn r0, #1
85d4: 0a000005 beq 85f0 <sigwait+0x34>
if ( sig )
85d8: e3540000 cmp r4, #0
*sig = status;
85dc: 15840000 strne r0, [r4]
return 0;
85e0: 13a00000 movne r0, #0
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
85e4: 18bd8010 popne {r4, pc}
*sig = status;
return 0;
85e8: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
85ec: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( sig )
*sig = status;
return 0;
}
return errno;
85f0: eb0022ac bl 110a8 <__errno>
85f4: e5900000 ldr r0, [r0]
85f8: e8bd8010 pop {r4, pc}