a001537c <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
a001537c: 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
)
{
a0015380: 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 ) {
a0015384: 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
)
{
a0015388: e1a06000 mov r6, r0 a001538c: e1a07002 mov r7, r2 a0015390: e1a0a001 mov sl, r1 a0015394: 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 ) {
a0015398: 9a000001 bls a00153a4 <_CORE_message_queue_Broadcast+0x28>
a001539c: e3a00001 mov r0, #1 <== NOT EXECUTED
a00153a0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
* 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 ) {
a00153a4: e5905048 ldr r5, [r0, #72] ; 0x48 a00153a8: e3550000 cmp r5, #0
a00153ac: 0a000009 beq a00153d8 <_CORE_message_queue_Broadcast+0x5c>
*count = 0;
a00153b0: e3a00000 mov r0, #0 a00153b4: e5880000 str r0, [r8]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
a00153b8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
a00153bc: e594002c ldr r0, [r4, #44] ; 0x2c a00153c0: e1a0100a mov r1, sl a00153c4: e1a02007 mov r2, r7 a00153c8: eb0023d4 bl a001e320 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
a00153cc: 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;
a00153d0: e2855001 add r5, r5, #1
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
a00153d4: 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 =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
a00153d8: e1a00006 mov r0, r6 a00153dc: eb0009db bl a0017b50 <_Thread_queue_Dequeue>
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
a00153e0: e2504000 subs r4, r0, #0
a00153e4: 1afffff4 bne a00153bc <_CORE_message_queue_Broadcast+0x40>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
a00153e8: e5885000 str r5, [r8] a00153ec: e1a00004 mov r0, r4
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; }
a00153f0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
a000f268 <_Heap_Extend>:
Heap_Control *heap,
void *area_begin_ptr,
uintptr_t area_size,
uintptr_t *amount_extended
)
{
a000f268: e92d41f0 push {r4, r5, r6, r7, r8, lr}
a000f26c: e1a04000 mov r4, r0
Heap_Statistics *const stats = &heap->stats; uintptr_t const area_begin = (uintptr_t) area_begin_ptr; uintptr_t const heap_area_begin = heap->area_begin;
a000f270: e594c018 ldr ip, [r4, #24]
uintptr_t const heap_area_end = heap->area_end;
a000f274: e590001c ldr r0, [r0, #28]
Heap_Control *heap,
void *area_begin_ptr,
uintptr_t area_size,
uintptr_t *amount_extended
)
{
a000f278: e1a08003 mov r8, r3
uintptr_t const area_begin = (uintptr_t) area_begin_ptr; uintptr_t const heap_area_begin = heap->area_begin; uintptr_t const heap_area_end = heap->area_end; uintptr_t const new_heap_area_end = heap_area_end + area_size; uintptr_t extend_size = 0; Heap_Block *const last_block = heap->last_block;
a000f27c: e5946024 ldr r6, [r4, #36] ; 0x24
uintptr_t *amount_extended
)
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const area_begin = (uintptr_t) area_begin_ptr;
uintptr_t const heap_area_begin = heap->area_begin;
a000f280: e1510000 cmp r1, r0 a000f284: 23a05000 movcs r5, #0 a000f288: 33a05001 movcc r5, #1 a000f28c: e151000c cmp r1, ip a000f290: 33a05000 movcc r5, #0 a000f294: e3550000 cmp r5, #0
a000f298: 0a000001 beq a000f2a4 <_Heap_Extend+0x3c>
a000f29c: e3a00001 mov r0, #1
a000f2a0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* As noted, this code only supports (4).
*/
if ( area_begin >= heap_area_begin && area_begin < heap_area_end ) {
return HEAP_EXTEND_ERROR; /* case 3 */
} else if ( area_begin != heap_area_end ) {
a000f2a4: e1510000 cmp r1, r0
a000f2a8: 0a000001 beq a000f2b4 <_Heap_Extend+0x4c>
a000f2ac: e3a00002 mov r0, #2
a000f2b0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* block and free it.
*/
heap->area_end = new_heap_area_end;
extend_size = new_heap_area_end
a000f2b4: e3e07007 mvn r7, #7
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const area_begin = (uintptr_t) area_begin_ptr;
uintptr_t const heap_area_begin = heap->area_begin;
uintptr_t const heap_area_end = heap->area_end;
uintptr_t const new_heap_area_end = heap_area_end + area_size;
a000f2b8: e0821001 add r1, r2, r1
* block and free it.
*/
heap->area_end = new_heap_area_end;
extend_size = new_heap_area_end
a000f2bc: e0667007 rsb r7, r6, r7 a000f2c0: e0877001 add r7, r7, r1
* Currently only case 4 should make it to this point.
* The basic trick is to make the extend area look like a used
* block and free it.
*/
heap->area_end = new_heap_area_end;
a000f2c4: e584101c str r1, [r4, #28]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
a000f2c8: e1a00007 mov r0, r7 a000f2cc: e5941010 ldr r1, [r4, #16] a000f2d0: ebffcf49 bl a0002ffc <__umodsi3> a000f2d4: e0600007 rsb r0, r0, r7
extend_size = new_heap_area_end
- (uintptr_t) last_block - HEAP_BLOCK_HEADER_SIZE;
extend_size = _Heap_Align_down( extend_size, heap->page_size );
*amount_extended = extend_size;
a000f2d8: e5880000 str r0, [r8]
if( extend_size >= heap->min_block_size ) {
a000f2dc: e5943014 ldr r3, [r4, #20] a000f2e0: e1500003 cmp r0, r3
a000f2e4: 2a000001 bcs a000f2f0 <_Heap_Extend+0x88>
a000f2e8: e1a00005 mov r0, r5 <== NOT EXECUTED
a000f2ec: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
block->size_and_flag = size | flag;
a000f2f0: e5961004 ldr r1, [r6, #4]
Heap_Block *const new_last_block = _Heap_Block_at( last_block, extend_size );
_Heap_Block_set_size( last_block, extend_size );
new_last_block->size_and_flag =
a000f2f4: e5942020 ldr r2, [r4, #32]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
a000f2f8: e0803006 add r3, r0, r6
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
block->size_and_flag = size | flag;
a000f2fc: e2011001 and r1, r1, #1 a000f300: e0632002 rsb r2, r3, r2 a000f304: e1801001 orr r1, r0, r1 a000f308: e3822001 orr r2, r2, #1 a000f30c: e5861004 str r1, [r6, #4] a000f310: e5832004 str r2, [r3, #4]
| HEAP_PREV_BLOCK_USED;
heap->last_block = new_last_block;
/* Statistics */
stats->size += extend_size;
a000f314: e594702c ldr r7, [r4, #44] ; 0x2c
++stats->used_blocks;
a000f318: e5941040 ldr r1, [r4, #64] ; 0x40
--stats->frees; /* Do not count subsequent call as actual free() */
a000f31c: e5942050 ldr r2, [r4, #80] ; 0x50
| HEAP_PREV_BLOCK_USED;
heap->last_block = new_last_block;
/* Statistics */
stats->size += extend_size;
a000f320: e0870000 add r0, r7, r0
++stats->used_blocks;
a000f324: e2811001 add r1, r1, #1
--stats->frees; /* Do not count subsequent call as actual free() */
a000f328: e2422001 sub r2, r2, #1
| HEAP_PREV_BLOCK_USED;
heap->last_block = new_last_block;
/* Statistics */
stats->size += extend_size;
a000f32c: e584002c str r0, [r4, #44] ; 0x2c
++stats->used_blocks;
a000f330: e5841040 str r1, [r4, #64] ; 0x40
new_last_block->size_and_flag =
((uintptr_t) heap->first_block - (uintptr_t) new_last_block)
| HEAP_PREV_BLOCK_USED;
heap->last_block = new_last_block;
a000f334: e5843024 str r3, [r4, #36] ; 0x24
/* Statistics */
stats->size += extend_size;
++stats->used_blocks;
--stats->frees; /* Do not count subsequent call as actual free() */
a000f338: e5842050 str r2, [r4, #80] ; 0x50
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( last_block ));
a000f33c: e1a00004 mov r0, r4 a000f340: e2861008 add r1, r6, #8 a000f344: ebffea4a bl a0009c74 <_Heap_Free> a000f348: e1a00005 mov r0, r5
}
return HEAP_EXTEND_SUCCESSFUL;
}
a000f34c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
a0006824 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
a0006824: e92d40f0 push {r4, r5, r6, r7, lr}
a0006828: e1a06000 mov r6, r0
a000682c: e1a05001 mov r5, r1
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
a0006830: e1a00002 mov r0, r2 a0006834: e1d613ba ldrh r1, [r6, #58] ; 0x3a
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
a0006838: e1a07002 mov r7, r2
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
a000683c: eb00221e bl a000f0bc <strnlen>
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
a0006840: e5d63038 ldrb r3, [r6, #56] ; 0x38
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
a0006844: e1a04000 mov r4, r0
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
a0006848: e3530000 cmp r3, #0
a000684c: 0a000014 beq a00068a4 <_Objects_Set_name+0x80>
char *d;
d = _Workspace_Allocate( length + 1 );
a0006850: e2800001 add r0, r0, #1 a0006854: eb0006bb bl a0008348 <_Workspace_Allocate>
if ( !d )
a0006858: e2506000 subs r6, r0, #0
a000685c: 1a000001 bne a0006868 <_Objects_Set_name+0x44>
a0006860: e1a00006 mov r0, r6 <== NOT EXECUTED
a0006864: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
return false;
if ( the_object->name.name_p ) {
a0006868: e595000c ldr r0, [r5, #12] a000686c: e3500000 cmp r0, #0
a0006870: 0a000002 beq a0006880 <_Objects_Set_name+0x5c>
_Workspace_Free( (void *)the_object->name.name_p );
a0006874: eb0006b9 bl a0008360 <_Workspace_Free>
the_object->name.name_p = NULL;
a0006878: e3a03000 mov r3, #0 a000687c: e585300c str r3, [r5, #12]
}
strncpy( d, name, length );
a0006880: e1a01007 mov r1, r7 a0006884: e1a00006 mov r0, r6 a0006888: e1a02004 mov r2, r4 a000688c: eb0021d0 bl a000efd4 <strncpy>
d[length] = '\0';
a0006890: e3a03000 mov r3, #0 a0006894: e7c63004 strb r3, [r6, r4]
the_object->name.name_p = d;
a0006898: e3a00001 mov r0, #1
a000689c: e585600c str r6, [r5, #12]
a00068a0: e8bd80f0 pop {r4, r5, r6, r7, pc}
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
a00068a4: e3500001 cmp r0, #1 a00068a8: e5d70000 ldrb r0, [r7]
a00068ac: 9a00000e bls a00068ec <_Objects_Set_name+0xc8>
a00068b0: e5d71001 ldrb r1, [r7, #1] a00068b4: e3540002 cmp r4, #2 a00068b8: e1a01801 lsl r1, r1, #16
a00068bc: 9a00000b bls a00068f0 <_Objects_Set_name+0xcc>
a00068c0: e5d72002 ldrb r2, [r7, #2] a00068c4: e3540003 cmp r4, #3 a00068c8: 85d73003 ldrbhi r3, [r7, #3] a00068cc: e1a02402 lsl r2, r2, #8
a00068d0: 9a000007 bls a00068f4 <_Objects_Set_name+0xd0>
a00068d4: e1811c00 orr r1, r1, r0, lsl #24 a00068d8: e1812002 orr r2, r1, r2 a00068dc: e1823003 orr r3, r2, r3 a00068e0: e585300c str r3, [r5, #12] a00068e4: e3a00001 mov r0, #1
);
}
return true;
}
a00068e8: e8bd80f0 pop {r4, r5, r6, r7, pc}
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
a00068ec: e3a01602 mov r1, #2097152 ; 0x200000 a00068f0: e3a02a02 mov r2, #8192 ; 0x2000 a00068f4: e3a03020 mov r3, #32 a00068f8: eafffff5 b a00068d4 <_Objects_Set_name+0xb0>
a00059a8 <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
a00059a8: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr}
a00059ac: e1a04001 mov r4, r1
a00059b0: e1a06000 mov r6, r0
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
a00059b4: e1a0100d mov r1, sp a00059b8: e1a00004 mov r0, r4
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
a00059bc: e1a08002 mov r8, r2 a00059c0: e20370ff and r7, r3, #255 ; 0xff
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
a00059c4: eb000071 bl a0005b90 <_POSIX_Mutex_Get> a00059c8: e3500000 cmp r0, #0
a00059cc: 0a000032 beq a0005a9c <_POSIX_Condition_variables_Wait_support+0xf4>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
a00059d0: e59f30d0 ldr r3, [pc, #208] ; a0005aa8 <_POSIX_Condition_variables_Wait_support+0x100>
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
a00059d4: e1a0100d mov r1, sp a00059d8: e1a00006 mov r0, r6 a00059dc: e5932000 ldr r2, [r3] a00059e0: e2422001 sub r2, r2, #1 a00059e4: e5832000 str r2, [r3] a00059e8: ebffff7b bl a00057dc <_POSIX_Condition_variables_Get>
switch ( location ) {
a00059ec: e59d3000 ldr r3, [sp]
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
a00059f0: e1a0a000 mov sl, r0
switch ( location ) {
a00059f4: e3530000 cmp r3, #0
a00059f8: 1a000027 bne a0005a9c <_POSIX_Condition_variables_Wait_support+0xf4>
case OBJECTS_LOCAL:
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
a00059fc: e5903014 ldr r3, [r0, #20] a0005a00: e3530000 cmp r3, #0
a0005a04: 0a000004 beq a0005a1c <_POSIX_Condition_variables_Wait_support+0x74>
a0005a08: e5942000 ldr r2, [r4] a0005a0c: e1530002 cmp r3, r2
a0005a10: 0a000001 beq a0005a1c <_POSIX_Condition_variables_Wait_support+0x74>
_Thread_Enable_dispatch();
a0005a14: eb000bf2 bl a00089e4 <_Thread_Enable_dispatch> a0005a18: ea00001f b a0005a9c <_POSIX_Condition_variables_Wait_support+0xf4>
return EINVAL;
}
(void) pthread_mutex_unlock( mutex );
a0005a1c: e1a00004 mov r0, r4 a0005a20: eb0000e3 bl a0005db4 <pthread_mutex_unlock>
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
a0005a24: e3570000 cmp r7, #0
a0005a28: 1a000015 bne a0005a84 <_POSIX_Condition_variables_Wait_support+0xdc>
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
a0005a2c: e59f5078 ldr r5, [pc, #120] ; a0005aac <_POSIX_Condition_variables_Wait_support+0x104>
return EINVAL;
}
*/
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
a0005a30: e5941000 ldr r1, [r4]
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
a0005a34: e28a2018 add r2, sl, #24
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
a0005a38: e5953000 ldr r3, [r5]
return EINVAL;
}
*/
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
a0005a3c: e58a1014 str r1, [sl, #20]
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a0005a40: e3a00001 mov r0, #1
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
a0005a44: e5837034 str r7, [r3, #52] ; 0x34
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
_Thread_Executing->Wait.id = *cond;
a0005a48: e5961000 ldr r1, [r6]
if ( !already_timedout ) {
the_cond->Mutex = *mutex;
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
a0005a4c: e5832044 str r2, [r3, #68] ; 0x44 a0005a50: e58a0048 str r0, [sl, #72] ; 0x48
_Thread_Executing->Wait.id = *cond;
a0005a54: e5831020 str r1, [r3, #32]
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
a0005a58: e1a00002 mov r0, r2 a0005a5c: e1a01008 mov r1, r8 a0005a60: e59f2048 ldr r2, [pc, #72] ; a0005ab0 <_POSIX_Condition_variables_Wait_support+0x108> a0005a64: eb000d1a bl a0008ed4 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
a0005a68: eb000bdd bl a00089e4 <_Thread_Enable_dispatch>
/*
* Switch ourself out because we blocked as a result of the
* _Thread_queue_Enqueue.
*/
status = _Thread_Executing->Wait.return_code;
a0005a6c: e5953000 ldr r3, [r5] a0005a70: e5935034 ldr r5, [r3, #52] ; 0x34
if ( status && status != ETIMEDOUT )
a0005a74: e3550074 cmp r5, #116 ; 0x74 a0005a78: 13550000 cmpne r5, #0
a0005a7c: 0a000002 beq a0005a8c <_POSIX_Condition_variables_Wait_support+0xe4>
a0005a80: ea000006 b a0005aa0 <_POSIX_Condition_variables_Wait_support+0xf8><== NOT EXECUTED
return status;
} else {
_Thread_Enable_dispatch();
a0005a84: eb000bd6 bl a00089e4 <_Thread_Enable_dispatch> a0005a88: e3a05074 mov r5, #116 ; 0x74
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
a0005a8c: e1a00004 mov r0, r4 a0005a90: eb0000a8 bl a0005d38 <pthread_mutex_lock>
if ( mutex_status )
a0005a94: e3500000 cmp r0, #0
a0005a98: 0a000000 beq a0005aa0 <_POSIX_Condition_variables_Wait_support+0xf8>
a0005a9c: e3a05016 mov r5, #22
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
a0005aa0: e1a00005 mov r0, r5
a0005aa4: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc}
a0005aa8: a001cbac .word 0xa001cbac
a0005aac: a001cc60 .word 0xa001cc60
a0005ab0: a0009280 .word 0xa0009280
a0006e8c <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
a0006e8c: e5913014 ldr r3, [r1, #20]
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
a0006e90: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
a0006e94: e281503c add r5, r1, #60 ; 0x3c a0006e98: e5815038 str r5, [r1, #56] ; 0x38
the_chain->permanent_null = NULL;
a0006e9c: e3a05000 mov r5, #0
the_chain->last = _Chain_Head(the_chain);
a0006ea0: e281c038 add ip, r1, #56 ; 0x38
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
a0006ea4: e3130020 tst r3, #32
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
a0006ea8: e1a04323 lsr r4, r3, #6
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
a0006eac: e581503c str r5, [r1, #60] ; 0x3c a0006eb0: e285500c add r5, r5, #12
the_chain->last = _Chain_Head(the_chain);
a0006eb4: e581c040 str ip, [r1, #64] ; 0x40
block_state = the_thread_queue->state;
a0006eb8: e5907038 ldr r7, [r0, #56] ; 0x38
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
a0006ebc: e02c0495 mla ip, r5, r4, r0
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
a0006ec0: 159f8158 ldrne r8, [pc, #344] ; a0007020 <_Thread_queue_Enqueue_priority+0x194>
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
a0006ec4: 1a000023 bne a0006f58 <_Thread_queue_Enqueue_priority+0xcc>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
a0006ec8: e28c8004 add r8, ip, #4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0006ecc: e10f5000 mrs r5, CPSR a0006ed0: e3854080 orr r4, r5, #128 ; 0x80 a0006ed4: e129f004 msr CPSR_fc, r4
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
a0006ed8: e3e06000 mvn r6, #0 a0006edc: e59c4000 ldr r4, [ip]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
a0006ee0: ea00000b b a0006f14 <_Thread_queue_Enqueue_priority+0x88>
search_priority = search_thread->current_priority;
a0006ee4: e5946014 ldr r6, [r4, #20]
if ( priority <= search_priority )
a0006ee8: e1530006 cmp r3, r6
a0006eec: 9a00000a bls a0006f1c <_Thread_queue_Enqueue_priority+0x90>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
a0006ef0: e10fa000 mrs sl, CPSR a0006ef4: e129f005 msr CPSR_fc, r5 a0006ef8: e129f00a msr CPSR_fc, sl
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
a0006efc: e594a010 ldr sl, [r4, #16] a0006f00: e117000a tst r7, sl
a0006f04: 1a000001 bne a0006f10 <_Thread_queue_Enqueue_priority+0x84>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0006f08: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED a0006f0c: eaffffee b a0006ecc <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
a0006f10: e5944000 ldr r4, [r4]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
a0006f14: e1540008 cmp r4, r8
a0006f18: 1afffff1 bne a0006ee4 <_Thread_queue_Enqueue_priority+0x58>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
a0006f1c: e5907030 ldr r7, [r0, #48] ; 0x30
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
a0006f20: e1a0c005 mov ip, r5
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
a0006f24: e3570001 cmp r7, #1
a0006f28: 1a000039 bne a0007014 <_Thread_queue_Enqueue_priority+0x188>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
a0006f2c: e1530006 cmp r3, r6
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
a0006f30: e3a03000 mov r3, #0 a0006f34: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
a0006f38: 0a00002b beq a0006fec <_Thread_queue_Enqueue_priority+0x160>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
a0006f3c: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
a0006f40: e5814000 str r4, [r1]
the_node->previous = previous_node; previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
a0006f44: e5810044 str r0, [r1, #68] ; 0x44
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
a0006f48: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
a0006f4c: e5831000 str r1, [r3]
search_node->previous = the_node;
a0006f50: e5841004 str r1, [r4, #4]
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level );
a0006f54: ea000022 b a0006fe4 <_Thread_queue_Enqueue_priority+0x158>
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
a0006f58: e5d86000 ldrb r6, [r8] a0006f5c: e2866001 add r6, r6, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0006f60: e10f5000 mrs r5, CPSR a0006f64: e3854080 orr r4, r5, #128 ; 0x80 a0006f68: e129f004 msr CPSR_fc, r4
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
a0006f6c: e59c4008 ldr r4, [ip, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
a0006f70: ea00000b b a0006fa4 <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
a0006f74: e5946014 ldr r6, [r4, #20]
if ( priority >= search_priority )
a0006f78: e1530006 cmp r3, r6
a0006f7c: 2a00000a bcs a0006fac <_Thread_queue_Enqueue_priority+0x120>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
a0006f80: e10fa000 mrs sl, CPSR a0006f84: e129f005 msr CPSR_fc, r5 a0006f88: e129f00a msr CPSR_fc, sl
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
a0006f8c: e594a010 ldr sl, [r4, #16] a0006f90: e117000a tst r7, sl
a0006f94: 1a000001 bne a0006fa0 <_Thread_queue_Enqueue_priority+0x114>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0006f98: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED a0006f9c: eaffffed b a0006f58 <_Thread_queue_Enqueue_priority+0xcc> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
a0006fa0: e5944004 ldr r4, [r4, #4]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
a0006fa4: e154000c cmp r4, ip
a0006fa8: 1afffff1 bne a0006f74 <_Thread_queue_Enqueue_priority+0xe8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
a0006fac: e5907030 ldr r7, [r0, #48] ; 0x30
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
a0006fb0: e1a0c005 mov ip, r5
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
a0006fb4: e3570001 cmp r7, #1
a0006fb8: 1a000015 bne a0007014 <_Thread_queue_Enqueue_priority+0x188>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
a0006fbc: e1530006 cmp r3, r6
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
a0006fc0: e3a03000 mov r3, #0 a0006fc4: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
a0006fc8: 0a000007 beq a0006fec <_Thread_queue_Enqueue_priority+0x160>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
a0006fcc: e5943000 ldr r3, [r4]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
a0006fd0: e5814004 str r4, [r1, #4]
search_node->next = the_node; next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
a0006fd4: e5810044 str r0, [r1, #68] ; 0x44
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
a0006fd8: e5813000 str r3, [r1]
the_node->previous = search_node; search_node->next = the_node; next_node->previous = the_node;
a0006fdc: e5831004 str r1, [r3, #4]
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
a0006fe0: e5841000 str r1, [r4] a0006fe4: e129f005 msr CPSR_fc, r5 a0006fe8: ea000007 b a000700c <_Thread_queue_Enqueue_priority+0x180> a0006fec: e284403c add r4, r4, #60 ; 0x3c
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
a0006ff0: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
a0006ff4: e5814000 str r4, [r1]
the_node->previous = previous_node; previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
a0006ff8: e5810044 str r0, [r1, #68] ; 0x44
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
a0006ffc: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
a0007000: e5831000 str r1, [r3]
search_node->previous = the_node;
a0007004: e5841004 str r1, [r4, #4] a0007008: e129f00c msr CPSR_fc, ip a000700c: e3a00001 mov r0, #1
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a0007010: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
* the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state;
a0007014: e5900030 ldr r0, [r0, #48] ; 0x30
* For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level;
a0007018: e582c000 str ip, [r2]
return the_thread_queue->sync_state; }
a000701c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
a0007020: a0018630 .word 0xa0018630
a001494c <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
a001494c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
a0014950: e24dd020 sub sp, sp, #32
a0014954: e28d3014 add r3, sp, #20
a0014958: e28d5008 add r5, sp, #8
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
a001495c: e3a09000 mov r9, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
a0014960: e283a004 add sl, r3, #4 a0014964: e2858004 add r8, r5, #4
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
a0014968: e58d301c str r3, [sp, #28]
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
a001496c: e2802008 add r2, r0, #8
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
a0014970: e2803040 add r3, r0, #64 ; 0x40
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
a0014974: e1a04000 mov r4, r0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
a0014978: e58da014 str sl, [sp, #20]
the_chain->permanent_null = NULL;
a001497c: e58d9018 str r9, [sp, #24]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
a0014980: e58d8008 str r8, [sp, #8]
the_chain->permanent_null = NULL;
a0014984: e58d900c str r9, [sp, #12]
the_chain->last = _Chain_Head(the_chain);
a0014988: e58d5010 str r5, [sp, #16]
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a001498c: e280b030 add fp, r0, #48 ; 0x30
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a0014990: e2807068 add r7, r0, #104 ; 0x68
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
a0014994: e58d2004 str r2, [sp, #4]
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
a0014998: e58d3000 str r3, [sp]
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
a001499c: e28d2014 add r2, sp, #20 a00149a0: e5842078 str r2, [r4, #120] ; 0x78
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
a00149a4: e59f216c ldr r2, [pc, #364] ; a0014b18 <_Timer_server_Body+0x1cc>
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a00149a8: e1a0000b mov r0, fp
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
a00149ac: e5923000 ldr r3, [r2]
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
a00149b0: e594103c ldr r1, [r4, #60] ; 0x3c
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a00149b4: e1a02005 mov r2, r5
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
a00149b8: e584303c str r3, [r4, #60] ; 0x3c
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a00149bc: e0611003 rsb r1, r1, r3 a00149c0: eb001091 bl a0018c0c <_Watchdog_Adjust_to_chain>
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
a00149c4: e59f3150 ldr r3, [pc, #336] ; a0014b1c <_Timer_server_Body+0x1d0>
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
a00149c8: e5942074 ldr r2, [r4, #116] ; 0x74
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
a00149cc: e5936000 ldr r6, [r3]
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
a00149d0: e1560002 cmp r6, r2
a00149d4: 9a000004 bls a00149ec <_Timer_server_Body+0xa0>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a00149d8: e0621006 rsb r1, r2, r6 a00149dc: e1a00007 mov r0, r7 a00149e0: e1a02005 mov r2, r5 a00149e4: eb001088 bl a0018c0c <_Watchdog_Adjust_to_chain> a00149e8: ea000004 b a0014a00 <_Timer_server_Body+0xb4>
} else if ( snapshot < last_snapshot ) {
a00149ec: 2a000003 bcs a0014a00 <_Timer_server_Body+0xb4>
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
a00149f0: e0662002 rsb r2, r6, r2 a00149f4: e1a00007 mov r0, r7 a00149f8: e3a01001 mov r1, #1 a00149fc: eb00105a bl a0018b6c <_Watchdog_Adjust>
}
watchdogs->last_snapshot = snapshot;
a0014a00: e5846074 str r6, [r4, #116] ; 0x74
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
a0014a04: e5940078 ldr r0, [r4, #120] ; 0x78 a0014a08: eb00023f bl a001530c <_Chain_Get>
if ( timer == NULL ) {
a0014a0c: e2501000 subs r1, r0, #0
a0014a10: 0a00000a beq a0014a40 <_Timer_server_Body+0xf4>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
a0014a14: e5913038 ldr r3, [r1, #56] ; 0x38 a0014a18: e3530001 cmp r3, #1
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
a0014a1c: 02811010 addeq r1, r1, #16 a0014a20: 01a0000b moveq r0, fp
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
a0014a24: 0a000003 beq a0014a38 <_Timer_server_Body+0xec>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
a0014a28: e3530003 cmp r3, #3
a0014a2c: 1afffff4 bne a0014a04 <_Timer_server_Body+0xb8>
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
a0014a30: e2811010 add r1, r1, #16 a0014a34: e1a00007 mov r0, r7 a0014a38: eb0010a0 bl a0018cc0 <_Watchdog_Insert> a0014a3c: eafffff0 b a0014a04 <_Timer_server_Body+0xb8>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0014a40: e10f3000 mrs r3, CPSR a0014a44: e3832080 orr r2, r3, #128 ; 0x80 a0014a48: e129f002 msr CPSR_fc, r2
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
a0014a4c: e59d2014 ldr r2, [sp, #20] a0014a50: e152000a cmp r2, sl
a0014a54: 1a000005 bne a0014a70 <_Timer_server_Body+0x124>
ts->insert_chain = NULL;
a0014a58: e5841078 str r1, [r4, #120] ; 0x78
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0014a5c: e129f003 msr CPSR_fc, r3
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
a0014a60: e59d3008 ldr r3, [sp, #8] a0014a64: e1530008 cmp r3, r8
a0014a68: 1a000002 bne a0014a78 <_Timer_server_Body+0x12c>
a0014a6c: ea000015 b a0014ac8 <_Timer_server_Body+0x17c>
a0014a70: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED a0014a74: eaffffca b a00149a4 <_Timer_server_Body+0x58> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0014a78: e10f2000 mrs r2, CPSR a0014a7c: e3823080 orr r3, r2, #128 ; 0x80 a0014a80: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
a0014a84: e59d3008 ldr r3, [sp, #8]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
a0014a88: e1530008 cmp r3, r8
a0014a8c: 0a00000b beq a0014ac0 <_Timer_server_Body+0x174>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
a0014a90: e5931000 ldr r1, [r3]
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
a0014a94: e3530000 cmp r3, #0
the_chain->first = new_first;
a0014a98: e58d1008 str r1, [sp, #8]
new_first->previous = _Chain_Head(the_chain);
a0014a9c: e5815004 str r5, [r1, #4]
a0014aa0: 0a000006 beq a0014ac0 <_Timer_server_Body+0x174>
watchdog->state = WATCHDOG_INACTIVE;
a0014aa4: e5839008 str r9, [r3, #8]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0014aa8: e129f002 msr CPSR_fc, r2
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
a0014aac: e5930020 ldr r0, [r3, #32] a0014ab0: e5931024 ldr r1, [r3, #36] ; 0x24 a0014ab4: e1a0e00f mov lr, pc a0014ab8: e593f01c ldr pc, [r3, #28]
}
a0014abc: eaffffed b a0014a78 <_Timer_server_Body+0x12c> a0014ac0: e129f002 msr CPSR_fc, r2 a0014ac4: eaffffb4 b a001499c <_Timer_server_Body+0x50> a0014ac8: e59f3050 ldr r3, [pc, #80] ; a0014b20 <_Timer_server_Body+0x1d4>
} else {
ts->active = false;
a0014acc: e5c4907c strb r9, [r4, #124] ; 0x7c a0014ad0: e5932000 ldr r2, [r3] a0014ad4: e2822001 add r2, r2, #1 a0014ad8: e5832000 str r2, [r3]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
a0014adc: e3a01008 mov r1, #8 a0014ae0: e5940000 ldr r0, [r4] a0014ae4: eb000dc0 bl a00181ec <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
a0014ae8: e1a00004 mov r0, r4 a0014aec: ebffff6a bl a001489c <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
a0014af0: e1a00004 mov r0, r4 a0014af4: ebffff7e bl a00148f4 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
a0014af8: eb000b1b bl a001776c <_Thread_Enable_dispatch>
ts->active = true;
a0014afc: e3a03001 mov r3, #1 a0014b00: e5c4307c strb r3, [r4, #124] ; 0x7c
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
a0014b04: e59d0004 ldr r0, [sp, #4] a0014b08: eb0010c5 bl a0018e24 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
a0014b0c: e59d0000 ldr r0, [sp] a0014b10: eb0010c3 bl a0018e24 <_Watchdog_Remove> a0014b14: eaffffa0 b a001499c <_Timer_server_Body+0x50> a0014b18: a0039d44 .word 0xa0039d44 a0014b1c: a0039c74 .word 0xa0039c74 a0014b20: a0039bec .word 0xa0039bec
a0005260 <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
a0005260: e3520000 cmp r2, #0
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
a0005264: e92d40f0 push {r4, r5, r6, r7, lr}
a0005268: e1a04000 mov r4, r0
a000526c: e1a05001 mov r5, r1
ISR_Level level;
if ( oact )
a0005270: 0a00000a beq a00052a0 <sigaction+0x40>
*oact = _POSIX_signals_Vectors[ sig ];
a0005274: e3a0300c mov r3, #12 a0005278: e0010093 mul r1, r3, r0 a000527c: e59f00e4 ldr r0, [pc, #228] ; a0005368 <sigaction+0x108> a0005280: e1a03002 mov r3, r2 a0005284: e790c001 ldr ip, [r0, r1] a0005288: e0801001 add r1, r0, r1 a000528c: e483c004 str ip, [r3], #4 a0005290: e5910004 ldr r0, [r1, #4] a0005294: e5820004 str r0, [r2, #4] a0005298: e5912008 ldr r2, [r1, #8] a000529c: e5832004 str r2, [r3, #4]
if ( !sig )
a00052a0: e3540000 cmp r4, #0
a00052a4: 0a000004 beq a00052bc <sigaction+0x5c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
a00052a8: e2443001 sub r3, r4, #1 a00052ac: e353001f cmp r3, #31
a00052b0: 8a000001 bhi a00052bc <sigaction+0x5c>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
a00052b4: e3540009 cmp r4, #9
a00052b8: 1a000004 bne a00052d0 <sigaction+0x70>
rtems_set_errno_and_return_minus_one( EINVAL );
a00052bc: eb0022a9 bl a000dd68 <__errno>
a00052c0: e3a03016 mov r3, #22
a00052c4: e5803000 str r3, [r0]
a00052c8: e3e00000 mvn r0, #0
a00052cc: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
a00052d0: e3550000 cmp r5, #0
a00052d4: 1a000001 bne a00052e0 <sigaction+0x80>
a00052d8: e1a00005 mov r0, r5 <== NOT EXECUTED
a00052dc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a00052e0: e10f7000 mrs r7, CPSR a00052e4: e3873080 orr r3, r7, #128 ; 0x80 a00052e8: 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 ) {
a00052ec: e5953008 ldr r3, [r5, #8] a00052f0: e59f6070 ldr r6, [pc, #112] ; a0005368 <sigaction+0x108> a00052f4: e3530000 cmp r3, #0
a00052f8: 1a00000b bne a000532c <sigaction+0xcc>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
a00052fc: e3a0200c mov r2, #12 a0005300: e0030492 mul r3, r2, r4 a0005304: e59f0060 ldr r0, [pc, #96] ; a000536c <sigaction+0x10c> a0005308: e0862003 add r2, r6, r3 a000530c: e0801003 add r1, r0, r3 a0005310: e790c003 ldr ip, [r0, r3] a0005314: e5910008 ldr r0, [r1, #8] a0005318: e5911004 ldr r1, [r1, #4] a000531c: e786c003 str ip, [r6, r3] a0005320: e5820008 str r0, [r2, #8] a0005324: e5821004 str r1, [r2, #4] a0005328: ea00000b b a000535c <sigaction+0xfc>
} else {
_POSIX_signals_Clear_process_signals( sig );
a000532c: e1a00004 mov r0, r4 a0005330: eb001565 bl a000a8cc <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
a0005334: e1a03005 mov r3, r5 a0005338: e3a0200c mov r2, #12 a000533c: e4930004 ldr r0, [r3], #4 a0005340: e0010492 mul r1, r2, r4 a0005344: e7860001 str r0, [r6, r1] a0005348: e0862001 add r2, r6, r1 a000534c: e5951004 ldr r1, [r5, #4] a0005350: e5821004 str r1, [r2, #4] a0005354: e5933004 ldr r3, [r3, #4] a0005358: e5823008 str r3, [r2, #8]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a000535c: e129f007 msr CPSR_fc, r7 a0005360: e3a00000 mov r0, #0
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
}
a0005364: e8bd80f0 pop {r4, r5, r6, r7, pc}
a0005368: a001c8ac .word 0xa001c8ac
a000536c: a001b0a4 .word 0xa001b0a4