RTEMS 4.11Annotated Report
Sat Nov 27 22:06:46 2010
a0014b6c <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
a0014b6c: 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
)
{
a0014b70: 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 ) {
a0014b74: e1520003 cmp r2, r3
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
a0014b78: e1a06000 mov r6, r0
a0014b7c: e1a0a001 mov sl, r1
a0014b80: e1a07002 mov r7, r2
a0014b84: e59d8020 ldr r8, [sp, #32]
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
a0014b88: 8a000013 bhi a0014bdc <_CORE_message_queue_Broadcast+0x70>
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
a0014b8c: e5905048 ldr r5, [r0, #72] ; 0x48
a0014b90: e3550000 cmp r5, #0
a0014b94: 0a000009 beq a0014bc0 <_CORE_message_queue_Broadcast+0x54>
*count = 0;
a0014b98: e3a00000 mov r0, #0
a0014b9c: e5880000 str r0, [r8]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
a0014ba0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
a0014ba4: e594002c ldr r0, [r4, #44] ; 0x2c
a0014ba8: e1a0100a mov r1, sl
a0014bac: e1a02007 mov r2, r7
a0014bb0: eb00224a bl a001d4e0 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
a0014bb4: e5943028 ldr r3, [r4, #40] ; 0x28
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
a0014bb8: e2855001 add r5, r5, #1
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
a0014bbc: e5837000 str r7, [r3]
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
a0014bc0: e1a00006 mov r0, r6
a0014bc4: eb000a9e bl a0017644 <_Thread_queue_Dequeue>
a0014bc8: e2504000 subs r4, r0, #0
a0014bcc: 1afffff4 bne a0014ba4 <_CORE_message_queue_Broadcast+0x38>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
a0014bd0: e5885000 str r5, [r8]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
a0014bd4: e1a00004 mov r0, r4
a0014bd8: 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;
a0014bdc: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
a0014be0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
a000dc38 <_CORE_message_queue_Initialize>:
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
a000dc38: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
a000dc3c: e3130003 tst r3, #3
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
a000dc40: e1a04000 mov r4, r0
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
a000dc44: e3a00000 mov r0, #0
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
a000dc48: e1a06002 mov r6, r2
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
a000dc4c: e5842044 str r2, [r4, #68] ; 0x44
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
a000dc50: e1a05001 mov r5, r1
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
a000dc54: e5840048 str r0, [r4, #72] ; 0x48
the_message_queue->maximum_message_size = maximum_message_size;
a000dc58: e584304c str r3, [r4, #76] ; 0x4c
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
a000dc5c: e5840060 str r0, [r4, #96] ; 0x60
the_message_queue->notify_argument = the_argument;
a000dc60: e5840064 str r0, [r4, #100] ; 0x64
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
a000dc64: 01a02003 moveq r2, r3
a000dc68: 0a000003 beq a000dc7c <_CORE_message_queue_Initialize+0x44>
allocated_message_size += sizeof(uint32_t);
a000dc6c: e2832004 add r2, r3, #4
allocated_message_size &= ~(sizeof(uint32_t) - 1);
a000dc70: e3c22003 bic r2, r2, #3
}
if (allocated_message_size < maximum_message_size)
a000dc74: e1520003 cmp r2, r3
a000dc78: 3a00001e bcc a000dcf8 <_CORE_message_queue_Initialize+0xc0>
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
a000dc7c: e2827014 add r7, r2, #20
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
a000dc80: e0000796 mul r0, r6, r7
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
a000dc84: e1500002 cmp r0, r2
a000dc88: 3a000018 bcc a000dcf0 <_CORE_message_queue_Initialize+0xb8>
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
a000dc8c: eb000b53 bl a00109e0 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
a000dc90: e3500000 cmp r0, #0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
a000dc94: e1a01000 mov r1, r0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
a000dc98: e584005c str r0, [r4, #92] ; 0x5c
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
a000dc9c: 0a000015 beq a000dcf8 <_CORE_message_queue_Initialize+0xc0>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
a000dca0: e2840068 add r0, r4, #104 ; 0x68
a000dca4: e1a02006 mov r2, r6
a000dca8: e1a03007 mov r3, r7
a000dcac: eb0014ce bl a0012fec <_Chain_Initialize>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
a000dcb0: e2843054 add r3, r4, #84 ; 0x54
head->next = tail;
a000dcb4: e5843050 str r3, [r4, #80] ; 0x50
head->previous = NULL;
a000dcb8: e3a03000 mov r3, #0
a000dcbc: e5843054 str r3, [r4, #84] ; 0x54
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
a000dcc0: e2843050 add r3, r4, #80 ; 0x50
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
a000dcc4: e5843058 str r3, [r4, #88] ; 0x58
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
a000dcc8: e5951000 ldr r1, [r5]
a000dccc: e1a00004 mov r0, r4
a000dcd0: e3a02080 mov r2, #128 ; 0x80
a000dcd4: e3510001 cmp r1, #1
a000dcd8: 13a01000 movne r1, #0
a000dcdc: 03a01001 moveq r1, #1
a000dce0: e3a03006 mov r3, #6
a000dce4: eb0008c9 bl a0010010 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
a000dce8: e3a00001 mov r0, #1
a000dcec: e8bd80f0 pop {r4, r5, r6, r7, pc}
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
a000dcf0: e3a00000 mov r0, #0 <== NOT EXECUTED
a000dcf4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
a000dcf8: e8bd80f0 pop {r4, r5, r6, r7, pc}
a0006c90 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
a0006c90: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
a0006c94: e5903014 ldr r3, [r0, #20]
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
a0006c98: e24dd030 sub sp, sp, #48 ; 0x30
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;
a0006c9c: e59f44c8 ldr r4, [pc, #1224] ; a000716c <_Heap_Walk+0x4dc>
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
a0006ca0: e58d3024 str r3, [sp, #36] ; 0x24
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
a0006ca4: e5903024 ldr r3, [r0, #36] ; 0x24
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
a0006ca8: e31200ff tst r2, #255 ; 0xff
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
a0006cac: e590c020 ldr ip, [r0, #32]
Heap_Block *const last_block = heap->last_block;
a0006cb0: e58d3028 str r3, [sp, #40] ; 0x28
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
a0006cb4: e59f34b4 ldr r3, [pc, #1204] ; a0007170 <_Heap_Walk+0x4e0>
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
a0006cb8: e1a06000 mov r6, r0
a0006cbc: e1a05001 mov r5, 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;
a0006cc0: 11a04003 movne r4, r3
if ( !_System_state_Is_up( _System_state_Get() ) ) {
a0006cc4: e59f34a8 ldr r3, [pc, #1192] ; a0007174 <_Heap_Walk+0x4e4>
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
a0006cc8: e5909010 ldr r9, [r0, #16]
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
a0006ccc: e58dc020 str ip, [sp, #32]
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() ) ) {
a0006cd0: e5933000 ldr r3, [r3]
a0006cd4: e3530003 cmp r3, #3
a0006cd8: 1a000118 bne a0007140 <_Heap_Walk+0x4b0>
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)(
a0006cdc: e59dc024 ldr ip, [sp, #36] ; 0x24
a0006ce0: e59d2020 ldr r2, [sp, #32]
a0006ce4: e58dc000 str ip, [sp]
a0006ce8: e5903018 ldr r3, [r0, #24]
a0006cec: e58d3004 str r3, [sp, #4]
a0006cf0: e590301c ldr r3, [r0, #28]
a0006cf4: e58d200c str r2, [sp, #12]
a0006cf8: e59f2478 ldr r2, [pc, #1144] ; a0007178 <_Heap_Walk+0x4e8>
a0006cfc: e58d3008 str r3, [sp, #8]
a0006d00: e59d3028 ldr r3, [sp, #40] ; 0x28
a0006d04: e58d3010 str r3, [sp, #16]
a0006d08: e5903008 ldr r3, [r0, #8]
a0006d0c: e58d3014 str r3, [sp, #20]
a0006d10: e590300c ldr r3, [r0, #12]
a0006d14: e1a00001 mov r0, r1
a0006d18: e3a01000 mov r1, #0
a0006d1c: e58d3018 str r3, [sp, #24]
a0006d20: e1a03009 mov r3, r9
a0006d24: e12fff34 blx r4
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
a0006d28: e3590000 cmp r9, #0
a0006d2c: 1a000005 bne a0006d48 <_Heap_Walk+0xb8>
(*printer)( source, true, "page size is zero\n" );
a0006d30: e1a00005 mov r0, r5
a0006d34: e3a01001 mov r1, #1
a0006d38: e59f243c ldr r2, [pc, #1084] ; a000717c <_Heap_Walk+0x4ec>
a0006d3c: e12fff34 blx r4
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a0006d40: e1a08009 mov r8, r9
a0006d44: ea0000fe b a0007144 <_Heap_Walk+0x4b4>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
a0006d48: e2198007 ands r8, r9, #7
(*printer)(
a0006d4c: 11a00005 movne r0, r5
a0006d50: 13a01001 movne r1, #1
a0006d54: 159f2424 ldrne r2, [pc, #1060] ; a0007180 <_Heap_Walk+0x4f0>
a0006d58: 11a03009 movne r3, r9
a0006d5c: 1a0000ff bne a0007160 <_Heap_Walk+0x4d0>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
a0006d60: e59d0024 ldr r0, [sp, #36] ; 0x24
a0006d64: e1a01009 mov r1, r9
a0006d68: ebffe741 bl a0000a74 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
a0006d6c: e250b000 subs fp, r0, #0
a0006d70: 0a000005 beq a0006d8c <_Heap_Walk+0xfc>
(*printer)(
a0006d74: e1a00005 mov r0, r5
a0006d78: e3a01001 mov r1, #1
a0006d7c: e59f2400 ldr r2, [pc, #1024] ; a0007184 <_Heap_Walk+0x4f4>
a0006d80: e59d3024 ldr r3, [sp, #36] ; 0x24
a0006d84: e12fff34 blx r4
a0006d88: ea0000ed b a0007144 <_Heap_Walk+0x4b4>
a0006d8c: e59dc020 ldr ip, [sp, #32]
a0006d90: e1a01009 mov r1, r9
a0006d94: e28c0008 add r0, ip, #8
a0006d98: ebffe735 bl a0000a74 <__umodsi3>
);
return false;
}
if (
a0006d9c: e250a000 subs sl, r0, #0
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
a0006da0: 11a00005 movne r0, r5
a0006da4: 13a01001 movne r1, #1
a0006da8: 159f23d8 ldrne r2, [pc, #984] ; a0007188 <_Heap_Walk+0x4f8>
a0006dac: 159d3020 ldrne r3, [sp, #32]
a0006db0: 1a0000c3 bne a00070c4 <_Heap_Walk+0x434>
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;
a0006db4: e59d2020 ldr r2, [sp, #32]
a0006db8: e5928004 ldr r8, [r2, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
a0006dbc: e2188001 ands r8, r8, #1
(*printer)(
a0006dc0: 01a00005 moveq r0, r5
a0006dc4: 03a01001 moveq r1, #1
a0006dc8: 059f23bc ldreq r2, [pc, #956] ; a000718c <_Heap_Walk+0x4fc>
a0006dcc: 0a000009 beq a0006df8 <_Heap_Walk+0x168>
- 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;
a0006dd0: e59d3028 ldr r3, [sp, #40] ; 0x28
a0006dd4: e5937004 ldr r7, [r3, #4]
a0006dd8: e3c77001 bic r7, r7, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
a0006ddc: e0837007 add r7, r3, r7
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
a0006de0: e5978004 ldr r8, [r7, #4]
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
a0006de4: e2188001 ands r8, r8, #1
a0006de8: 1a000004 bne a0006e00 <_Heap_Walk+0x170>
(*printer)(
a0006dec: e59f239c ldr r2, [pc, #924] ; a0007190 <_Heap_Walk+0x500>
a0006df0: e1a00005 mov r0, r5
a0006df4: e3a01001 mov r1, #1
a0006df8: e12fff34 blx r4
a0006dfc: ea0000d0 b a0007144 <_Heap_Walk+0x4b4>
);
return false;
}
if (
a0006e00: e59dc020 ldr ip, [sp, #32]
a0006e04: e157000c cmp r7, ip
a0006e08: 0a000005 beq a0006e24 <_Heap_Walk+0x194>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
a0006e0c: e1a00005 mov r0, r5 <== NOT EXECUTED
a0006e10: e3a01001 mov r1, #1 <== NOT EXECUTED
a0006e14: e59f2378 ldr r2, [pc, #888] ; a0007194 <_Heap_Walk+0x504> <== NOT EXECUTED
a0006e18: e12fff34 blx r4 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a0006e1c: e1a0800a mov r8, sl <== NOT EXECUTED
a0006e20: ea0000c7 b a0007144 <_Heap_Walk+0x4b4> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
a0006e24: e596b010 ldr fp, [r6, #16]
block = next_block;
} while ( block != first_block );
return true;
}
a0006e28: e5968008 ldr r8, [r6, #8]
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
a0006e2c: e1a0a006 mov sl, r6
a0006e30: ea000032 b a0006f00 <_Heap_Walk+0x270>
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;
a0006e34: e5963020 ldr r3, [r6, #32]
a0006e38: e1530008 cmp r3, r8
a0006e3c: 83a0c000 movhi ip, #0
a0006e40: 8a000003 bhi a0006e54 <_Heap_Walk+0x1c4>
a0006e44: e596c024 ldr ip, [r6, #36] ; 0x24
a0006e48: e15c0008 cmp ip, r8
a0006e4c: 33a0c000 movcc ip, #0
a0006e50: 23a0c001 movcs ip, #1
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
a0006e54: e21cc0ff ands ip, ip, #255 ; 0xff
(*printer)(
a0006e58: 01a00005 moveq r0, r5
a0006e5c: 03a01001 moveq r1, #1
a0006e60: 059f2330 ldreq r2, [pc, #816] ; a0007198 <_Heap_Walk+0x508>
a0006e64: 0a000012 beq a0006eb4 <_Heap_Walk+0x224>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
a0006e68: e2880008 add r0, r8, #8
a0006e6c: e1a0100b mov r1, fp
a0006e70: ebffe6ff bl a0000a74 <__umodsi3>
);
return false;
}
if (
a0006e74: e250c000 subs ip, r0, #0
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
a0006e78: 11a00005 movne r0, r5
a0006e7c: 13a01001 movne r1, #1
a0006e80: 159f2314 ldrne r2, [pc, #788] ; a000719c <_Heap_Walk+0x50c>
a0006e84: 11a03008 movne r3, r8
a0006e88: 1a0000b4 bne a0007160 <_Heap_Walk+0x4d0>
- 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;
a0006e8c: e5983004 ldr r3, [r8, #4]
a0006e90: e3c33001 bic r3, r3, #1
block = next_block;
} while ( block != first_block );
return true;
}
a0006e94: e0883003 add r3, r8, 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;
a0006e98: e5933004 ldr r3, [r3, #4]
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
a0006e9c: e2133001 ands r3, r3, #1
a0006ea0: e58d302c str r3, [sp, #44] ; 0x2c
a0006ea4: 0a000008 beq a0006ecc <_Heap_Walk+0x23c>
(*printer)(
a0006ea8: e59f22f0 ldr r2, [pc, #752] ; a00071a0 <_Heap_Walk+0x510>
a0006eac: e1a00005 mov r0, r5
a0006eb0: e3a01001 mov r1, #1
a0006eb4: e1a03008 mov r3, r8
a0006eb8: e58dc01c str ip, [sp, #28]
a0006ebc: e12fff34 blx r4
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a0006ec0: e59dc01c ldr ip, [sp, #28]
a0006ec4: e1a0800c mov r8, ip
a0006ec8: ea00009d b a0007144 <_Heap_Walk+0x4b4>
);
return false;
}
if ( free_block->prev != prev_block ) {
a0006ecc: e598300c ldr r3, [r8, #12]
a0006ed0: e153000a cmp r3, sl
a0006ed4: 0a000007 beq a0006ef8 <_Heap_Walk+0x268>
(*printer)(
a0006ed8: e58d3000 str r3, [sp]
a0006edc: e1a00005 mov r0, r5
a0006ee0: e1a03008 mov r3, r8
a0006ee4: e3a01001 mov r1, #1
a0006ee8: e59f22b4 ldr r2, [pc, #692] ; a00071a4 <_Heap_Walk+0x514>
a0006eec: e12fff34 blx r4
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
a0006ef0: e59d802c ldr r8, [sp, #44] ; 0x2c
a0006ef4: ea000092 b a0007144 <_Heap_Walk+0x4b4>
return false;
}
prev_block = free_block;
free_block = free_block->next;
a0006ef8: e1a0a008 mov sl, r8
a0006efc: e5988008 ldr r8, [r8, #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 ) {
a0006f00: e1580006 cmp r8, r6
a0006f04: 1affffca bne a0006e34 <_Heap_Walk+0x1a4>
a0006f08: ea000000 b a0006f10 <_Heap_Walk+0x280>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
a0006f0c: e1a07008 mov r7, r8
return true;
}
a0006f10: e5973004 ldr r3, [r7, #4]
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;
a0006f14: e5962020 ldr r2, [r6, #32]
- 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;
a0006f18: e3c3a001 bic sl, r3, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
a0006f1c: e087800a add r8, r7, sl
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
a0006f20: e1520008 cmp r2, r8
a0006f24: 83a0b000 movhi fp, #0
a0006f28: 8a000003 bhi a0006f3c <_Heap_Walk+0x2ac>
a0006f2c: e596b024 ldr fp, [r6, #36] ; 0x24
a0006f30: e15b0008 cmp fp, r8
a0006f34: 33a0b000 movcc fp, #0
a0006f38: 23a0b001 movcs fp, #1
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
a0006f3c: e21bb0ff ands fp, fp, #255 ; 0xff
a0006f40: 1a000006 bne a0006f60 <_Heap_Walk+0x2d0>
(*printer)(
a0006f44: e58d8000 str r8, [sp]
a0006f48: e1a00005 mov r0, r5
a0006f4c: e3a01001 mov r1, #1
a0006f50: e59f2250 ldr r2, [pc, #592] ; a00071a8 <_Heap_Walk+0x518>
a0006f54: e1a03007 mov r3, r7
a0006f58: e12fff34 blx r4
a0006f5c: ea000059 b a00070c8 <_Heap_Walk+0x438>
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;
a0006f60: e59d2028 ldr r2, [sp, #40] ; 0x28
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
a0006f64: e1a0000a mov r0, sl
a0006f68: e1a01009 mov r1, r9
a0006f6c: e057b002 subs fp, r7, r2
a0006f70: 13a0b001 movne fp, #1
a0006f74: e58d301c str r3, [sp, #28]
a0006f78: ebffe6bd bl a0000a74 <__umodsi3>
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
a0006f7c: e3500000 cmp r0, #0
a0006f80: e59d301c ldr r3, [sp, #28]
a0006f84: 0a000005 beq a0006fa0 <_Heap_Walk+0x310>
a0006f88: e35b0000 cmp fp, #0
(*printer)(
a0006f8c: 158da000 strne sl, [sp]
a0006f90: 11a00005 movne r0, r5
a0006f94: 13a01001 movne r1, #1
a0006f98: 159f220c ldrne r2, [pc, #524] ; a00071ac <_Heap_Walk+0x51c>
a0006f9c: 1a000013 bne a0006ff0 <_Heap_Walk+0x360>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
a0006fa0: e59dc024 ldr ip, [sp, #36] ; 0x24
a0006fa4: e15a000c cmp sl, ip
a0006fa8: 2a000008 bcs a0006fd0 <_Heap_Walk+0x340>
a0006fac: e35b0000 cmp fp, #0
a0006fb0: 0a000006 beq a0006fd0 <_Heap_Walk+0x340>
(*printer)(
a0006fb4: e88d1400 stm sp, {sl, ip}
a0006fb8: e1a00005 mov r0, r5
a0006fbc: e3a01001 mov r1, #1
a0006fc0: e59f21e8 ldr r2, [pc, #488] ; a00071b0 <_Heap_Walk+0x520>
a0006fc4: e1a03007 mov r3, r7
a0006fc8: e12fff34 blx r4
a0006fcc: ea000064 b a0007164 <_Heap_Walk+0x4d4>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
a0006fd0: e1580007 cmp r8, r7
a0006fd4: 8a000008 bhi a0006ffc <_Heap_Walk+0x36c>
a0006fd8: e35b0000 cmp fp, #0
a0006fdc: 0a000006 beq a0006ffc <_Heap_Walk+0x36c>
(*printer)(
a0006fe0: e59f21cc ldr r2, [pc, #460] ; a00071b4 <_Heap_Walk+0x524>
a0006fe4: e58d8000 str r8, [sp]
a0006fe8: e1a00005 mov r0, r5
a0006fec: e3a01001 mov r1, #1
a0006ff0: e1a03007 mov r3, r7
a0006ff4: e12fff34 blx r4
a0006ff8: ea000059 b a0007164 <_Heap_Walk+0x4d4>
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;
a0006ffc: e203b001 and fp, r3, #1
a0007000: e5983004 ldr r3, [r8, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
a0007004: e3130001 tst r3, #1
a0007008: 1a000038 bne a00070f0 <_Heap_Walk+0x460>
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 ?
a000700c: e597200c ldr r2, [r7, #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)(
a0007010: e5963008 ldr r3, [r6, #8]
block = next_block;
} while ( block != first_block );
return true;
}
a0007014: e596100c ldr r1, [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)(
a0007018: e1520003 cmp r2, r3
a000701c: 059f0194 ldreq r0, [pc, #404] ; a00071b8 <_Heap_Walk+0x528>
a0007020: 0a000003 beq a0007034 <_Heap_Walk+0x3a4>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
a0007024: e59f3190 ldr r3, [pc, #400] ; a00071bc <_Heap_Walk+0x52c>
a0007028: e1520006 cmp r2, r6
a000702c: e59f018c ldr r0, [pc, #396] ; a00071c0 <_Heap_Walk+0x530>
a0007030: 01a00003 moveq r0, r3
block->next,
block->next == last_free_block ?
a0007034: e5973008 ldr r3, [r7, #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)(
a0007038: e1530001 cmp r3, r1
a000703c: 059f1180 ldreq r1, [pc, #384] ; a00071c4 <_Heap_Walk+0x534>
a0007040: 0a000003 beq a0007054 <_Heap_Walk+0x3c4>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
a0007044: e59fc17c ldr ip, [pc, #380] ; a00071c8 <_Heap_Walk+0x538>
a0007048: e1530006 cmp r3, r6
a000704c: e59f116c ldr r1, [pc, #364] ; a00071c0 <_Heap_Walk+0x530>
a0007050: 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)(
a0007054: e58d2004 str r2, [sp, #4]
a0007058: e58d0008 str r0, [sp, #8]
a000705c: e58d300c str r3, [sp, #12]
a0007060: e58d1010 str r1, [sp, #16]
a0007064: e1a03007 mov r3, r7
a0007068: e58da000 str sl, [sp]
a000706c: e1a00005 mov r0, r5
a0007070: e3a01000 mov r1, #0
a0007074: e59f2150 ldr r2, [pc, #336] ; a00071cc <_Heap_Walk+0x53c>
a0007078: e12fff34 blx r4
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
a000707c: e5983000 ldr r3, [r8]
a0007080: e15a0003 cmp sl, r3
a0007084: 0a000008 beq a00070ac <_Heap_Walk+0x41c>
(*printer)(
a0007088: e58d3004 str r3, [sp, #4]
a000708c: e58da000 str sl, [sp]
a0007090: e58d8008 str r8, [sp, #8]
a0007094: e1a00005 mov r0, r5
a0007098: e3a01001 mov r1, #1
a000709c: e59f212c ldr r2, [pc, #300] ; a00071d0 <_Heap_Walk+0x540>
a00070a0: e1a03007 mov r3, r7
a00070a4: e12fff34 blx r4
a00070a8: ea00002d b a0007164 <_Heap_Walk+0x4d4>
);
return false;
}
if ( !prev_used ) {
a00070ac: e35b0000 cmp fp, #0
a00070b0: 1a000006 bne a00070d0 <_Heap_Walk+0x440>
(*printer)(
a00070b4: e59f2118 ldr r2, [pc, #280] ; a00071d4 <_Heap_Walk+0x544>
a00070b8: e1a00005 mov r0, r5
a00070bc: e3a01001 mov r1, #1
a00070c0: e1a03007 mov r3, r7
a00070c4: e12fff34 blx r4
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
a00070c8: e1a0800b mov r8, fp
a00070cc: ea00001c b a0007144 <_Heap_Walk+0x4b4>
block = next_block;
} while ( block != first_block );
return true;
}
a00070d0: e5963008 ldr r3, [r6, #8]
a00070d4: ea000002 b a00070e4 <_Heap_Walk+0x454>
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
a00070d8: e1530007 cmp r3, r7
a00070dc: 0a000014 beq a0007134 <_Heap_Walk+0x4a4>
return true;
}
free_block = free_block->next;
a00070e0: 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 ) {
a00070e4: e1530006 cmp r3, r6
a00070e8: 1afffffa bne a00070d8 <_Heap_Walk+0x448>
a00070ec: ea000017 b a0007150 <_Heap_Walk+0x4c0>
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
a00070f0: e35b0000 cmp fp, #0
a00070f4: 0a000006 beq a0007114 <_Heap_Walk+0x484>
(*printer)(
a00070f8: e58da000 str sl, [sp]
a00070fc: e1a00005 mov r0, r5
a0007100: e3a01000 mov r1, #0
a0007104: e59f20cc ldr r2, [pc, #204] ; a00071d8 <_Heap_Walk+0x548>
a0007108: e1a03007 mov r3, r7
a000710c: e12fff34 blx r4
a0007110: ea000007 b a0007134 <_Heap_Walk+0x4a4>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
a0007114: e58da000 str sl, [sp]
a0007118: e5973000 ldr r3, [r7]
a000711c: e1a00005 mov r0, r5
a0007120: e1a0100b mov r1, fp
a0007124: e58d3004 str r3, [sp, #4]
a0007128: e59f20ac ldr r2, [pc, #172] ; a00071dc <_Heap_Walk+0x54c>
a000712c: e1a03007 mov r3, r7
a0007130: e12fff34 blx r4
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
a0007134: e59d2020 ldr r2, [sp, #32]
a0007138: e1580002 cmp r8, r2
a000713c: 1affff72 bne a0006f0c <_Heap_Walk+0x27c>
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
a0007140: e3a08001 mov r8, #1
block = next_block;
} while ( block != first_block );
return true;
}
a0007144: e1a00008 mov r0, r8
a0007148: e28dd030 add sp, sp, #48 ; 0x30
a000714c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
a0007150: e59f2088 ldr r2, [pc, #136] ; a00071e0 <_Heap_Walk+0x550>
a0007154: e1a00005 mov r0, r5
a0007158: e3a01001 mov r1, #1
a000715c: e1a03007 mov r3, r7
a0007160: e12fff34 blx r4
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
a0007164: e3a08000 mov r8, #0
a0007168: eafffff5 b a0007144 <_Heap_Walk+0x4b4>
a0005e18 <_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();
a0005e18: e59f30b4 ldr r3, [pc, #180] ; a0005ed4 <_TOD_Validate+0xbc>
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
a0005e1c: 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) ||
a0005e20: 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();
a0005e24: e593100c ldr r1, [r3, #12]
if ((!the_tod) ||
a0005e28: 0a000021 beq a0005eb4 <_TOD_Validate+0x9c>
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
a0005e2c: e59f00a4 ldr r0, [pc, #164] ; a0005ed8 <_TOD_Validate+0xc0>
a0005e30: eb004676 bl a0017810 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
a0005e34: e5943018 ldr r3, [r4, #24]
a0005e38: e1530000 cmp r3, r0
a0005e3c: 2a000020 bcs a0005ec4 <_TOD_Validate+0xac>
(the_tod->ticks >= ticks_per_second) ||
a0005e40: e5943014 ldr r3, [r4, #20]
a0005e44: e353003b cmp r3, #59 ; 0x3b
a0005e48: 8a00001d bhi a0005ec4 <_TOD_Validate+0xac>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
a0005e4c: e5943010 ldr r3, [r4, #16]
a0005e50: e353003b cmp r3, #59 ; 0x3b
a0005e54: 8a00001a bhi a0005ec4 <_TOD_Validate+0xac>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
a0005e58: e594300c ldr r3, [r4, #12]
a0005e5c: e3530017 cmp r3, #23
a0005e60: 8a000017 bhi a0005ec4 <_TOD_Validate+0xac>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
a0005e64: e5943004 ldr r3, [r4, #4]
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
a0005e68: e3530000 cmp r3, #0
a0005e6c: 0a000012 beq a0005ebc <_TOD_Validate+0xa4>
(the_tod->month == 0) ||
a0005e70: e353000c cmp r3, #12
a0005e74: 8a000012 bhi a0005ec4 <_TOD_Validate+0xac>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
a0005e78: 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) ||
a0005e7c: e59f1058 ldr r1, [pc, #88] ; a0005edc <_TOD_Validate+0xc4>
a0005e80: e1520001 cmp r2, r1
a0005e84: 9a000010 bls a0005ecc <_TOD_Validate+0xb4>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
a0005e88: e5940008 ldr r0, [r4, #8]
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
a0005e8c: e3500000 cmp r0, #0
a0005e90: 0a00000e beq a0005ed0 <_TOD_Validate+0xb8>
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
a0005e94: e3120003 tst r2, #3
a0005e98: e59f2040 ldr r2, [pc, #64] ; a0005ee0 <_TOD_Validate+0xc8>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
a0005e9c: 0283300d addeq r3, r3, #13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
a0005ea0: e7924103 ldr r4, [r2, r3, lsl #2]
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
a0005ea4: e1500004 cmp r0, r4
a0005ea8: 83a00000 movhi r0, #0
a0005eac: 93a00001 movls r0, #1
a0005eb0: 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;
a0005eb4: e1a00004 mov r0, r4 <== NOT EXECUTED
a0005eb8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
a0005ebc: e1a00003 mov r0, r3 <== NOT EXECUTED
a0005ec0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
a0005ec4: e3a00000 mov r0, #0
a0005ec8: e8bd8010 pop {r4, pc}
a0005ecc: e3a00000 mov r0, #0
if ( the_tod->day > days_in_month )
return false;
return true;
}
a0005ed0: e8bd8010 pop {r4, pc}
a000574c <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
a000574c: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
a0005750: e59f419c ldr r4, [pc, #412] ; a00058f4 <aio_cancel+0x1a8>
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
a0005754: e1a05001 mov r5, r1
a0005758: e1a07000 mov r7, r0
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
a000575c: e1a00004 mov r0, r4
a0005760: eb000413 bl a00067b4 <pthread_mutex_lock>
if (aiocbp == NULL)
a0005764: e3550000 cmp r5, #0
a0005768: 1a000035 bne a0005844 <aio_cancel+0xf8>
{
if (fcntl (fildes, F_GETFL) < 0) {
a000576c: e1a00007 mov r0, r7
a0005770: e3a01003 mov r1, #3
a0005774: eb001a1e bl a000bff4 <fcntl>
a0005778: e3500000 cmp r0, #0
a000577c: aa000004 bge a0005794 <aio_cancel+0x48>
pthread_mutex_unlock(&aio_request_queue.mutex);
a0005780: e1a00004 mov r0, r4
a0005784: eb000429 bl a0006830 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
a0005788: eb002745 bl a000f4a4 <__errno>
a000578c: e3a03009 mov r3, #9
a0005790: ea000032 b a0005860 <aio_cancel+0x114>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
a0005794: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED
a0005798: e1a01007 mov r1, r7 <== NOT EXECUTED
a000579c: e1a02005 mov r2, r5 <== NOT EXECUTED
a00057a0: eb0000a6 bl a0005a40 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
a00057a4: e2506000 subs r6, r0, #0 <== NOT EXECUTED
a00057a8: 1a00001b bne a000581c <aio_cancel+0xd0> <== NOT EXECUTED
{
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
a00057ac: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED
a00057b0: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED
a00057b4: e1520003 cmp r2, r3 <== NOT EXECUTED
a00057b8: 0a000013 beq a000580c <aio_cancel+0xc0> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
a00057bc: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED
a00057c0: e1a01007 mov r1, r7 <== NOT EXECUTED
a00057c4: e1a02006 mov r2, r6 <== NOT EXECUTED
a00057c8: eb00009c bl a0005a40 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL) {
a00057cc: e2505000 subs r5, r0, #0 <== NOT EXECUTED
a00057d0: 0a00000d beq a000580c <aio_cancel+0xc0> <== NOT EXECUTED
return AIO_ALLDONE;
}
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
pthread_mutex_destroy (&r_chain->mutex);
a00057d4: e285701c add r7, r5, #28 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
a00057d8: eb000a12 bl a0008028 <_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);
a00057dc: e1a00005 mov r0, r5 <== NOT EXECUTED
a00057e0: eb00016f bl a0005da4 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_destroy (&r_chain->mutex);
a00057e4: e1a00007 mov r0, r7 <== NOT EXECUTED
a00057e8: eb00034e bl a0006528 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->mutex);
a00057ec: e1a00007 mov r0, r7 <== NOT EXECUTED
a00057f0: eb00027d bl a00061ec <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
a00057f4: e1a00005 mov r0, r5 <== NOT EXECUTED
a00057f8: ebfff40f bl a000283c <free> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
a00057fc: e1a00004 mov r0, r4 <== NOT EXECUTED
a0005800: eb00040a bl a0006830 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_CANCELED;
a0005804: e1a05006 mov r5, r6 <== NOT EXECUTED
a0005808: ea000037 b a00058ec <aio_cancel+0x1a0> <== NOT EXECUTED
}
pthread_mutex_unlock (&aio_request_queue.mutex);
a000580c: e1a00004 mov r0, r4 <== NOT EXECUTED
a0005810: eb000406 bl a0006830 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
a0005814: e3a05002 mov r5, #2 <== NOT EXECUTED
a0005818: ea000033 b a00058ec <aio_cancel+0x1a0> <== NOT EXECUTED
}
pthread_mutex_lock (&r_chain->mutex);
a000581c: e286701c add r7, r6, #28 <== NOT EXECUTED
a0005820: e1a00007 mov r0, r7 <== NOT EXECUTED
a0005824: eb0003e2 bl a00067b4 <pthread_mutex_lock> <== NOT EXECUTED
a0005828: e1a00006 mov r0, r6 <== NOT EXECUTED
a000582c: eb0009fd bl a0008028 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
a0005830: e1a00006 mov r0, r6 <== NOT EXECUTED
a0005834: eb00015a bl a0005da4 <rtems_aio_remove_fd> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
a0005838: e1a00007 mov r0, r7 <== NOT EXECUTED
a000583c: eb0003fb bl a0006830 <pthread_mutex_unlock> <== NOT EXECUTED
a0005840: ea00001c b a00058b8 <aio_cancel+0x16c> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
}
else
{
if (aiocbp->aio_fildes != fildes) {
a0005844: e5956000 ldr r6, [r5]
a0005848: e1560007 cmp r6, r7
a000584c: 0a000006 beq a000586c <aio_cancel+0x120>
pthread_mutex_unlock (&aio_request_queue.mutex);
a0005850: e1a00004 mov r0, r4
a0005854: eb0003f5 bl a0006830 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
a0005858: eb002711 bl a000f4a4 <__errno>
a000585c: e3a03016 mov r3, #22
a0005860: e5803000 str r3, [r0]
a0005864: e3e05000 mvn r5, #0
a0005868: ea00001f b a00058ec <aio_cancel+0x1a0>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
a000586c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED
a0005870: e1a01006 mov r1, r6 <== NOT EXECUTED
a0005874: e3a02000 mov r2, #0 <== NOT EXECUTED
a0005878: eb000070 bl a0005a40 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
a000587c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
a0005880: 1a00000e bne a00058c0 <aio_cancel+0x174> <== NOT EXECUTED
if (!rtems_chain_is_empty (&aio_request_queue.idle_req))
a0005884: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED
a0005888: e2843058 add r3, r4, #88 ; 0x58 <== NOT EXECUTED
a000588c: e1520003 cmp r2, r3 <== NOT EXECUTED
a0005890: 0a00000a beq a00058c0 <aio_cancel+0x174> <== NOT EXECUTED
{
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req,
a0005894: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED
a0005898: e1a01006 mov r1, r6 <== NOT EXECUTED
a000589c: e1a02007 mov r2, r7 <== NOT EXECUTED
a00058a0: eb000066 bl a0005a40 <rtems_aio_search_fd> <== NOT EXECUTED
fildes,
0);
if (r_chain == NULL)
a00058a4: e3500000 cmp r0, #0 <== NOT EXECUTED
a00058a8: 0affffe8 beq a0005850 <aio_cancel+0x104> <== NOT EXECUTED
{
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);
a00058ac: e1a01005 mov r1, r5 <== NOT EXECUTED
a00058b0: eb00014b bl a0005de4 <rtems_aio_remove_req> <== NOT EXECUTED
a00058b4: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
a00058b8: e1a00004 mov r0, r4 <== NOT EXECUTED
a00058bc: ea000009 b a00058e8 <aio_cancel+0x19c> <== NOT EXECUTED
return result;
}
pthread_mutex_lock (&r_chain->mutex);
a00058c0: e287401c add r4, r7, #28 <== NOT EXECUTED
a00058c4: e1a00004 mov r0, r4 <== NOT EXECUTED
a00058c8: eb0003b9 bl a00067b4 <pthread_mutex_lock> <== NOT EXECUTED
result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp);
a00058cc: e1a01005 mov r1, r5 <== NOT EXECUTED
a00058d0: e1a00007 mov r0, r7 <== NOT EXECUTED
a00058d4: eb000142 bl a0005de4 <rtems_aio_remove_req> <== NOT EXECUTED
a00058d8: e1a05000 mov r5, r0 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
a00058dc: e1a00004 mov r0, r4 <== NOT EXECUTED
a00058e0: eb0003d2 bl a0006830 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
a00058e4: e59f0008 ldr r0, [pc, #8] ; a00058f4 <aio_cancel+0x1a8> <== NOT EXECUTED
a00058e8: eb0003d0 bl a0006830 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
}
return AIO_ALLDONE;
}
a00058ec: e1a00005 mov r0, r5
a00058f0: e8bd80f0 pop {r4, r5, r6, r7, pc}
a0005900 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
a0005900: e3500a02 cmp r0, #8192 ; 0x2000
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
a0005904: e92d4030 push {r4, r5, lr}
a0005908: e1a04001 mov r4, r1
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
a000590c: 13a05016 movne r5, #22
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
a0005910: 1a00000c bne a0005948 <aio_fsync+0x48>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
a0005914: e5910000 ldr r0, [r1]
a0005918: e3a01003 mov r1, #3
a000591c: eb0019b4 bl a000bff4 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
a0005920: e2000003 and r0, r0, #3
a0005924: e2400001 sub r0, r0, #1
a0005928: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
a000592c: 83a05009 movhi r5, #9
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
a0005930: 8a000004 bhi a0005948 <aio_fsync+0x48>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
a0005934: e3a00018 mov r0, #24 <== NOT EXECUTED
a0005938: ebfff535 bl a0002e14 <malloc> <== NOT EXECUTED
if (req == NULL)
a000593c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
a0005940: 1a000007 bne a0005964 <aio_fsync+0x64> <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
a0005944: e3a0500b mov r5, #11 <== NOT EXECUTED
a0005948: e3e03000 mvn r3, #0
a000594c: e5845030 str r5, [r4, #48] ; 0x30
a0005950: e5843034 str r3, [r4, #52] ; 0x34
a0005954: eb0026d2 bl a000f4a4 <__errno>
a0005958: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
a000595c: e3e00000 mvn r0, #0
a0005960: e8bd8030 pop {r4, r5, pc}
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
a0005964: e5834014 str r4, [r3, #20] <== NOT EXECUTED
req->aiocbp->aio_lio_opcode = LIO_SYNC;
a0005968: e3a03003 mov r3, #3 <== NOT EXECUTED
a000596c: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return rtems_aio_enqueue (req);
}
a0005970: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
a0005974: ea000130 b a0005e3c <rtems_aio_enqueue> <== NOT EXECUTED
a000604c <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
a000604c: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
a0006050: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
a0006054: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
a0006058: e5900000 ldr r0, [r0]
a000605c: eb0017e4 bl a000bff4 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
a0006060: e2000003 and r0, r0, #3
a0006064: e3500002 cmp r0, #2
a0006068: 13500000 cmpne r0, #0
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
a000606c: 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)))
a0006070: 1a00000d bne a00060ac <aio_read+0x60>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
a0006074: e5943014 ldr r3, [r4, #20]
a0006078: e3530000 cmp r3, #0
a000607c: 1a000007 bne a00060a0 <aio_read+0x54>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
a0006080: e5943008 ldr r3, [r4, #8]
a0006084: e3530000 cmp r3, #0
a0006088: ba000004 blt a00060a0 <aio_read+0x54>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
a000608c: e3a00018 mov r0, #24
a0006090: ebfff35f bl a0002e14 <malloc>
if (req == NULL)
a0006094: e2503000 subs r3, r0, #0
a0006098: 1a00000a bne a00060c8 <aio_read+0x7c>
a000609c: ea000001 b a00060a8 <aio_read+0x5c> <== NOT EXECUTED
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
a00060a0: e3a05016 mov r5, #22
a00060a4: ea000000 b a00060ac <aio_read+0x60>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
a00060a8: e3a0500b mov r5, #11 <== NOT EXECUTED
a00060ac: e3e03000 mvn r3, #0
a00060b0: e5845030 str r5, [r4, #48] ; 0x30
a00060b4: e5843034 str r3, [r4, #52] ; 0x34
a00060b8: eb0024f9 bl a000f4a4 <__errno>
a00060bc: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
a00060c0: e3e00000 mvn r0, #0
a00060c4: e8bd8030 pop {r4, r5, pc}
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
a00060c8: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_READ;
a00060cc: e3a03001 mov r3, #1
a00060d0: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
a00060d4: 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);
a00060d8: eaffff57 b a0005e3c <rtems_aio_enqueue>
a00060e4 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
a00060e4: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
a00060e8: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
a00060ec: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
a00060f0: e5900000 ldr r0, [r0]
a00060f4: eb0017be bl a000bff4 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
a00060f8: e2000003 and r0, r0, #3
a00060fc: e2400001 sub r0, r0, #1
a0006100: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
a0006104: 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)))
a0006108: 8a00000d bhi a0006144 <aio_write+0x60>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
a000610c: e5943014 ldr r3, [r4, #20]
a0006110: e3530000 cmp r3, #0
a0006114: 1a000007 bne a0006138 <aio_write+0x54>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
a0006118: e5943008 ldr r3, [r4, #8]
a000611c: e3530000 cmp r3, #0
a0006120: ba000004 blt a0006138 <aio_write+0x54>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
a0006124: e3a00018 mov r0, #24
a0006128: ebfff339 bl a0002e14 <malloc>
if (req == NULL)
a000612c: e2503000 subs r3, r0, #0
a0006130: 1a00000a bne a0006160 <aio_write+0x7c>
a0006134: ea000001 b a0006140 <aio_write+0x5c> <== NOT EXECUTED
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
a0006138: e3a05016 mov r5, #22
a000613c: ea000000 b a0006144 <aio_write+0x60>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
a0006140: e3a0500b mov r5, #11 <== NOT EXECUTED
a0006144: e3e03000 mvn r3, #0
a0006148: e5845030 str r5, [r4, #48] ; 0x30
a000614c: e5843034 str r3, [r4, #52] ; 0x34
a0006150: eb0024d3 bl a000f4a4 <__errno>
a0006154: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
a0006158: e3e00000 mvn r0, #0
a000615c: e8bd8030 pop {r4, r5, pc}
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
a0006160: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
a0006164: e3a03002 mov r3, #2
a0006168: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
a000616c: 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);
a0006170: eaffff31 b a0005e3c <rtems_aio_enqueue>
a000a1e0 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
a000a1e0: e3500000 cmp r0, #0
a000a1e4: 0a00000b beq a000a218 <pthread_attr_setschedpolicy+0x38>
a000a1e8: e5903000 ldr r3, [r0]
a000a1ec: e3530000 cmp r3, #0
a000a1f0: 0a000008 beq a000a218 <pthread_attr_setschedpolicy+0x38>
return EINVAL;
switch ( policy ) {
a000a1f4: e3510004 cmp r1, #4
a000a1f8: 8a000008 bhi a000a220 <pthread_attr_setschedpolicy+0x40>
a000a1fc: e3a03001 mov r3, #1
a000a200: e1a03113 lsl r3, r3, r1
a000a204: e3130017 tst r3, #23
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
a000a208: 15801014 strne r1, [r0, #20]
return 0;
a000a20c: 13a00000 movne r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
a000a210: 112fff1e bxne lr
a000a214: ea000001 b a000a220 <pthread_attr_setschedpolicy+0x40> <== NOT EXECUTED
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
a000a218: e3a00016 mov r0, #22
a000a21c: e12fff1e bx lr
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
a000a220: e3a00086 mov r0, #134 ; 0x86
}
}
a000a224: e12fff1e bx lr
a0005d14 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
a0005d14: e92d40f0 push {r4, r5, r6, r7, lr}
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Condition_variables_Default_attributes;
a0005d18: e59f50a8 ldr r5, [pc, #168] ; a0005dc8 <pthread_cond_init+0xb4>
a0005d1c: e3510000 cmp r1, #0
a0005d20: 11a05001 movne r5, r1
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
a0005d24: e5953004 ldr r3, [r5, #4]
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
a0005d28: e1a07000 mov r7, r0
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
a0005d2c: e3530001 cmp r3, #1
a0005d30: 0a000020 beq a0005db8 <pthread_cond_init+0xa4>
return EINVAL;
if ( !the_attr->is_initialized )
a0005d34: e5953000 ldr r3, [r5]
a0005d38: e3530000 cmp r3, #0
a0005d3c: 0a00001f beq a0005dc0 <pthread_cond_init+0xac>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
a0005d40: e59f3084 ldr r3, [pc, #132] ; a0005dcc <pthread_cond_init+0xb8>
a0005d44: e5932000 ldr r2, [r3]
a0005d48: e2822001 add r2, r2, #1
a0005d4c: e5832000 str r2, [r3]
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
a0005d50: e59f6078 ldr r6, [pc, #120] ; a0005dd0 <pthread_cond_init+0xbc>
a0005d54: e1a00006 mov r0, r6
a0005d58: eb00092f bl a000821c <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
a0005d5c: e2504000 subs r4, r0, #0
a0005d60: 1a000002 bne a0005d70 <pthread_cond_init+0x5c>
_Thread_Enable_dispatch();
a0005d64: eb000d05 bl a0009180 <_Thread_Enable_dispatch>
return ENOMEM;
a0005d68: e3a0000c mov r0, #12
a0005d6c: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
the_cond->process_shared = the_attr->process_shared;
a0005d70: e5953004 ldr r3, [r5, #4]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
a0005d74: e3a05000 mov r5, #0
_Thread_queue_Initialize(
a0005d78: e2840018 add r0, r4, #24
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
a0005d7c: e5843010 str r3, [r4, #16]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
a0005d80: e1a01005 mov r1, r5
a0005d84: e59f2048 ldr r2, [pc, #72] ; a0005dd4 <pthread_cond_init+0xc0>
a0005d88: e3a03074 mov r3, #116 ; 0x74
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
a0005d8c: e5845014 str r5, [r4, #20]
_Thread_queue_Initialize(
a0005d90: eb000ee6 bl a0009930 <_Thread_queue_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
a0005d94: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
a0005d98: e5943008 ldr r3, [r4, #8]
a0005d9c: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
a0005da0: e7824101 str r4, [r2, r1, lsl #2]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
a0005da4: e584500c str r5, [r4, #12]
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
a0005da8: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
a0005dac: eb000cf3 bl a0009180 <_Thread_Enable_dispatch>
return 0;
a0005db0: e1a00005 mov r0, r5
a0005db4: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
a0005db8: e3a00016 mov r0, #22 <== NOT EXECUTED
a0005dbc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( !the_attr->is_initialized )
return EINVAL;
a0005dc0: e3a00016 mov r0, #22
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
a0005dc4: e8bd80f0 pop {r4, r5, r6, r7, pc}
a000700c <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
a000700c: e3500000 cmp r0, #0
a0007010: 0a000007 beq a0007034 <pthread_mutexattr_setpshared+0x28>
a0007014: e5903000 ldr r3, [r0]
a0007018: e3530000 cmp r3, #0
a000701c: 0a000004 beq a0007034 <pthread_mutexattr_setpshared+0x28>
return EINVAL;
switch ( pshared ) {
a0007020: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
a0007024: 95801004 strls r1, [r0, #4]
return 0;
a0007028: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
a000702c: 912fff1e bxls lr
a0007030: ea000001 b a000703c <pthread_mutexattr_setpshared+0x30> <== NOT EXECUTED
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
a0007034: e3a00016 mov r0, #22
a0007038: e12fff1e bx lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
a000703c: e3a00016 mov r0, #22 <== NOT EXECUTED
}
}
a0007040: e12fff1e bx lr <== NOT EXECUTED
a0006c78 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
a0006c78: e3500000 cmp r0, #0
a0006c7c: 0a000007 beq a0006ca0 <pthread_rwlockattr_setpshared+0x28>
return EINVAL;
if ( !attr->is_initialized )
a0006c80: e5903000 ldr r3, [r0]
a0006c84: e3530000 cmp r3, #0
a0006c88: 0a000004 beq a0006ca0 <pthread_rwlockattr_setpshared+0x28>
return EINVAL;
switch ( pshared ) {
a0006c8c: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
a0006c90: 95801004 strls r1, [r0, #4]
return 0;
a0006c94: 93a00000 movls r0, #0
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
a0006c98: 912fff1e bxls lr
a0006c9c: ea000001 b a0006ca8 <pthread_rwlockattr_setpshared+0x30>
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
a0006ca0: e3a00016 mov r0, #22
a0006ca4: e12fff1e bx lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
a0006ca8: e3a00016 mov r0, #22
}
}
a0006cac: e12fff1e bx lr <== NOT EXECUTED
a0005e3c <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
a0005e3c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, 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);
a0005e40: e59f41f0 ldr r4, [pc, #496] ; a0006038 <rtems_aio_enqueue+0x1fc>
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
a0005e44: e24dd024 sub sp, sp, #36 ; 0x24
a0005e48: 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);
a0005e4c: e1a00004 mov r0, r4
a0005e50: eb000257 bl a00067b4 <pthread_mutex_lock>
if (result != 0) {
a0005e54: e2505000 subs r5, r0, #0
a0005e58: 0a000002 beq a0005e68 <rtems_aio_enqueue+0x2c>
free (req);
a0005e5c: e1a00006 mov r0, r6 <== NOT EXECUTED
a0005e60: ebfff275 bl a000283c <free> <== NOT EXECUTED
return result;
a0005e64: ea000070 b a000602c <rtems_aio_enqueue+0x1f0> <== 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);
a0005e68: eb000462 bl a0006ff8 <pthread_self>
a0005e6c: e28d101c add r1, sp, #28
a0005e70: e1a0200d mov r2, sp
a0005e74: eb000364 bl a0006c0c <pthread_getschedparam>
req->caller_thread = pthread_self ();
a0005e78: eb00045e bl a0006ff8 <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
a0005e7c: e5963014 ldr r3, [r6, #20]
a0005e80: e59d1000 ldr r1, [sp]
/* _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 ();
a0005e84: e5860010 str r0, [r6, #16]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
a0005e88: e5932014 ldr r2, [r3, #20]
a0005e8c: e0622001 rsb r2, r2, r1
a0005e90: e586200c str r2, [r6, #12]
req->policy = policy;
a0005e94: e59d201c ldr r2, [sp, #28]
a0005e98: e5862008 str r2, [r6, #8]
req->aiocbp->error_code = EINPROGRESS;
a0005e9c: e3a02077 mov r2, #119 ; 0x77
a0005ea0: e5832030 str r2, [r3, #48] ; 0x30
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
a0005ea4: e5942068 ldr r2, [r4, #104] ; 0x68
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
a0005ea8: e5835034 str r5, [r3, #52] ; 0x34
if ((aio_request_queue.idle_threads == 0) &&
a0005eac: e3520000 cmp r2, #0
a0005eb0: 1a00002e bne a0005f70 <rtems_aio_enqueue+0x134>
a0005eb4: e5942064 ldr r2, [r4, #100] ; 0x64
a0005eb8: e3520004 cmp r2, #4
a0005ebc: ca00002b bgt a0005f70 <rtems_aio_enqueue+0x134>
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);
a0005ec0: e5931000 ldr r1, [r3]
a0005ec4: e2840048 add r0, r4, #72 ; 0x48
a0005ec8: e3a02001 mov r2, #1
a0005ecc: ebfffedb bl a0005a40 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
a0005ed0: e5903018 ldr r3, [r0, #24]
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);
a0005ed4: e1a07000 mov r7, r0
a0005ed8: e2809008 add r9, r0, #8
if (r_chain->new_fd == 1) {
a0005edc: e3530001 cmp r3, #1
a0005ee0: e280801c add r8, r0, #28
a0005ee4: e280a020 add sl, r0, #32
a0005ee8: 1a000017 bne a0005f4c <rtems_aio_enqueue+0x110>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
a0005eec: e1a01006 mov r1, r6
a0005ef0: e1a00009 mov r0, r9
a0005ef4: eb000860 bl a000807c <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
a0005ef8: e1a01005 mov r1, r5
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;
a0005efc: e5875018 str r5, [r7, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
a0005f00: e1a00008 mov r0, r8
a0005f04: eb0001d7 bl a0006668 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
a0005f08: e1a01005 mov r1, r5
a0005f0c: e1a0000a mov r0, sl
a0005f10: eb0000e7 bl a00062b4 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
a0005f14: e1a03007 mov r3, r7
a0005f18: e28d0020 add r0, sp, #32
a0005f1c: e2841008 add r1, r4, #8
a0005f20: e59f2114 ldr r2, [pc, #276] ; a000603c <rtems_aio_enqueue+0x200>
a0005f24: eb0002a3 bl a00069b8 <pthread_create>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
a0005f28: e2506000 subs r6, r0, #0
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
++aio_request_queue.active_threads;
a0005f2c: 05943064 ldreq r3, [r4, #100] ; 0x64
a0005f30: 02833001 addeq r3, r3, #1
a0005f34: 05843064 streq r3, [r4, #100] ; 0x64
pthread_cond_init (&r_chain->cond, NULL);
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
a0005f38: 0a000039 beq a0006024 <rtems_aio_enqueue+0x1e8>
pthread_mutex_unlock (&aio_request_queue.mutex);
a0005f3c: e1a00004 mov r0, r4 <== NOT EXECUTED
a0005f40: eb00023a bl a0006830 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
a0005f44: e1a05006 mov r5, r6 <== NOT EXECUTED
a0005f48: ea000037 b a000602c <rtems_aio_enqueue+0x1f0> <== NOT EXECUTED
}
++aio_request_queue.active_threads;
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
a0005f4c: e1a00008 mov r0, r8
a0005f50: eb000217 bl a00067b4 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
a0005f54: e1a00009 mov r0, r9
a0005f58: e1a01006 mov r1, r6
a0005f5c: ebffff7c bl a0005d54 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
a0005f60: e1a0000a mov r0, sl
a0005f64: eb000103 bl a0006378 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
a0005f68: e1a00008 mov r0, r8
a0005f6c: ea00000e b a0005fac <rtems_aio_enqueue+0x170>
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,
a0005f70: e59f00c8 ldr r0, [pc, #200] ; a0006040 <rtems_aio_enqueue+0x204>
a0005f74: e5931000 ldr r1, [r3]
a0005f78: e3a02000 mov r2, #0
a0005f7c: ebfffeaf bl a0005a40 <rtems_aio_search_fd>
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
a0005f80: e2504000 subs r4, r0, #0
a0005f84: 0a00000a beq a0005fb4 <rtems_aio_enqueue+0x178>
{
pthread_mutex_lock (&r_chain->mutex);
a0005f88: e284701c add r7, r4, #28 <== NOT EXECUTED
a0005f8c: e1a00007 mov r0, r7 <== NOT EXECUTED
a0005f90: eb000207 bl a00067b4 <pthread_mutex_lock> <== NOT EXECUTED
rtems_aio_insert_prio (&r_chain->perfd, req);
a0005f94: e2840008 add r0, r4, #8 <== NOT EXECUTED
a0005f98: e1a01006 mov r1, r6 <== NOT EXECUTED
a0005f9c: ebffff6c bl a0005d54 <rtems_aio_insert_prio> <== NOT EXECUTED
pthread_cond_signal (&r_chain->cond);
a0005fa0: e2840020 add r0, r4, #32 <== NOT EXECUTED
a0005fa4: eb0000f3 bl a0006378 <pthread_cond_signal> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
a0005fa8: e1a00007 mov r0, r7 <== NOT EXECUTED
a0005fac: eb00021f bl a0006830 <pthread_mutex_unlock>
a0005fb0: ea00001b b a0006024 <rtems_aio_enqueue+0x1e8>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
a0005fb4: e5963014 ldr r3, [r6, #20]
a0005fb8: e59f0084 ldr r0, [pc, #132] ; a0006044 <rtems_aio_enqueue+0x208>
a0005fbc: e3a02001 mov r2, #1
a0005fc0: e5931000 ldr r1, [r3]
a0005fc4: ebfffe9d bl a0005a40 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
a0005fc8: e5903018 ldr r3, [r0, #24]
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
a0005fcc: e1a07000 mov r7, r0
a0005fd0: e2800008 add r0, r0, #8
if (r_chain->new_fd == 1) {
a0005fd4: e3530001 cmp r3, #1
a0005fd8: 1a00000f bne a000601c <rtems_aio_enqueue+0x1e0>
a0005fdc: e1a01006 mov r1, r6
a0005fe0: eb000825 bl a000807c <_Chain_Insert>
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
a0005fe4: e1a01004 mov r1, r4
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
a0005fe8: e5874018 str r4, [r7, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
a0005fec: e287001c add r0, r7, #28
a0005ff0: eb00019c bl a0006668 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
a0005ff4: e1a01004 mov r1, r4
a0005ff8: e2870020 add r0, r7, #32
a0005ffc: eb0000ac bl a00062b4 <pthread_cond_init>
pthread_cond_signal (&aio_request_queue.new_req);
a0006000: e59f0040 ldr r0, [pc, #64] ; a0006048 <rtems_aio_enqueue+0x20c>
a0006004: eb0000db bl a0006378 <pthread_cond_signal>
++aio_request_queue.idle_threads;
a0006008: e59f3028 ldr r3, [pc, #40] ; a0006038 <rtems_aio_enqueue+0x1fc>
a000600c: e5932068 ldr r2, [r3, #104] ; 0x68
a0006010: e2822001 add r2, r2, #1
a0006014: e5832068 str r2, [r3, #104] ; 0x68
a0006018: ea000001 b a0006024 <rtems_aio_enqueue+0x1e8>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
a000601c: e1a01006 mov r1, r6
a0006020: ebffff4b bl a0005d54 <rtems_aio_insert_prio>
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
a0006024: e59f000c ldr r0, [pc, #12] ; a0006038 <rtems_aio_enqueue+0x1fc>
a0006028: eb000200 bl a0006830 <pthread_mutex_unlock>
return 0;
}
a000602c: e1a00005 mov r0, r5
a0006030: e28dd024 add sp, sp, #36 ; 0x24
a0006034: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
a0005ae8 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
a0005ae8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
a0005aec: e59f6254 ldr r6, [pc, #596] ; a0005d48 <rtems_aio_handle+0x260><== NOT EXECUTED
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
a0005af0: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
a0005af4: e1a04000 mov r4, r0 <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
a0005af8: e28d7020 add r7, sp, #32 <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
a0005afc: e286b058 add fp, r6, #88 ; 0x58 <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
a0005b00: e28d9004 add r9, sp, #4 <== NOT EXECUTED
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
a0005b04: e284a01c add sl, r4, #28 <== NOT EXECUTED
a0005b08: e1a0000a mov r0, sl <== NOT EXECUTED
a0005b0c: eb000328 bl a00067b4 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
a0005b10: e2508000 subs r8, r0, #0 <== NOT EXECUTED
a0005b14: 1a000088 bne a0005d3c <rtems_aio_handle+0x254> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0005b18: e5945008 ldr r5, [r4, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
a0005b1c: e284300c add r3, r4, #12 <== NOT EXECUTED
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
a0005b20: e1550003 cmp r5, r3 <== NOT EXECUTED
a0005b24: 0a000035 beq a0005c00 <rtems_aio_handle+0x118> <== NOT EXECUTED
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
a0005b28: eb000532 bl a0006ff8 <pthread_self> <== NOT EXECUTED
a0005b2c: e28d1028 add r1, sp, #40 ; 0x28 <== NOT EXECUTED
a0005b30: e1a02009 mov r2, r9 <== NOT EXECUTED
a0005b34: eb000434 bl a0006c0c <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
a0005b38: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
a0005b3c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
a0005b40: eb00052c bl a0006ff8 <pthread_self> <== NOT EXECUTED
a0005b44: e1a02009 mov r2, r9 <== NOT EXECUTED
a0005b48: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED
a0005b4c: eb00052e bl a000700c <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
a0005b50: e1a00005 mov r0, r5 <== NOT EXECUTED
a0005b54: eb000933 bl a0008028 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
a0005b58: e1a0000a mov r0, sl <== NOT EXECUTED
a0005b5c: eb000333 bl a0006830 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
a0005b60: e5952014 ldr r2, [r5, #20] <== NOT EXECUTED
a0005b64: e592302c ldr r3, [r2, #44] ; 0x2c <== NOT EXECUTED
a0005b68: e3530002 cmp r3, #2 <== NOT EXECUTED
a0005b6c: 0a00000b beq a0005ba0 <rtems_aio_handle+0xb8> <== NOT EXECUTED
a0005b70: e3530003 cmp r3, #3 <== NOT EXECUTED
a0005b74: 0a000011 beq a0005bc0 <rtems_aio_handle+0xd8> <== NOT EXECUTED
a0005b78: e3530001 cmp r3, #1 <== NOT EXECUTED
a0005b7c: 1a000013 bne a0005bd0 <rtems_aio_handle+0xe8> <== NOT EXECUTED
case LIO_READ:
result = pread (req->aiocbp->aio_fildes,
a0005b80: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED
a0005b84: e5923004 ldr r3, [r2, #4] <== NOT EXECUTED
a0005b88: e58d1000 str r1, [sp] <== NOT EXECUTED
a0005b8c: e592100c ldr r1, [r2, #12] <== NOT EXECUTED
a0005b90: e5920000 ldr r0, [r2] <== NOT EXECUTED
a0005b94: e5922010 ldr r2, [r2, #16] <== NOT EXECUTED
a0005b98: eb002943 bl a00100ac <pread> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
a0005b9c: ea000009 b a0005bc8 <rtems_aio_handle+0xe0> <== NOT EXECUTED
case LIO_WRITE:
result = pwrite (req->aiocbp->aio_fildes,
a0005ba0: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED
a0005ba4: e5923004 ldr r3, [r2, #4] <== NOT EXECUTED
a0005ba8: e58d1000 str r1, [sp] <== NOT EXECUTED
a0005bac: e592100c ldr r1, [r2, #12] <== NOT EXECUTED
a0005bb0: e5920000 ldr r0, [r2] <== NOT EXECUTED
a0005bb4: e5922010 ldr r2, [r2, #16] <== NOT EXECUTED
a0005bb8: eb002983 bl a00101cc <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
a0005bbc: ea000001 b a0005bc8 <rtems_aio_handle+0xe0> <== NOT EXECUTED
case LIO_SYNC:
result = fsync (req->aiocbp->aio_fildes);
a0005bc0: e5920000 ldr r0, [r2] <== NOT EXECUTED
a0005bc4: eb00197f bl a000c1c8 <fsync> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
a0005bc8: e3700001 cmn r0, #1 <== NOT EXECUTED
a0005bcc: 1a000006 bne a0005bec <rtems_aio_handle+0x104> <== NOT EXECUTED
req->aiocbp->return_value = -1;
a0005bd0: e5955014 ldr r5, [r5, #20] <== NOT EXECUTED
a0005bd4: e3e02000 mvn r2, #0 <== NOT EXECUTED
a0005bd8: e5852034 str r2, [r5, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = errno;
a0005bdc: eb002630 bl a000f4a4 <__errno> <== NOT EXECUTED
a0005be0: e5903000 ldr r3, [r0] <== NOT EXECUTED
a0005be4: e5853030 str r3, [r5, #48] ; 0x30 <== NOT EXECUTED
a0005be8: eaffffc5 b a0005b04 <rtems_aio_handle+0x1c> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
a0005bec: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
req->aiocbp->error_code = 0;
a0005bf0: e3a02000 mov r2, #0 <== NOT EXECUTED
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
a0005bf4: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = 0;
a0005bf8: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
a0005bfc: eaffffc0 b a0005b04 <rtems_aio_handle+0x1c> <== 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);
a0005c00: e1a0000a mov r0, sl <== NOT EXECUTED
a0005c04: eb000309 bl a0006830 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
a0005c08: e59f0138 ldr r0, [pc, #312] ; a0005d48 <rtems_aio_handle+0x260><== NOT EXECUTED
a0005c0c: eb0002e8 bl a00067b4 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
a0005c10: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
a0005c14: e1530005 cmp r3, r5 <== NOT EXECUTED
a0005c18: 1affffb9 bne a0005b04 <rtems_aio_handle+0x1c> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
a0005c1c: e1a01007 mov r1, r7 <== NOT EXECUTED
a0005c20: e3a00001 mov r0, #1 <== NOT EXECUTED
a0005c24: eb000152 bl a0006174 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
a0005c28: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
a0005c2c: e2845020 add r5, r4, #32 <== NOT EXECUTED
a0005c30: e1a00005 mov r0, r5 <== 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;
a0005c34: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
a0005c38: e59f1108 ldr r1, [pc, #264] ; a0005d48 <rtems_aio_handle+0x260><== NOT EXECUTED
a0005c3c: e1a02007 mov r2, r7 <== 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;
a0005c40: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
a0005c44: e58d8024 str r8, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
a0005c48: eb0001e1 bl a00063d4 <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) {
a0005c4c: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED
a0005c50: 1affffab bne a0005b04 <rtems_aio_handle+0x1c> <== NOT EXECUTED
a0005c54: e1a00004 mov r0, r4 <== NOT EXECUTED
a0005c58: eb0008f2 bl a0008028 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
a0005c5c: e1a0000a mov r0, sl <== NOT EXECUTED
a0005c60: eb000230 bl a0006528 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
a0005c64: e1a00005 mov r0, r5 <== NOT EXECUTED
a0005c68: eb00015f bl a00061ec <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
a0005c6c: e1a00004 mov r0, r4 <== NOT EXECUTED
a0005c70: ebfff2f1 bl a000283c <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)) {
a0005c74: e5963054 ldr r3, [r6, #84] ; 0x54 <== NOT EXECUTED
a0005c78: e153000b cmp r3, fp <== NOT EXECUTED
a0005c7c: 1a00002b bne a0005d30 <rtems_aio_handle+0x248> <== NOT EXECUTED
++aio_request_queue.idle_threads;
a0005c80: e5963068 ldr r3, [r6, #104] ; 0x68 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
a0005c84: e1a01007 mov r1, r7 <== NOT EXECUTED
a0005c88: e3a00001 mov r0, #1 <== 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;
a0005c8c: e2833001 add r3, r3, #1 <== NOT EXECUTED
a0005c90: e5863068 str r3, [r6, #104] ; 0x68 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
a0005c94: eb000136 bl a0006174 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
a0005c98: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
a0005c9c: e59f00a8 ldr r0, [pc, #168] ; a0005d4c <rtems_aio_handle+0x264><== NOT EXECUTED
a0005ca0: e59f10a0 ldr r1, [pc, #160] ; a0005d48 <rtems_aio_handle+0x260><== 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;
a0005ca4: e2833003 add r3, r3, #3 <== NOT EXECUTED
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
a0005ca8: e1a02007 mov r2, r7 <== NOT EXECUTED
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
++aio_request_queue.idle_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
a0005cac: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
timeout.tv_nsec = 0;
a0005cb0: e58d8024 str r8, [sp, #36] ; 0x24 <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
a0005cb4: eb0001c6 bl a00063d4 <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) {
a0005cb8: e3500074 cmp r0, #116 ; 0x74 <== NOT EXECUTED
a0005cbc: 1a000002 bne a0005ccc <rtems_aio_handle+0x1e4> <== NOT EXECUTED
pthread_mutex_unlock (&aio_request_queue.mutex);
a0005cc0: e59f0080 ldr r0, [pc, #128] ; a0005d48 <rtems_aio_handle+0x260><== NOT EXECUTED
a0005cc4: eb0002d9 bl a0006830 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
a0005cc8: ea00001b b a0005d3c <rtems_aio_handle+0x254> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0005ccc: e5965054 ldr r5, [r6, #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;
a0005cd0: e5963068 ldr r3, [r6, #104] ; 0x68 <== NOT EXECUTED
a0005cd4: e1a00005 mov r0, r5 <== NOT EXECUTED
a0005cd8: e2433001 sub r3, r3, #1 <== NOT EXECUTED
a0005cdc: e5863068 str r3, [r6, #104] ; 0x68 <== NOT EXECUTED
a0005ce0: eb0008d0 bl a0008028 <_Chain_Extract> <== NOT EXECUTED
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
a0005ce4: e3a02001 mov r2, #1 <== NOT EXECUTED
a0005ce8: e5951014 ldr r1, [r5, #20] <== NOT EXECUTED
a0005cec: e59f005c ldr r0, [pc, #92] ; a0005d50 <rtems_aio_handle+0x268><== NOT EXECUTED
a0005cf0: ebffff52 bl a0005a40 <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);
a0005cf4: e1a01008 mov r1, r8 <== NOT EXECUTED
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
a0005cf8: e1a04000 mov r4, r0 <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes,
1);
r_chain->new_fd = 0;
a0005cfc: e5808018 str r8, [r0, #24] <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
a0005d00: e280001c add r0, r0, #28 <== NOT EXECUTED
a0005d04: eb000257 bl a0006668 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
a0005d08: e2840020 add r0, r4, #32 <== NOT EXECUTED
a0005d0c: e1a01008 mov r1, r8 <== NOT EXECUTED
a0005d10: eb000167 bl a00062b4 <pthread_cond_init> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
a0005d14: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
a0005d18: e5843008 str r3, [r4, #8] <== NOT EXECUTED
a0005d1c: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
a0005d20: e584300c str r3, [r4, #12] <== NOT EXECUTED
a0005d24: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
a0005d28: e5843010 str r3, [r4, #16] <== NOT EXECUTED
a0005d2c: eaffff74 b a0005b04 <rtems_aio_handle+0x1c> <== NOT EXECUTED
}
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);
a0005d30: e59f0010 ldr r0, [pc, #16] ; a0005d48 <rtems_aio_handle+0x260><== NOT EXECUTED
a0005d34: eb0002bd bl a0006830 <pthread_mutex_unlock> <== NOT EXECUTED
a0005d38: eaffff71 b a0005b04 <rtems_aio_handle+0x1c> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0005d3c: e3a00000 mov r0, #0 <== NOT EXECUTED
a0005d40: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
a0005d44: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
a0005978 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
a0005978: e92d4010 push {r4, lr}
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
a000597c: e59f00ac ldr r0, [pc, #172] ; a0005a30 <rtems_aio_init+0xb8>
a0005980: eb0003ec bl a0006938 <pthread_attr_init>
if (result != 0)
a0005984: e2504000 subs r4, r0, #0
a0005988: 1a000026 bne a0005a28 <rtems_aio_init+0xb0>
return result;
result =
a000598c: e59f009c ldr r0, [pc, #156] ; a0005a30 <rtems_aio_init+0xb8>
a0005990: e1a01004 mov r1, r4
a0005994: eb0003f9 bl a0006980 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
a0005998: e3500000 cmp r0, #0
a000599c: 0a000001 beq a00059a8 <rtems_aio_init+0x30>
pthread_attr_destroy (&aio_request_queue.attr);
a00059a0: e59f0088 ldr r0, [pc, #136] ; a0005a30 <rtems_aio_init+0xb8><== NOT EXECUTED
a00059a4: eb0003da bl a0006914 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
a00059a8: e59f0084 ldr r0, [pc, #132] ; a0005a34 <rtems_aio_init+0xbc>
a00059ac: e3a01000 mov r1, #0
a00059b0: eb00032c bl a0006668 <pthread_mutex_init>
if (result != 0)
a00059b4: e3500000 cmp r0, #0
a00059b8: 0a000001 beq a00059c4 <rtems_aio_init+0x4c>
pthread_attr_destroy (&aio_request_queue.attr);
a00059bc: e59f006c ldr r0, [pc, #108] ; a0005a30 <rtems_aio_init+0xb8><== NOT EXECUTED
a00059c0: eb0003d3 bl a0006914 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
a00059c4: e59f006c ldr r0, [pc, #108] ; a0005a38 <rtems_aio_init+0xc0>
a00059c8: e3a01000 mov r1, #0
a00059cc: eb000238 bl a00062b4 <pthread_cond_init>
if (result != 0) {
a00059d0: e2504000 subs r4, r0, #0
a00059d4: 0a000003 beq a00059e8 <rtems_aio_init+0x70>
pthread_mutex_destroy (&aio_request_queue.mutex);
a00059d8: e59f0054 ldr r0, [pc, #84] ; a0005a34 <rtems_aio_init+0xbc><== NOT EXECUTED
a00059dc: eb0002d1 bl a0006528 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
a00059e0: e59f0048 ldr r0, [pc, #72] ; a0005a30 <rtems_aio_init+0xb8><== NOT EXECUTED
a00059e4: eb0003ca bl a0006914 <pthread_attr_destroy> <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
a00059e8: e59f3044 ldr r3, [pc, #68] ; a0005a34 <rtems_aio_init+0xbc>
a00059ec: e283204c add r2, r3, #76 ; 0x4c
a00059f0: e5832048 str r2, [r3, #72] ; 0x48
head->previous = NULL;
a00059f4: e3a02000 mov r2, #0
tail->previous = head;
a00059f8: e2831048 add r1, r3, #72 ; 0x48
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
a00059fc: e583204c str r2, [r3, #76] ; 0x4c
a0005a00: e5832058 str r2, [r3, #88] ; 0x58
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
a0005a04: e5832064 str r2, [r3, #100] ; 0x64
aio_request_queue.idle_threads = 0;
a0005a08: e5832068 str r2, [r3, #104] ; 0x68
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
a0005a0c: e59f2028 ldr r2, [pc, #40] ; a0005a3c <rtems_aio_init+0xc4>
tail->previous = head;
a0005a10: e5831050 str r1, [r3, #80] ; 0x50
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
a0005a14: e2831058 add r1, r3, #88 ; 0x58
a0005a18: e5831054 str r1, [r3, #84] ; 0x54
head->previous = NULL;
tail->previous = head;
a0005a1c: e2831054 add r1, r3, #84 ; 0x54
a0005a20: e583105c str r1, [r3, #92] ; 0x5c
a0005a24: e5832060 str r2, [r3, #96] ; 0x60
return result;
}
a0005a28: e1a00004 mov r0, r4
a0005a2c: e8bd8010 pop {r4, pc}
a0005d54 <rtems_aio_insert_prio>:
a0005d54: e1a02000 mov r2, r0
a0005d58: e4923004 ldr r3, [r2], #4
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
a0005d5c: e1a0c001 mov ip, r1
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
a0005d60: e1530002 cmp r3, r2
a0005d64: 0a00000d beq a0005da0 <rtems_aio_insert_prio+0x4c>
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;
a0005d68: e5931014 ldr r1, [r3, #20]
while (req->aiocbp->aio_reqprio > prio &&
a0005d6c: e59c0014 ldr r0, [ip, #20]
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;
a0005d70: e5911014 ldr r1, [r1, #20]
while (req->aiocbp->aio_reqprio > prio &&
a0005d74: e5900014 ldr r0, [r0, #20]
a0005d78: ea000002 b a0005d88 <rtems_aio_insert_prio+0x34>
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0005d7c: e5933000 ldr r3, [r3] <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
a0005d80: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED
a0005d84: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
a0005d88: e1500001 cmp r0, r1
a0005d8c: da000001 ble a0005d98 <rtems_aio_insert_prio+0x44>
a0005d90: e1530002 cmp r3, r2
a0005d94: 1afffff8 bne a0005d7c <rtems_aio_insert_prio+0x28>
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
a0005d98: e5930004 ldr r0, [r3, #4]
a0005d9c: e1a0100c mov r1, ip
a0005da0: ea0008b5 b a000807c <_Chain_Insert>
a0005da4 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
a0005da4: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
a0005da8: e280700c add r7, r0, #12 <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0005dac: e5904008 ldr r4, [r0, #8] <== NOT EXECUTED
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
a0005db0: e3a0608c mov r6, #140 ; 0x8c <== NOT EXECUTED
req->aiocbp->return_value = -1;
a0005db4: e3e05000 mvn r5, #0 <== NOT EXECUTED
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
a0005db8: ea000006 b a0005dd8 <rtems_aio_remove_fd+0x34> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
a0005dbc: e1a00004 mov r0, r4 <== NOT EXECUTED
a0005dc0: eb000898 bl a0008028 <_Chain_Extract> <== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
a0005dc4: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
req->aiocbp->return_value = -1;
free (req);
a0005dc8: 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;
a0005dcc: e5836030 str r6, [r3, #48] ; 0x30 <== NOT EXECUTED
req->aiocbp->return_value = -1;
a0005dd0: e5835034 str r5, [r3, #52] ; 0x34 <== NOT EXECUTED
free (req);
a0005dd4: ebfff298 bl a000283c <free> <== NOT EXECUTED
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
a0005dd8: e1540007 cmp r4, r7 <== NOT EXECUTED
a0005ddc: 1afffff6 bne a0005dbc <rtems_aio_remove_fd+0x18> <== NOT EXECUTED
rtems_aio_request *req = (rtems_aio_request *) node;
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
a0005de0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
a0005de4 <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)
{
a0005de4: e92d4010 push {r4, lr} <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0005de8: e4904004 ldr r4, [r0], #4 <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
a0005dec: ea000000 b a0005df4 <rtems_aio_remove_req+0x10> <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
a0005df0: e5944000 ldr r4, [r4] <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
a0005df4: e1540000 cmp r4, r0 <== NOT EXECUTED
a0005df8: 0a00000d beq a0005e34 <rtems_aio_remove_req+0x50> <== NOT EXECUTED
a0005dfc: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
a0005e00: e1530001 cmp r3, r1 <== NOT EXECUTED
a0005e04: 1afffff9 bne a0005df0 <rtems_aio_remove_req+0xc> <== NOT EXECUTED
a0005e08: e1a00004 mov r0, r4 <== NOT EXECUTED
a0005e0c: eb000885 bl a0008028 <_Chain_Extract> <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
a0005e10: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
a0005e14: e3a0208c mov r2, #140 ; 0x8c <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
a0005e18: e1a00004 mov r0, r4 <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
a0005e1c: e5832030 str r2, [r3, #48] ; 0x30 <== NOT EXECUTED
current->aiocbp->return_value = -1;
a0005e20: e3e02000 mvn r2, #0 <== NOT EXECUTED
a0005e24: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
free (current);
a0005e28: ebfff283 bl a000283c <free> <== NOT EXECUTED
}
return AIO_CANCELED;
a0005e2c: e3a00000 mov r0, #0 <== NOT EXECUTED
a0005e30: e8bd8010 pop {r4, pc} <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
a0005e34: e3a00001 mov r0, #1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
a0005e38: e8bd8010 pop {r4, pc} <== NOT EXECUTED
a0005b10 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
a0005b10: e92d4030 push {r4, r5, lr}
a0005b14: e1a04002 mov r4, r2
a0005b18: e1a05003 mov r5, r3
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Append_with_empty_check( chain, node );
a0005b1c: eb00013a bl a000600c <_Chain_Append_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
a0005b20: e3500000 cmp r0, #0
a0005b24: 0a000003 beq a0005b38 <rtems_chain_append_with_notification+0x28>
sc = rtems_event_send( task, events );
a0005b28: e1a00004 mov r0, r4
a0005b2c: e1a01005 mov r1, r5
}
return sc;
}
a0005b30: e8bd4030 pop {r4, r5, lr}
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
a0005b34: eafffda5 b a00051d0 <rtems_event_send>
}
return sc;
}
a0005b38: e8bd8030 pop {r4, r5, pc}
a0005bc0 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
a0005bc0: e92d4030 push {r4, r5, lr}
a0005bc4: e1a04002 mov r4, r2
a0005bc8: e1a05003 mov r5, r3
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Prepend_with_empty_check( chain, node );
a0005bcc: eb00015d bl a0006148 <_Chain_Prepend_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
a0005bd0: e3500000 cmp r0, #0
a0005bd4: 0a000003 beq a0005be8 <rtems_chain_prepend_with_notification+0x28>
sc = rtems_event_send( task, events );
a0005bd8: e1a00004 mov r0, r4
a0005bdc: e1a01005 mov r1, r5
}
return sc;
}
a0005be0: e8bd4030 pop {r4, r5, lr}
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
a0005be4: eafffd79 b a00051d0 <rtems_event_send>
}
return sc;
}
a0005be8: e8bd8030 pop {r4, r5, pc}
a0005710 <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
a0005710: e3520000 cmp r2, #0
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
a0005714: e92d40f0 push {r4, r5, r6, r7, lr}
a0005718: e1a04000 mov r4, r0
a000571c: e1a05001 mov r5, r1
ISR_Level level;
if ( oact )
a0005720: 0a00000a beq a0005750 <sigaction+0x40>
*oact = _POSIX_signals_Vectors[ sig ];
a0005724: e3a0300c mov r3, #12
a0005728: e0030394 mul r3, r4, r3
a000572c: e59f00dc ldr r0, [pc, #220] ; a0005810 <sigaction+0x100>
a0005730: e0801003 add r1, r0, r3
a0005734: e7900003 ldr r0, [r0, r3]
a0005738: e1a03002 mov r3, r2
a000573c: e4830004 str r0, [r3], #4
a0005740: e5910004 ldr r0, [r1, #4]
a0005744: e5820004 str r0, [r2, #4]
a0005748: e5912008 ldr r2, [r1, #8]
a000574c: e5832004 str r2, [r3, #4]
if ( !sig )
a0005750: e3540000 cmp r4, #0
a0005754: 0a000004 beq a000576c <sigaction+0x5c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
a0005758: e2443001 sub r3, r4, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
a000575c: e353001f cmp r3, #31
a0005760: 8a000001 bhi a000576c <sigaction+0x5c>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
a0005764: e3540009 cmp r4, #9
a0005768: 1a000004 bne a0005780 <sigaction+0x70>
rtems_set_errno_and_return_minus_one( EINVAL );
a000576c: eb00218a bl a000dd9c <__errno>
a0005770: e3a03016 mov r3, #22
a0005774: e5803000 str r3, [r0]
a0005778: e3e00000 mvn r0, #0
a000577c: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
a0005780: e3550000 cmp r5, #0
a0005784: 0a00001f beq a0005808 <sigaction+0xf8>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0005788: e10f7000 mrs r7, CPSR
a000578c: e3873080 orr r3, r7, #128 ; 0x80
a0005790: 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 ) {
a0005794: e5953008 ldr r3, [r5, #8]
a0005798: e59f6070 ldr r6, [pc, #112] ; a0005810 <sigaction+0x100>
a000579c: e3530000 cmp r3, #0
a00057a0: 1a000009 bne a00057cc <sigaction+0xbc>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
a00057a4: e283300c add r3, r3, #12
a00057a8: e0040493 mul r4, r3, r4
a00057ac: e59f1060 ldr r1, [pc, #96] ; a0005814 <sigaction+0x104>
a00057b0: e0863004 add r3, r6, r4
a00057b4: e0812004 add r2, r1, r4
a00057b8: e7911004 ldr r1, [r1, r4]
a00057bc: e7861004 str r1, [r6, r4]
a00057c0: e9920006 ldmib r2, {r1, r2}
a00057c4: e9830006 stmib r3, {r1, r2}
a00057c8: ea00000b b a00057fc <sigaction+0xec>
} else {
_POSIX_signals_Clear_process_signals( sig );
a00057cc: e1a00004 mov r0, r4
a00057d0: eb0015cd bl a000af0c <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
a00057d4: e3a0300c mov r3, #12
a00057d8: e0040493 mul r4, r3, r4
a00057dc: e1a03005 mov r3, r5
a00057e0: e4931004 ldr r1, [r3], #4
a00057e4: e0862004 add r2, r6, r4
a00057e8: e7861004 str r1, [r6, r4]
a00057ec: e5951004 ldr r1, [r5, #4]
a00057f0: e5821004 str r1, [r2, #4]
a00057f4: e5933004 ldr r3, [r3, #4]
a00057f8: e5823008 str r3, [r2, #8]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a00057fc: e129f007 msr CPSR_fc, r7
* 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;
a0005800: e3a00000 mov r0, #0
a0005804: e8bd80f0 pop {r4, r5, r6, r7, pc}
a0005808: e1a00005 mov r0, r5
}
a000580c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
a0007e20 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
a0007e20: e92d4010 push {r4, lr}
a0007e24: e1a04001 mov r4, r1
int status;
status = sigtimedwait( set, NULL, NULL );
a0007e28: e3a01000 mov r1, #0
a0007e2c: e1a02001 mov r2, r1
a0007e30: ebffff84 bl a0007c48 <sigtimedwait>
if ( status != -1 ) {
a0007e34: e3700001 cmn r0, #1
a0007e38: 0a000004 beq a0007e50 <sigwait+0x30>
if ( sig )
a0007e3c: e3540000 cmp r4, #0
a0007e40: 0a000005 beq a0007e5c <sigwait+0x3c>
*sig = status;
a0007e44: e5840000 str r0, [r4]
return 0;
a0007e48: e3a00000 mov r0, #0
a0007e4c: e8bd8010 pop {r4, pc}
}
return errno;
a0007e50: eb0020b1 bl a001011c <__errno>
a0007e54: e5900000 ldr r0, [r0]
a0007e58: e8bd8010 pop {r4, pc}
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
a0007e5c: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
a0007e60: e8bd8010 pop {r4, pc} <== NOT EXECUTED