a0015330 <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
a0015330: 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
)
{
a0015334: 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 ) {
a0015338: 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
)
{
a001533c: e1a06000 mov r6, r0 a0015340: e1a07002 mov r7, r2 a0015344: e1a0a001 mov sl, r1 a0015348: 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 ) {
a001534c: 9a000001 bls a0015358 <_CORE_message_queue_Broadcast+0x28>
a0015350: e3a00001 mov r0, #1 <== NOT EXECUTED
a0015354: 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 ) {
a0015358: e5905048 ldr r5, [r0, #72] ; 0x48 a001535c: e3550000 cmp r5, #0
a0015360: 0a000009 beq a001538c <_CORE_message_queue_Broadcast+0x5c>
*count = 0;
a0015364: e3a00000 mov r0, #0 a0015368: e5880000 str r0, [r8]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
a001536c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
a0015370: e594002c ldr r0, [r4, #44] ; 0x2c a0015374: e1a0100a mov r1, sl a0015378: e1a02007 mov r2, r7 a001537c: eb001f3c bl a001d074 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
a0015380: 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;
a0015384: e2855001 add r5, r5, #1
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
a0015388: 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))) {
a001538c: e1a00006 mov r0, r6 a0015390: eb000993 bl a00179e4 <_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 =
a0015394: e2504000 subs r4, r0, #0
a0015398: 1afffff4 bne a0015370 <_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;
a001539c: e5885000 str r5, [r8] a00153a0: e1a00004 mov r0, r4
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; }
a00153a4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
a00098e0 <_CORE_mutex_Seize_interrupt_trylock>:
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
a00098e0: e59f2120 ldr r2, [pc, #288] ; a0009a08 <_CORE_mutex_Seize_interrupt_trylock+0x128>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
a00098e4: e3a03000 mov r3, #0
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
a00098e8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
a00098ec: e5922000 ldr r2, [r2]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
a00098f0: e5823034 str r3, [r2, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
a00098f4: e590c050 ldr ip, [r0, #80] ; 0x50 a00098f8: e15c0003 cmp ip, r3
a00098fc: 0a00002c beq a00099b4 <_CORE_mutex_Seize_interrupt_trylock+0xd4>
the_mutex->lock = CORE_MUTEX_LOCKED;
a0009900: e5803050 str r3, [r0, #80] ; 0x50
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
a0009904: e592c008 ldr ip, [r2, #8]
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
a0009908: e5903048 ldr r3, [r0, #72] ; 0x48
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
a000990c: e580205c str r2, [r0, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
a0009910: e580c060 str ip, [r0, #96] ; 0x60
the_mutex->nest_count = 1;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
a0009914: e3530002 cmp r3, #2
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
a0009918: e3a0c001 mov ip, #1 a000991c: e580c054 str ip, [r0, #84] ; 0x54
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
a0009920: 0a000001 beq a000992c <_CORE_mutex_Seize_interrupt_trylock+0x4c>
a0009924: e3530003 cmp r3, #3
a0009928: 1a000004 bne a0009940 <_CORE_mutex_Seize_interrupt_trylock+0x60>
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
a000992c: e592c01c ldr ip, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
a0009930: e3530003 cmp r3, #3
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
a0009934: e28c3001 add r3, ip, #1 a0009938: e582301c str r3, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
a000993c: 0a000000 beq a0009944 <_CORE_mutex_Seize_interrupt_trylock+0x64>
_ISR_Enable( *level_p );
a0009940: ea00002a b a00099f0 <_CORE_mutex_Seize_interrupt_trylock+0x110>
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
a0009944: e590304c ldr r3, [r0, #76] ; 0x4c
current = executing->current_priority;
a0009948: e592c014 ldr ip, [r2, #20]
if ( current == ceiling ) {
a000994c: e15c0003 cmp ip, r3
a0009950: 1a000000 bne a0009958 <_CORE_mutex_Seize_interrupt_trylock+0x78>
_ISR_Enable( *level_p );
a0009954: ea000025 b a00099f0 <_CORE_mutex_Seize_interrupt_trylock+0x110>
return 0;
}
if ( current > ceiling ) {
a0009958: 9a00000b bls a000998c <_CORE_mutex_Seize_interrupt_trylock+0xac>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
a000995c: e59f30a8 ldr r3, [pc, #168] ; a0009a0c <_CORE_mutex_Seize_interrupt_trylock+0x12c> a0009960: e5932000 ldr r2, [r3] a0009964: e2822001 add r2, r2, #1 a0009968: e5832000 str r2, [r3] a000996c: e5913000 ldr r3, [r1] a0009970: e129f003 msr CPSR_fc, r3
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
a0009974: e3a02000 mov r2, #0 a0009978: e590104c ldr r1, [r0, #76] ; 0x4c a000997c: e590005c ldr r0, [r0, #92] ; 0x5c a0009980: ebfff25b bl a00062f4 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
a0009984: ebfff3be bl a0006884 <_Thread_Enable_dispatch> a0009988: ea00001a b a00099f8 <_CORE_mutex_Seize_interrupt_trylock+0x118>
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
a000998c: e3a03006 mov r3, #6 a0009990: e5823034 str r3, [r2, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
the_mutex->nest_count = 0; /* undo locking above */
a0009994: e3a03000 mov r3, #0 a0009998: e5803054 str r3, [r0, #84] ; 0x54
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
the_mutex->lock = CORE_MUTEX_UNLOCKED;
a000999c: e2833001 add r3, r3, #1 a00099a0: e5803050 str r3, [r0, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
executing->resource_count--; /* undo locking above */
a00099a4: e592301c ldr r3, [r2, #28] a00099a8: e2433001 sub r3, r3, #1 a00099ac: e582301c str r3, [r2, #28]
_ISR_Enable( *level_p );
a00099b0: ea00000e b a00099f0 <_CORE_mutex_Seize_interrupt_trylock+0x110>
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
a00099b4: e590305c ldr r3, [r0, #92] ; 0x5c a00099b8: e1530002 cmp r3, r2
a00099bc: 1a00000f bne a0009a00 <_CORE_mutex_Seize_interrupt_trylock+0x120>
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
a00099c0: e5902040 ldr r2, [r0, #64] ; 0x40 a00099c4: e3520000 cmp r2, #0
a00099c8: 0a000002 beq a00099d8 <_CORE_mutex_Seize_interrupt_trylock+0xf8>
a00099cc: e3520001 cmp r2, #1
a00099d0: 1a00000a bne a0009a00 <_CORE_mutex_Seize_interrupt_trylock+0x120>
a00099d4: ea000003 b a00099e8 <_CORE_mutex_Seize_interrupt_trylock+0x108><== NOT EXECUTED
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
a00099d8: e5903054 ldr r3, [r0, #84] ; 0x54 a00099dc: e2833001 add r3, r3, #1 a00099e0: e5803054 str r3, [r0, #84] ; 0x54
_ISR_Enable( *level_p );
a00099e4: ea000001 b a00099f0 <_CORE_mutex_Seize_interrupt_trylock+0x110>
return 0;
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
a00099e8: e3a02002 mov r2, #2 <== NOT EXECUTED a00099ec: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
a00099f0: e5913000 ldr r3, [r1]
a00099f4: e129f003 msr CPSR_fc, r3
a00099f8: e3a00000 mov r0, #0
a00099fc: e49df004 pop {pc} ; (ldr pc, [sp], #4)
a0009a00: e3a00001 mov r0, #1
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
a0009a04: e49df004 pop {pc} ; (ldr pc, [sp], #4)
a000eb3c <_Heap_Extend>:
Heap_Control *heap,
void *area_begin_ptr,
uintptr_t area_size,
uintptr_t *amount_extended
)
{
a000eb3c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
a000eb40: 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;
a000eb44: e594c018 ldr ip, [r4, #24]
uintptr_t const heap_area_end = heap->area_end;
a000eb48: e590001c ldr r0, [r0, #28]
Heap_Control *heap,
void *area_begin_ptr,
uintptr_t area_size,
uintptr_t *amount_extended
)
{
a000eb4c: 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;
a000eb50: 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;
a000eb54: e1510000 cmp r1, r0 a000eb58: 23a05000 movcs r5, #0 a000eb5c: 33a05001 movcc r5, #1 a000eb60: e151000c cmp r1, ip a000eb64: 33a05000 movcc r5, #0 a000eb68: e3550000 cmp r5, #0
a000eb6c: 0a000001 beq a000eb78 <_Heap_Extend+0x3c>
a000eb70: e3a00001 mov r0, #1
a000eb74: 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 ) {
a000eb78: e1510000 cmp r1, r0
a000eb7c: 0a000001 beq a000eb88 <_Heap_Extend+0x4c>
a000eb80: e3a00002 mov r0, #2
a000eb84: 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
a000eb88: 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;
a000eb8c: e0821001 add r1, r2, r1
* block and free it.
*/
heap->area_end = new_heap_area_end;
extend_size = new_heap_area_end
a000eb90: e0667007 rsb r7, r6, r7 a000eb94: 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;
a000eb98: e584101c str r1, [r4, #28]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
a000eb9c: e1a00007 mov r0, r7 a000eba0: e5941010 ldr r1, [r4, #16] a000eba4: ebffd11f bl a0003028 <__umodsi3> a000eba8: 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;
a000ebac: e5880000 str r0, [r8]
if( extend_size >= heap->min_block_size ) {
a000ebb0: e5943014 ldr r3, [r4, #20] a000ebb4: e1500003 cmp r0, r3
a000ebb8: 2a000001 bcs a000ebc4 <_Heap_Extend+0x88>
a000ebbc: e1a00005 mov r0, r5 <== NOT EXECUTED
a000ebc0: 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;
a000ebc4: 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 =
a000ebc8: 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);
a000ebcc: 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;
a000ebd0: e2011001 and r1, r1, #1 a000ebd4: e0632002 rsb r2, r3, r2 a000ebd8: e1801001 orr r1, r0, r1 a000ebdc: e3822001 orr r2, r2, #1 a000ebe0: e5861004 str r1, [r6, #4] a000ebe4: e5832004 str r2, [r3, #4]
| HEAP_PREV_BLOCK_USED;
heap->last_block = new_last_block;
/* Statistics */
stats->size += extend_size;
a000ebe8: e594702c ldr r7, [r4, #44] ; 0x2c
++stats->used_blocks;
a000ebec: e5941040 ldr r1, [r4, #64] ; 0x40
--stats->frees; /* Do not count subsequent call as actual free() */
a000ebf0: e5942050 ldr r2, [r4, #80] ; 0x50
| HEAP_PREV_BLOCK_USED;
heap->last_block = new_last_block;
/* Statistics */
stats->size += extend_size;
a000ebf4: e0870000 add r0, r7, r0
++stats->used_blocks;
a000ebf8: e2811001 add r1, r1, #1
--stats->frees; /* Do not count subsequent call as actual free() */
a000ebfc: e2422001 sub r2, r2, #1
| HEAP_PREV_BLOCK_USED;
heap->last_block = new_last_block;
/* Statistics */
stats->size += extend_size;
a000ec00: e584002c str r0, [r4, #44] ; 0x2c
++stats->used_blocks;
a000ec04: 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;
a000ec08: e5843024 str r3, [r4, #36] ; 0x24
/* Statistics */
stats->size += extend_size;
++stats->used_blocks;
--stats->frees; /* Do not count subsequent call as actual free() */
a000ec0c: e5842050 str r2, [r4, #80] ; 0x50
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( last_block ));
a000ec10: e1a00004 mov r0, r4 a000ec14: e2861008 add r1, r6, #8 a000ec18: ebffec0d bl a0009c54 <_Heap_Free> a000ec1c: e1a00005 mov r0, r5
}
return HEAP_EXTEND_SUCCESSFUL;
}
a000ec20: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
a0006940 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
a0006940: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
a0006944: e3a05000 mov r5, #0 a0006948: e5815100 str r5, [r1, #256] ; 0x100 a000694c: e5815104 str r5, [r1, #260] ; 0x104 a0006950: e5815108 str r5, [r1, #264] ; 0x108
extensions_area = NULL;
the_thread->libc_reent = NULL;
a0006954: e58150fc str r5, [r1, #252] ; 0xfc
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
a0006958: e1a04001 mov r4, r1 a000695c: e1a0a000 mov sl, r0
/*
* Allocate and Initialize the stack for this thread.
*/
#if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
a0006960: e1a00001 mov r0, r1 a0006964: e1a01003 mov r1, r3
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
a0006968: e1a06003 mov r6, r3 a000696c: e59d7024 ldr r7, [sp, #36] ; 0x24 a0006970: e5dd9028 ldrb r9, [sp, #40] ; 0x28
/*
* Allocate and Initialize the stack for this thread.
*/
#if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
a0006974: eb00026c bl a000732c <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
a0006978: e1500005 cmp r0, r5 a000697c: 13a03000 movne r3, #0 a0006980: 03a03001 moveq r3, #1 a0006984: e1500006 cmp r0, r6 a0006988: 21a06003 movcs r6, r3 a000698c: 33836001 orrcc r6, r3, #1 a0006990: e1560005 cmp r6, r5
a0006994: 0a000001 beq a00069a0 <_Thread_Initialize+0x60>
a0006998: e1a00005 mov r0, r5
a000699c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
a00069a0: e59f2144 ldr r2, [pc, #324] ; a0006aec <_Thread_Initialize+0x1ac>
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
the_stack->size = size;
a00069a4: e58400c0 str r0, [r4, #192] ; 0xc0
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
a00069a8: e59430c8 ldr r3, [r4, #200] ; 0xc8 a00069ac: e5925000 ldr r5, [r2]
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
a00069b0: e584606c str r6, [r4, #108] ; 0x6c a00069b4: e58430c4 str r3, [r4, #196] ; 0xc4 a00069b8: e3550000 cmp r5, #0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
a00069bc: e5846050 str r6, [r4, #80] ; 0x50
the_watchdog->routine = routine;
a00069c0: e5846064 str r6, [r4, #100] ; 0x64
the_watchdog->id = id;
a00069c4: e5846068 str r6, [r4, #104] ; 0x68
a00069c8: 0a000004 beq a00069e0 <_Thread_Initialize+0xa0>
extensions_area = _Workspace_Allocate(
a00069cc: e2855001 add r5, r5, #1 a00069d0: e1a00105 lsl r0, r5, #2 a00069d4: eb00045f bl a0007b58 <_Workspace_Allocate>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
a00069d8: e2505000 subs r5, r0, #0
a00069dc: 0a00002a beq a0006a8c <_Thread_Initialize+0x14c>
* if they are linked to the thread. An extension user may
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
a00069e0: e3550000 cmp r5, #0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
a00069e4: e584510c str r5, [r4, #268] ; 0x10c
* if they are linked to the thread. An extension user may
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
a00069e8: 0a000009 beq a0006a14 <_Thread_Initialize+0xd4>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
a00069ec: e59f20f8 ldr r2, [pc, #248] ; a0006aec <_Thread_Initialize+0x1ac> a00069f0: e3a03000 mov r3, #0
the_thread->extensions[i] = NULL;
a00069f4: e1a01003 mov r1, r3
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
a00069f8: e5922000 ldr r2, [r2] a00069fc: ea000002 b a0006a0c <_Thread_Initialize+0xcc>
the_thread->extensions[i] = NULL;
a0006a00: e594010c ldr r0, [r4, #268] ; 0x10c a0006a04: e7801103 str r1, [r0, r3, lsl #2]
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
a0006a08: e2833001 add r3, r3, #1 a0006a0c: e1530002 cmp r3, r2
a0006a10: 9afffffa bls a0006a00 <_Thread_Initialize+0xc0>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
a0006a14: e59d302c ldr r3, [sp, #44] ; 0x2c
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
the_thread->Wait.queue = NULL;
a0006a18: e3a06000 mov r6, #0
#endif
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
a0006a1c: e3a08001 mov r8, #1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
a0006a20: e58430b0 str r3, [r4, #176] ; 0xb0
the_thread->Start.budget_callout = budget_callout;
a0006a24: e59d3030 ldr r3, [sp, #48] ; 0x30
#if defined(RTEMS_ITRON_API)
the_thread->suspend_count = 0;
#endif
the_thread->real_priority = priority;
the_thread->Start.initial_priority = priority;
_Thread_Set_priority( the_thread, priority );
a0006a28: e1a01007 mov r1, r7 a0006a2c: e1a00004 mov r0, r4
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
a0006a30: e58430b4 str r3, [r4, #180] ; 0xb4
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
a0006a34: e59d3034 ldr r3, [sp, #52] ; 0x34
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
a0006a38: e5c490ac strb r9, [r4, #172] ; 0xac
#endif
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
a0006a3c: e5848010 str r8, [r4, #16]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
a0006a40: e58430b8 str r3, [r4, #184] ; 0xb8
the_thread->current_state = STATES_DORMANT;
the_thread->Wait.queue = NULL;
a0006a44: e5846044 str r6, [r4, #68] ; 0x44
the_thread->resource_count = 0;
a0006a48: e584601c str r6, [r4, #28]
#if defined(RTEMS_ITRON_API)
the_thread->suspend_count = 0;
#endif
the_thread->real_priority = priority;
a0006a4c: e5847018 str r7, [r4, #24]
the_thread->Start.initial_priority = priority;
a0006a50: e58470bc str r7, [r4, #188] ; 0xbc
_Thread_Set_priority( the_thread, priority );
a0006a54: eb00019e bl a00070d4 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
a0006a58: e5846088 str r6, [r4, #136] ; 0x88
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
a0006a5c: e59d1038 ldr r1, [sp, #56] ; 0x38
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
a0006a60: e59a301c ldr r3, [sl, #28] a0006a64: e1d420b8 ldrh r2, [r4, #8]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
a0006a68: e584100c str r1, [r4, #12] a0006a6c: e5846084 str r6, [r4, #132] ; 0x84
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
a0006a70: e7834102 str r4, [r3, r2, lsl #2]
* enabled when we get here. We want to be able to run the * user extensions with dispatching enabled. The Allocator * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread );
a0006a74: e1a00004 mov r0, r4 a0006a78: eb000339 bl a0007764 <_User_extensions_Thread_create>
if ( extension_status )
a0006a7c: e1500006 cmp r0, r6
a0006a80: 0a000001 beq a0006a8c <_Thread_Initialize+0x14c>
a0006a84: e1a00008 mov r0, r8
a0006a88: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
return true;
failed:
if ( the_thread->libc_reent )
a0006a8c: e59400fc ldr r0, [r4, #252] ; 0xfc a0006a90: e3500000 cmp r0, #0
a0006a94: 0a000000 beq a0006a9c <_Thread_Initialize+0x15c>
_Workspace_Free( the_thread->libc_reent );
a0006a98: eb000434 bl a0007b70 <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
a0006a9c: e5940100 ldr r0, [r4, #256] ; 0x100 a0006aa0: e3500000 cmp r0, #0
a0006aa4: 0a000000 beq a0006aac <_Thread_Initialize+0x16c>
_Workspace_Free( the_thread->API_Extensions[i] );
a0006aa8: eb000430 bl a0007b70 <_Workspace_Free>
failed:
if ( the_thread->libc_reent )
_Workspace_Free( the_thread->libc_reent );
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
a0006aac: e5940104 ldr r0, [r4, #260] ; 0x104 a0006ab0: e3500000 cmp r0, #0
a0006ab4: 0a000000 beq a0006abc <_Thread_Initialize+0x17c>
_Workspace_Free( the_thread->API_Extensions[i] );
a0006ab8: eb00042c bl a0007b70 <_Workspace_Free> <== NOT EXECUTED
failed:
if ( the_thread->libc_reent )
_Workspace_Free( the_thread->libc_reent );
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
a0006abc: e5940108 ldr r0, [r4, #264] ; 0x108 a0006ac0: e3500000 cmp r0, #0
a0006ac4: 0a000000 beq a0006acc <_Thread_Initialize+0x18c>
_Workspace_Free( the_thread->API_Extensions[i] );
a0006ac8: eb000428 bl a0007b70 <_Workspace_Free> <== NOT EXECUTED
if ( extensions_area )
a0006acc: e3550000 cmp r5, #0
a0006ad0: 0a000001 beq a0006adc <_Thread_Initialize+0x19c>
(void) _Workspace_Free( extensions_area );
a0006ad4: e1a00005 mov r0, r5 a0006ad8: eb000424 bl a0007b70 <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
(void) _Workspace_Free( fp_area );
#endif
_Thread_Stack_Free( the_thread );
a0006adc: e1a00004 mov r0, r4 a0006ae0: eb000229 bl a000738c <_Thread_Stack_Free> a0006ae4: e3a00000 mov r0, #0
return false;
}
a0006ae8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
a0006dfc <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
a0006dfc: 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
)
{
a0006e00: 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);
a0006e04: e281503c add r5, r1, #60 ; 0x3c a0006e08: e5815038 str r5, [r1, #56] ; 0x38
the_chain->permanent_null = NULL;
a0006e0c: e3a05000 mov r5, #0
the_chain->last = _Chain_Head(the_chain);
a0006e10: 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 ) )
a0006e14: 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 ];
a0006e18: 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;
a0006e1c: e581503c str r5, [r1, #60] ; 0x3c a0006e20: e285500c add r5, r5, #12
the_chain->last = _Chain_Head(the_chain);
a0006e24: e581c040 str ip, [r1, #64] ; 0x40
block_state = the_thread_queue->state;
a0006e28: 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 ];
a0006e2c: 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;
a0006e30: 159f8158 ldrne r8, [pc, #344] ; a0006f90 <_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 ) )
a0006e34: 1a000023 bne a0006ec8 <_Thread_queue_Enqueue_priority+0xcc>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
a0006e38: e28c8004 add r8, ip, #4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0006e3c: e10f5000 mrs r5, CPSR a0006e40: e3854080 orr r4, r5, #128 ; 0x80 a0006e44: 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;
a0006e48: e3e06000 mvn r6, #0 a0006e4c: e59c4000 ldr r4, [ip]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
a0006e50: ea00000b b a0006e84 <_Thread_queue_Enqueue_priority+0x88>
search_priority = search_thread->current_priority;
a0006e54: e5946014 ldr r6, [r4, #20]
if ( priority <= search_priority )
a0006e58: e1530006 cmp r3, r6
a0006e5c: 9a00000a bls a0006e8c <_Thread_queue_Enqueue_priority+0x90>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
a0006e60: e10fa000 mrs sl, CPSR a0006e64: e129f005 msr CPSR_fc, r5 a0006e68: 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) ) {
a0006e6c: e594a010 ldr sl, [r4, #16] a0006e70: e117000a tst r7, sl
a0006e74: 1a000001 bne a0006e80 <_Thread_queue_Enqueue_priority+0x84>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0006e78: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED a0006e7c: eaffffee b a0006e3c <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
a0006e80: 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 ) ) {
a0006e84: e1540008 cmp r4, r8
a0006e88: 1afffff1 bne a0006e54 <_Thread_queue_Enqueue_priority+0x58>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
a0006e8c: 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 ) ) {
a0006e90: e1a0c005 mov ip, r5
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
a0006e94: e3570001 cmp r7, #1
a0006e98: 1a000039 bne a0006f84 <_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 )
a0006e9c: 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;
a0006ea0: e3a03000 mov r3, #0 a0006ea4: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
a0006ea8: 0a00002b beq a0006f5c <_Thread_queue_Enqueue_priority+0x160>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
a0006eac: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
a0006eb0: 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;
a0006eb4: 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;
a0006eb8: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
a0006ebc: e5831000 str r1, [r3]
search_node->previous = the_node;
a0006ec0: e5841004 str r1, [r4, #4]
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level );
a0006ec4: ea000022 b a0006f54 <_Thread_queue_Enqueue_priority+0x158>
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
a0006ec8: e5d86000 ldrb r6, [r8] a0006ecc: e2866001 add r6, r6, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0006ed0: e10f5000 mrs r5, CPSR a0006ed4: e3854080 orr r4, r5, #128 ; 0x80 a0006ed8: e129f004 msr CPSR_fc, r4
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
a0006edc: e59c4008 ldr r4, [ip, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
a0006ee0: ea00000b b a0006f14 <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
a0006ee4: e5946014 ldr r6, [r4, #20]
if ( priority >= search_priority )
a0006ee8: e1530006 cmp r3, r6
a0006eec: 2a00000a bcs a0006f1c <_Thread_queue_Enqueue_priority+0x120>
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+0x114>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0006f08: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED a0006f0c: eaffffed b a0006ec8 <_Thread_queue_Enqueue_priority+0xcc> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
a0006f10: 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 ) ) {
a0006f14: e154000c cmp r4, ip
a0006f18: 1afffff1 bne a0006ee4 <_Thread_queue_Enqueue_priority+0xe8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
a0006f1c: 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 ) ) {
a0006f20: e1a0c005 mov ip, r5
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
a0006f24: e3570001 cmp r7, #1
a0006f28: 1a000015 bne a0006f84 <_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: 0a000007 beq a0006f5c <_Thread_queue_Enqueue_priority+0x160>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
a0006f3c: e5943000 ldr r3, [r4]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
a0006f40: e5814004 str r4, [r1, #4]
search_node->next = the_node; next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
a0006f44: 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;
a0006f48: e5813000 str r3, [r1]
the_node->previous = search_node; search_node->next = the_node; next_node->previous = the_node;
a0006f4c: 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;
a0006f50: e5841000 str r1, [r4] a0006f54: e129f005 msr CPSR_fc, r5 a0006f58: ea000007 b a0006f7c <_Thread_queue_Enqueue_priority+0x180> a0006f5c: 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;
a0006f60: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
a0006f64: 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;
a0006f68: 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;
a0006f6c: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
a0006f70: e5831000 str r1, [r3]
search_node->previous = the_node;
a0006f74: e5841004 str r1, [r4, #4] a0006f78: e129f00c msr CPSR_fc, ip a0006f7c: e3a00001 mov r0, #1
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a0006f80: 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;
a0006f84: 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;
a0006f88: e582c000 str ip, [r2]
return the_thread_queue->sync_state; }
a0006f8c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
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: eb001026 bl a0018a60 <_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: eb00101d bl a0018a60 <_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: eb000fef bl a00189c0 <_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: eb00022c bl a00152c0 <_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: eb001035 bl a0018b14 <_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: e10f3000 mrs r3, CPSR a0014a7c: e3832080 orr r2, r3, #128 ; 0x80 a0014a80: e129f002 msr CPSR_fc, r2
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
a0014a84: e59d2008 ldr r2, [sp, #8]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
a0014a88: e1520008 cmp r2, 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: e5921000 ldr r1, [r2]
* 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: e3520000 cmp r2, #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: e5829008 str r9, [r2, #8]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0014aa8: e129f003 msr CPSR_fc, r3
/*
* 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: e5921024 ldr r1, [r2, #36] ; 0x24 a0014ab0: e592301c ldr r3, [r2, #28] a0014ab4: e5920020 ldr r0, [r2, #32] a0014ab8: e12fff33 blx r3
}
a0014abc: eaffffed b a0014a78 <_Timer_server_Body+0x12c> a0014ac0: e129f003 msr CPSR_fc, r3 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: eb000d65 bl a0018080 <_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: eb000ac6 bl a0017618 <_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: eb00105a bl a0018c78 <_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: eb001058 bl a0018c78 <_Watchdog_Remove> a0014b14: eaffffa0 b a001499c <_Timer_server_Body+0x50>
a0005a60 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
a0005a60: e92d40f1 push {r0, r4, r5, r6, r7, lr}
a0005a64: e1a05000 mov r5, r0
a0005a68: e1a04001 mov r4, r1
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
a0005a6c: e59f0168 ldr r0, [pc, #360] ; a0005bdc <rtems_rate_monotonic_period+0x17c> a0005a70: e1a01005 mov r1, r5 a0005a74: e1a0200d mov r2, sp a0005a78: eb0007fd bl a0007a74 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
a0005a7c: e59d3000 ldr r3, [sp] a0005a80: e1a06000 mov r6, r0 a0005a84: e3530000 cmp r3, #0
a0005a88: 1a000050 bne a0005bd0 <rtems_rate_monotonic_period+0x170>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
a0005a8c: e59f314c ldr r3, [pc, #332] ; a0005be0 <rtems_rate_monotonic_period+0x180> a0005a90: e5902040 ldr r2, [r0, #64] ; 0x40 a0005a94: e5933000 ldr r3, [r3] a0005a98: e1520003 cmp r2, r3
a0005a9c: 0a000002 beq a0005aac <rtems_rate_monotonic_period+0x4c>
_Thread_Enable_dispatch();
a0005aa0: eb000a2d bl a000835c <_Thread_Enable_dispatch> a0005aa4: e3a04017 mov r4, #23
return RTEMS_NOT_OWNER_OF_RESOURCE;
a0005aa8: ea000049 b a0005bd4 <rtems_rate_monotonic_period+0x174>
}
if ( length == RTEMS_PERIOD_STATUS ) {
a0005aac: e3540000 cmp r4, #0
a0005ab0: 1a000004 bne a0005ac8 <rtems_rate_monotonic_period+0x68>
switch ( the_period->state ) {
a0005ab4: e5903038 ldr r3, [r0, #56] ; 0x38 a0005ab8: e3530004 cmp r3, #4 a0005abc: 959f2120 ldrls r2, [pc, #288] ; a0005be4 <rtems_rate_monotonic_period+0x184> a0005ac0: 97924103 ldrls r4, [r2, r3, lsl #2] a0005ac4: ea00003f b a0005bc8 <rtems_rate_monotonic_period+0x168>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0005ac8: e10f7000 mrs r7, CPSR a0005acc: e3873080 orr r3, r7, #128 ; 0x80 a0005ad0: e129f003 msr CPSR_fc, r3
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
switch ( the_period->state ) {
a0005ad4: e5903038 ldr r3, [r0, #56] ; 0x38 a0005ad8: e3530002 cmp r3, #2
a0005adc: 0a000014 beq a0005b34 <rtems_rate_monotonic_period+0xd4>
a0005ae0: e3530004 cmp r3, #4
a0005ae4: 0a00002d beq a0005ba0 <rtems_rate_monotonic_period+0x140>
a0005ae8: e3530000 cmp r3, #0
a0005aec: 1a000037 bne a0005bd0 <rtems_rate_monotonic_period+0x170>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0005af0: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
a0005af4: ebffff58 bl a000585c <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
a0005af8: e3a03002 mov r3, #2 a0005afc: e5863038 str r3, [r6, #56] ; 0x38
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
a0005b00: e59f30e0 ldr r3, [pc, #224] ; a0005be8 <rtems_rate_monotonic_period+0x188>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
a0005b04: e3a07000 mov r7, #0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
a0005b08: e586401c str r4, [r6, #28]
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
a0005b0c: e586403c str r4, [r6, #60] ; 0x3c
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
a0005b10: e586302c str r3, [r6, #44] ; 0x2c
the_watchdog->id = id;
a0005b14: e5865030 str r5, [r6, #48] ; 0x30
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
a0005b18: e2861010 add r1, r6, #16
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
a0005b1c: e5867018 str r7, [r6, #24]
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
a0005b20: e5867034 str r7, [r6, #52] ; 0x34
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
a0005b24: e59f00c0 ldr r0, [pc, #192] ; a0005bec <rtems_rate_monotonic_period+0x18c> a0005b28: eb000eae bl a00095e8 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
a0005b2c: e1a04007 mov r4, r7 a0005b30: ea000024 b a0005bc8 <rtems_rate_monotonic_period+0x168>
case RATE_MONOTONIC_ACTIVE:
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
a0005b34: ebffff93 bl a0005988 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
a0005b38: e3a03001 mov r3, #1
the_period->next_length = length;
a0005b3c: e586403c str r4, [r6, #60] ; 0x3c
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
a0005b40: e5863038 str r3, [r6, #56] ; 0x38 a0005b44: e129f007 msr CPSR_fc, r7
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
a0005b48: e59f2090 ldr r2, [pc, #144] ; a0005be0 <rtems_rate_monotonic_period+0x180> a0005b4c: e5963008 ldr r3, [r6, #8]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
a0005b50: e3a01901 mov r1, #16384 ; 0x4000
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
a0005b54: e5920000 ldr r0, [r2] a0005b58: e5803020 str r3, [r0, #32]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
a0005b5c: eb000c45 bl a0008c78 <_Thread_Set_state>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a0005b60: e10f2000 mrs r2, CPSR a0005b64: e3823080 orr r3, r2, #128 ; 0x80 a0005b68: e129f003 msr CPSR_fc, r3
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
a0005b6c: e3a01002 mov r1, #2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
a0005b70: e5963038 ldr r3, [r6, #56] ; 0x38
the_period->state = RATE_MONOTONIC_ACTIVE;
a0005b74: e5861038 str r1, [r6, #56] ; 0x38
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a0005b78: e129f002 msr CPSR_fc, r2
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
a0005b7c: e3530003 cmp r3, #3
a0005b80: 1a000003 bne a0005b94 <rtems_rate_monotonic_period+0x134>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
a0005b84: e59f3054 ldr r3, [pc, #84] ; a0005be0 <rtems_rate_monotonic_period+0x180><== NOT EXECUTED a0005b88: e3a01901 mov r1, #16384 ; 0x4000 <== NOT EXECUTED a0005b8c: e5930000 ldr r0, [r3] <== NOT EXECUTED a0005b90: eb0008f6 bl a0007f70 <_Thread_Clear_state> <== NOT EXECUTED
_Thread_Enable_dispatch();
a0005b94: eb0009f0 bl a000835c <_Thread_Enable_dispatch> a0005b98: e3a04000 mov r4, #0
return RTEMS_SUCCESSFUL;
a0005b9c: ea00000c b a0005bd4 <rtems_rate_monotonic_period+0x174>
case RATE_MONOTONIC_EXPIRED:
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
a0005ba0: ebffff78 bl a0005988 <_Rate_monotonic_Update_statistics> a0005ba4: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
a0005ba8: e3a03002 mov r3, #2
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
a0005bac: e586401c str r4, [r6, #28]
the_period->next_length = length;
a0005bb0: e586403c str r4, [r6, #60] ; 0x3c
*/
_Rate_monotonic_Update_statistics( the_period );
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
a0005bb4: e5863038 str r3, [r6, #56] ; 0x38
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
a0005bb8: e2861010 add r1, r6, #16 a0005bbc: e59f0028 ldr r0, [pc, #40] ; a0005bec <rtems_rate_monotonic_period+0x18c> a0005bc0: eb000e88 bl a00095e8 <_Watchdog_Insert>
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
a0005bc4: e3a04006 mov r4, #6 a0005bc8: eb0009e3 bl a000835c <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
a0005bcc: ea000000 b a0005bd4 <rtems_rate_monotonic_period+0x174> a0005bd0: e3a04004 mov r4, #4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
a0005bd4: e1a00004 mov r0, r4
a0005bd8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}