4000add8 <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 4000add8: c4 02 21 60 ld [ %o0 + 0x160 ], %g2 RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 4000addc: c6 00 a0 88 ld [ %g2 + 0x88 ], %g3 4000ade0: 05 10 00 70 sethi %hi(0x4001c000), %g2 4000ade4: d2 08 a0 84 ldub [ %g2 + 0x84 ], %o1 ! 4001c084 */ #if 0 printk( "callout %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 4000ade8: c4 02 20 1c ld [ %o0 + 0x1c ], %g2 4000adec: 92 22 40 03 sub %o1, %g3, %o1 /* * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 4000adf0: 86 10 3f ff mov -1, %g3 new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority); the_thread->real_priority = new_priority; 4000adf4: d2 22 20 18 st %o1, [ %o0 + 0x18 ] */ #if 0 printk( "callout %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 4000adf8: 80 a0 a0 00 cmp %g2, 0 4000adfc: 12 80 00 09 bne 4000ae20 <_POSIX_Threads_Sporadic_budget_callout+0x48> 4000ae00: c6 22 20 78 st %g3, [ %o0 + 0x78 ] /* * Make sure we are actually lowering it. If they have lowered it * to logically lower than sched_ss_low_priority, then we do not want to * change it. */ if ( the_thread->current_priority < new_priority ) { 4000ae04: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000ae08: 80 a0 40 09 cmp %g1, %o1 4000ae0c: 1a 80 00 05 bcc 4000ae20 <_POSIX_Threads_Sporadic_budget_callout+0x48> 4000ae10: 94 10 20 01 mov 1, %o2 _Thread_Change_priority( the_thread, new_priority, true ); 4000ae14: 82 13 c0 00 mov %o7, %g1 4000ae18: 7f ff f0 bd call 4000710c <_Thread_Change_priority> 4000ae1c: 9e 10 40 00 mov %g1, %o7 4000ae20: 81 c3 e0 08 retl <== NOT EXECUTED 4000ae24: 01 00 00 00 nop 40007c8c <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 40007c8c: 9d e3 bf a0 save %sp, -96, %sp Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 40007c90: e0 06 60 14 ld [ %i1 + 0x14 ], %l0 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40007c94: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; 40007c98: c0 26 60 3c clr [ %i1 + 0x3c ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40007c9c: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40007ca0: 82 06 60 38 add %i1, 0x38, %g1 40007ca4: c2 26 60 40 st %g1, [ %i1 + 0x40 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 40007ca8: 2d 10 00 70 sethi %hi(0x4001c000), %l6 _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 ]; 40007cac: 83 34 20 06 srl %l0, 6, %g1 block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 40007cb0: 80 8c 20 20 btst 0x20, %l0 _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 ]; 40007cb4: a7 28 60 04 sll %g1, 4, %l3 the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 40007cb8: ac 15 a0 84 or %l6, 0x84, %l6 _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 ]; 40007cbc: 83 28 60 02 sll %g1, 2, %g1 block_state = the_thread_queue->state; 40007cc0: ea 06 20 38 ld [ %i0 + 0x38 ], %l5 _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 ]; 40007cc4: a6 24 c0 01 sub %l3, %g1, %l3 block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 40007cc8: 12 80 00 28 bne 40007d68 <_Thread_queue_Enqueue_priority+0xdc> 40007ccc: a6 06 00 13 add %i0, %l3, %l3 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40007cd0: ac 04 e0 04 add %l3, 4, %l6 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 40007cd4: 7f ff e7 f1 call 40001c98 40007cd8: 01 00 00 00 nop 40007cdc: a4 10 00 08 mov %o0, %l2 search_thread = (Thread_Control *) header->first; 40007ce0: a8 10 3f ff mov -1, %l4 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 40007ce4: 10 80 00 10 b 40007d24 <_Thread_queue_Enqueue_priority+0x98> 40007ce8: e2 04 c0 00 ld [ %l3 ], %l1 search_priority = search_thread->current_priority; if ( priority <= search_priority ) 40007cec: 80 a4 00 14 cmp %l0, %l4 40007cf0: 28 80 00 11 bleu,a 40007d34 <_Thread_queue_Enqueue_priority+0xa8> 40007cf4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 40007cf8: 7f ff e7 ec call 40001ca8 40007cfc: 90 10 00 12 mov %l2, %o0 40007d00: 7f ff e7 e6 call 40001c98 40007d04: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 40007d08: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 40007d0c: 80 8d 40 01 btst %l5, %g1 40007d10: 32 80 00 05 bne,a 40007d24 <_Thread_queue_Enqueue_priority+0x98> 40007d14: e2 04 40 00 ld [ %l1 ], %l1 _ISR_Enable( level ); 40007d18: 7f ff e7 e4 call 40001ca8 <== NOT EXECUTED 40007d1c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED goto restart_forward_search; 40007d20: 30 bf ff ed b,a 40007cd4 <_Thread_queue_Enqueue_priority+0x48> <== NOT EXECUTED 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 ) ) { 40007d24: 80 a4 40 16 cmp %l1, %l6 40007d28: 32 bf ff f1 bne,a 40007cec <_Thread_queue_Enqueue_priority+0x60> 40007d2c: e8 04 60 14 ld [ %l1 + 0x14 ], %l4 } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 40007d30: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 40007d34: 80 a0 60 01 cmp %g1, 1 40007d38: 12 80 00 3c bne 40007e28 <_Thread_queue_Enqueue_priority+0x19c> 40007d3c: 90 10 00 12 mov %l2, %o0 THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( priority == search_priority ) 40007d40: 80 a4 00 14 cmp %l0, %l4 40007d44: 02 80 00 2e be 40007dfc <_Thread_queue_Enqueue_priority+0x170> 40007d48: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 40007d4c: c2 04 60 04 ld [ %l1 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 40007d50: e2 26 40 00 st %l1, [ %i1 ] the_node->previous = previous_node; 40007d54: c2 26 60 04 st %g1, [ %i1 + 4 ] previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; 40007d58: f0 26 60 44 st %i0, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 40007d5c: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 40007d60: f2 24 60 04 st %i1, [ %l1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 40007d64: 30 80 00 2d b,a 40007e18 <_Thread_queue_Enqueue_priority+0x18c> return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 40007d68: 7f ff e7 cc call 40001c98 40007d6c: e8 0d 80 00 ldub [ %l6 ], %l4 the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 40007d70: a8 05 20 01 inc %l4 _ISR_Disable( level ); 40007d74: a4 10 00 08 mov %o0, %l2 search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 40007d78: 10 80 00 10 b 40007db8 <_Thread_queue_Enqueue_priority+0x12c> 40007d7c: e2 04 e0 08 ld [ %l3 + 8 ], %l1 search_priority = search_thread->current_priority; if ( priority >= search_priority ) 40007d80: 80 a4 00 14 cmp %l0, %l4 40007d84: 3a 80 00 11 bcc,a 40007dc8 <_Thread_queue_Enqueue_priority+0x13c> 40007d88: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 40007d8c: 7f ff e7 c7 call 40001ca8 40007d90: 90 10 00 12 mov %l2, %o0 40007d94: 7f ff e7 c1 call 40001c98 40007d98: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 40007d9c: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 40007da0: 80 8d 40 01 btst %l5, %g1 40007da4: 32 80 00 05 bne,a 40007db8 <_Thread_queue_Enqueue_priority+0x12c> 40007da8: e2 04 60 04 ld [ %l1 + 4 ], %l1 _ISR_Enable( level ); 40007dac: 7f ff e7 bf call 40001ca8 40007db0: 90 10 00 12 mov %l2, %o0 goto restart_reverse_search; 40007db4: 30 bf ff ed b,a 40007d68 <_Thread_queue_Enqueue_priority+0xdc> 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 ) ) { 40007db8: 80 a4 40 13 cmp %l1, %l3 40007dbc: 32 bf ff f1 bne,a 40007d80 <_Thread_queue_Enqueue_priority+0xf4> 40007dc0: e8 04 60 14 ld [ %l1 + 0x14 ], %l4 } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 40007dc4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 40007dc8: 80 a0 60 01 cmp %g1, 1 40007dcc: 12 80 00 17 bne 40007e28 <_Thread_queue_Enqueue_priority+0x19c> 40007dd0: 90 10 00 12 mov %l2, %o0 THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( priority == search_priority ) 40007dd4: 80 a4 00 14 cmp %l0, %l4 40007dd8: 02 80 00 09 be 40007dfc <_Thread_queue_Enqueue_priority+0x170> 40007ddc: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 40007de0: c2 04 40 00 ld [ %l1 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 40007de4: e2 26 60 04 st %l1, [ %i1 + 4 ] search_node = (Chain_Node *) search_thread; next_node = search_node->next; the_node = (Chain_Node *) the_thread; the_node->next = next_node; 40007de8: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = search_node; search_node->next = the_node; next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; 40007dec: f0 26 60 44 st %i0, [ %i1 + 0x44 ] 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; 40007df0: f2 24 40 00 st %i1, [ %l1 ] next_node->previous = the_node; 40007df4: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 40007df8: 30 80 00 08 b,a 40007e18 <_Thread_queue_Enqueue_priority+0x18c> 40007dfc: a2 04 60 3c add %l1, 0x3c, %l1 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; 40007e00: c2 04 60 04 ld [ %l1 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 40007e04: e2 26 40 00 st %l1, [ %i1 ] the_node->previous = previous_node; 40007e08: c2 26 60 04 st %g1, [ %i1 + 4 ] previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; 40007e0c: f0 26 60 44 st %i0, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 40007e10: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 40007e14: f2 24 60 04 st %i1, [ %l1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 40007e18: 7f ff e7 a4 call 40001ca8 40007e1c: b0 10 20 01 mov 1, %i0 return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 40007e20: 81 c7 e0 08 ret 40007e24: 81 e8 00 00 restore * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; 40007e28: f0 06 20 30 ld [ %i0 + 0x30 ], %i0 * 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; 40007e2c: d0 26 80 00 st %o0, [ %i2 ] return the_thread_queue->sync_state; } 40007e30: 81 c7 e0 08 ret 40007e34: 81 e8 00 00 restore 40014b68 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 40014b68: 9d e3 bf 88 save %sp, -120, %sp static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 40014b6c: 35 10 00 f1 sethi %hi(0x4003c400), %i2 40014b70: b2 07 bf f4 add %fp, -12, %i1 40014b74: ac 07 bf f8 add %fp, -8, %l6 40014b78: a2 07 bf e8 add %fp, -24, %l1 40014b7c: a6 07 bf ec add %fp, -20, %l3 static void _Timer_server_Process_tod_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 40014b80: 37 10 00 f1 sethi %hi(0x4003c400), %i3 40014b84: 2b 10 00 f1 sethi %hi(0x4003c400), %l5 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 40014b88: c0 27 bf f8 clr [ %fp + -8 ] 40014b8c: c0 27 bf ec clr [ %fp + -20 ] the_chain->last = _Chain_Head(the_chain); 40014b90: f2 27 bf fc st %i1, [ %fp + -4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40014b94: ec 27 bf f4 st %l6, [ %fp + -12 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40014b98: e2 27 bf f0 st %l1, [ %fp + -16 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40014b9c: e6 27 bf e8 st %l3, [ %fp + -24 ] static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 40014ba0: b4 16 a2 24 or %i2, 0x224, %i2 static void _Timer_server_Process_tod_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 40014ba4: b6 16 e1 60 or %i3, 0x160, %i3 40014ba8: aa 15 60 d0 or %l5, 0xd0, %l5 */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 40014bac: a8 06 20 30 add %i0, 0x30, %l4 /* * 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 ); 40014bb0: a4 06 20 68 add %i0, 0x68, %l2 static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 40014bb4: b8 06 20 08 add %i0, 8, %i4 static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 40014bb8: ba 06 20 40 add %i0, 0x40, %i5 _Thread_Set_state( ts->thread, STATES_DELAYING ); _Timer_server_Reset_interval_system_watchdog( ts ); _Timer_server_Reset_tod_system_watchdog( ts ); _Thread_Enable_dispatch(); ts->active = true; 40014bbc: ae 10 20 01 mov 1, %l7 { /* * 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; 40014bc0: f2 26 20 78 st %i1, [ %i0 + 0x78 ] static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 40014bc4: c2 06 80 00 ld [ %i2 ], %g1 /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 40014bc8: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 40014bcc: 94 10 00 11 mov %l1, %o2 /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; 40014bd0: c2 26 20 3c st %g1, [ %i0 + 0x3c ] _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 40014bd4: 92 20 40 09 sub %g1, %o1, %o1 40014bd8: 40 00 11 5f call 40019154 <_Watchdog_Adjust_to_chain> 40014bdc: 90 10 00 14 mov %l4, %o0 Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 40014be0: d4 06 20 74 ld [ %i0 + 0x74 ], %o2 static void _Timer_server_Process_tod_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 40014be4: e0 06 c0 00 ld [ %i3 ], %l0 /* * 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 ) { 40014be8: 80 a4 00 0a cmp %l0, %o2 40014bec: 08 80 00 06 bleu 40014c04 <_Timer_server_Body+0x9c> 40014bf0: 92 24 00 0a sub %l0, %o2, %o1 /* * 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 ); 40014bf4: 90 10 00 12 mov %l2, %o0 40014bf8: 40 00 11 57 call 40019154 <_Watchdog_Adjust_to_chain> 40014bfc: 94 10 00 11 mov %l1, %o2 40014c00: 30 80 00 06 b,a 40014c18 <_Timer_server_Body+0xb0> } else if ( snapshot < last_snapshot ) { 40014c04: 1a 80 00 05 bcc 40014c18 <_Timer_server_Body+0xb0> 40014c08: 94 22 80 10 sub %o2, %l0, %o2 /* * 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 ); 40014c0c: 90 10 00 12 mov %l2, %o0 40014c10: 40 00 11 2a call 400190b8 <_Watchdog_Adjust> 40014c14: 92 10 20 01 mov 1, %o1 } watchdogs->last_snapshot = snapshot; 40014c18: e0 26 20 74 st %l0, [ %i0 + 0x74 ] } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 40014c1c: d0 06 20 78 ld [ %i0 + 0x78 ], %o0 40014c20: 40 00 02 7e call 40015618 <_Chain_Get> 40014c24: 01 00 00 00 nop if ( timer == NULL ) { 40014c28: 80 a2 20 00 cmp %o0, 0 40014c2c: 02 80 00 0f be 40014c68 <_Timer_server_Body+0x100> 40014c30: 01 00 00 00 nop static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 40014c34: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 40014c38: 80 a0 60 01 cmp %g1, 1 40014c3c: 12 80 00 05 bne 40014c50 <_Timer_server_Body+0xe8> 40014c40: 80 a0 60 03 cmp %g1, 3 _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 40014c44: 92 02 20 10 add %o0, 0x10, %o1 40014c48: 10 80 00 05 b 40014c5c <_Timer_server_Body+0xf4> 40014c4c: 90 10 00 14 mov %l4, %o0 } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 40014c50: 12 bf ff f3 bne 40014c1c <_Timer_server_Body+0xb4> 40014c54: 92 02 20 10 add %o0, 0x10, %o1 _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 40014c58: 90 10 00 12 mov %l2, %o0 40014c5c: 40 00 11 73 call 40019228 <_Watchdog_Insert> 40014c60: 01 00 00 00 nop 40014c64: 30 bf ff ee b,a 40014c1c <_Timer_server_Body+0xb4> * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 40014c68: 7f ff e5 00 call 4000e068 40014c6c: 01 00 00 00 nop if ( _Chain_Is_empty( insert_chain ) ) { 40014c70: c2 07 bf f4 ld [ %fp + -12 ], %g1 40014c74: 80 a0 40 16 cmp %g1, %l6 40014c78: 12 80 00 0a bne 40014ca0 <_Timer_server_Body+0x138> 40014c7c: 01 00 00 00 nop ts->insert_chain = NULL; 40014c80: c0 26 20 78 clr [ %i0 + 0x78 ] _ISR_Enable( level ); 40014c84: 7f ff e4 fd call 4000e078 40014c88: 01 00 00 00 nop _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 ) ) { 40014c8c: c2 07 bf e8 ld [ %fp + -24 ], %g1 40014c90: 80 a0 40 13 cmp %g1, %l3 40014c94: 12 80 00 06 bne 40014cac <_Timer_server_Body+0x144> 40014c98: 01 00 00 00 nop 40014c9c: 30 80 00 1a b,a 40014d04 <_Timer_server_Body+0x19c> ts->insert_chain = NULL; _ISR_Enable( level ); break; } else { _ISR_Enable( level ); 40014ca0: 7f ff e4 f6 call 4000e078 <== NOT EXECUTED 40014ca4: 01 00 00 00 nop <== NOT EXECUTED 40014ca8: 30 bf ff c7 b,a 40014bc4 <_Timer_server_Body+0x5c> <== NOT EXECUTED /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 40014cac: 7f ff e4 ef call 4000e068 40014cb0: 01 00 00 00 nop 40014cb4: 84 10 00 08 mov %o0, %g2 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 40014cb8: e0 07 bf e8 ld [ %fp + -24 ], %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 40014cbc: 80 a4 00 13 cmp %l0, %l3 40014cc0: 02 80 00 0e be 40014cf8 <_Timer_server_Body+0x190> 40014cc4: 80 a4 20 00 cmp %l0, 0 { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 40014cc8: c2 04 00 00 ld [ %l0 ], %g1 the_chain->first = new_first; 40014ccc: c2 27 bf e8 st %g1, [ %fp + -24 ] watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { 40014cd0: 02 80 00 0a be 40014cf8 <_Timer_server_Body+0x190> 40014cd4: e2 20 60 04 st %l1, [ %g1 + 4 ] watchdog->state = WATCHDOG_INACTIVE; 40014cd8: c0 24 20 08 clr [ %l0 + 8 ] _ISR_Enable( level ); 40014cdc: 7f ff e4 e7 call 4000e078 40014ce0: 01 00 00 00 nop /* * 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 ); 40014ce4: d2 04 20 24 ld [ %l0 + 0x24 ], %o1 40014ce8: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 40014cec: 9f c0 40 00 call %g1 40014cf0: d0 04 20 20 ld [ %l0 + 0x20 ], %o0 } 40014cf4: 30 bf ff ee b,a 40014cac <_Timer_server_Body+0x144> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 40014cf8: 7f ff e4 e0 call 4000e078 40014cfc: 90 10 00 02 mov %g2, %o0 40014d00: 30 bf ff b0 b,a 40014bc0 <_Timer_server_Body+0x58> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 40014d04: c0 2e 20 7c clrb [ %i0 + 0x7c ] 40014d08: c2 05 40 00 ld [ %l5 ], %g1 40014d0c: 82 00 60 01 inc %g1 40014d10: c2 25 40 00 st %g1, [ %l5 ] /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 40014d14: d0 06 00 00 ld [ %i0 ], %o0 40014d18: 40 00 0e 4c call 40018648 <_Thread_Set_state> 40014d1c: 92 10 20 08 mov 8, %o1 _Timer_server_Reset_interval_system_watchdog( ts ); 40014d20: 7f ff ff 68 call 40014ac0 <_Timer_server_Reset_interval_system_watchdog> 40014d24: 90 10 00 18 mov %i0, %o0 _Timer_server_Reset_tod_system_watchdog( ts ); 40014d28: 7f ff ff 7b call 40014b14 <_Timer_server_Reset_tod_system_watchdog> 40014d2c: 90 10 00 18 mov %i0, %o0 _Thread_Enable_dispatch(); 40014d30: 40 00 0b 93 call 40017b7c <_Thread_Enable_dispatch> 40014d34: 01 00 00 00 nop static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 40014d38: 90 10 00 1c mov %i4, %o0 _Thread_Set_state( ts->thread, STATES_DELAYING ); _Timer_server_Reset_interval_system_watchdog( ts ); _Timer_server_Reset_tod_system_watchdog( ts ); _Thread_Enable_dispatch(); ts->active = true; 40014d3c: ee 2e 20 7c stb %l7, [ %i0 + 0x7c ] static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 40014d40: 40 00 11 97 call 4001939c <_Watchdog_Remove> 40014d44: 01 00 00 00 nop static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 40014d48: 40 00 11 95 call 4001939c <_Watchdog_Remove> 40014d4c: 90 10 00 1d mov %i5, %o0 40014d50: 30 bf ff 9c b,a 40014bc0 <_Timer_server_Body+0x58> 4000e0e4 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 4000e0e4: 9d e3 bf 90 save %sp, -112, %sp POSIX_signals_Siginfo_node *psiginfo; /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 4000e0e8: 7f ff fb d5 call 4000d03c 4000e0ec: 01 00 00 00 nop 4000e0f0: 80 a6 00 08 cmp %i0, %o0 4000e0f4: 02 80 00 06 be 4000e10c 4000e0f8: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 4000e0fc: 40 00 01 97 call 4000e758 <__errno> 4000e100: 01 00 00 00 nop 4000e104: 10 80 00 07 b 4000e120 4000e108: 82 10 20 03 mov 3, %g1 ! 3 /* * Validate the signal passed. */ if ( !sig ) 4000e10c: 12 80 00 08 bne 4000e12c 4000e110: 82 06 7f ff add %i1, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); 4000e114: 40 00 01 91 call 4000e758 <__errno> 4000e118: 01 00 00 00 nop 4000e11c: 82 10 20 16 mov 0x16, %g1 ! 16 4000e120: c2 22 00 00 st %g1, [ %o0 ] 4000e124: 10 80 00 a5 b 4000e3b8 4000e128: 90 10 3f ff mov -1, %o0 if ( !is_valid_signo(sig) ) 4000e12c: 80 a0 60 1f cmp %g1, 0x1f 4000e130: 18 bf ff f9 bgu 4000e114 4000e134: 85 2e 60 02 sll %i1, 2, %g2 rtems_set_errno_and_return_minus_one( EINVAL ); /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) 4000e138: 87 2e 60 04 sll %i1, 4, %g3 4000e13c: 86 20 c0 02 sub %g3, %g2, %g3 4000e140: 05 10 00 73 sethi %hi(0x4001cc00), %g2 4000e144: 84 10 a3 74 or %g2, 0x374, %g2 ! 4001cf74 <_POSIX_signals_Vectors> 4000e148: 84 00 80 03 add %g2, %g3, %g2 4000e14c: c4 00 a0 08 ld [ %g2 + 8 ], %g2 4000e150: 80 a0 a0 01 cmp %g2, 1 4000e154: 02 80 00 99 be 4000e3b8 4000e158: 90 10 20 00 clr %o0 /* * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) 4000e15c: 80 a6 60 04 cmp %i1, 4 4000e160: 02 80 00 06 be 4000e178 4000e164: 80 a6 60 08 cmp %i1, 8 4000e168: 02 80 00 04 be 4000e178 4000e16c: 80 a6 60 0b cmp %i1, 0xb 4000e170: 12 80 00 08 bne 4000e190 4000e174: a0 10 20 01 mov 1, %l0 return pthread_kill( pthread_self(), sig ); 4000e178: 40 00 01 4f call 4000e6b4 4000e17c: 01 00 00 00 nop 4000e180: 40 00 01 11 call 4000e5c4 4000e184: 92 10 00 19 mov %i1, %o1 4000e188: 81 c7 e0 08 ret 4000e18c: 91 e8 00 08 restore %g0, %o0, %o0 /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 4000e190: f2 27 bf f4 st %i1, [ %fp + -12 ] siginfo->si_code = SI_USER; 4000e194: e0 27 bf f8 st %l0, [ %fp + -8 ] if ( !value ) { 4000e198: 80 a6 a0 00 cmp %i2, 0 4000e19c: 12 80 00 04 bne 4000e1ac 4000e1a0: a1 2c 00 01 sll %l0, %g1, %l0 siginfo->si_value.sival_int = 0; 4000e1a4: 10 80 00 04 b 4000e1b4 4000e1a8: c0 27 bf fc clr [ %fp + -4 ] } else { siginfo->si_value = *value; 4000e1ac: c2 06 80 00 ld [ %i2 ], %g1 4000e1b0: c2 27 bf fc st %g1, [ %fp + -4 ] 4000e1b4: 03 10 00 72 sethi %hi(0x4001c800), %g1 4000e1b8: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 4001c9e0 <_Thread_Dispatch_disable_level> 4000e1bc: 84 00 a0 01 inc %g2 4000e1c0: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 4000e1c4: 03 10 00 72 sethi %hi(0x4001c800), %g1 4000e1c8: c2 00 62 9c ld [ %g1 + 0x29c ], %g1 ! 4001ca9c <_Thread_Executing> api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 4000e1cc: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 4000e1d0: c4 00 a0 cc ld [ %g2 + 0xcc ], %g2 4000e1d4: 80 ac 00 02 andncc %l0, %g2, %g0 4000e1d8: 12 80 00 4e bne 4000e310 4000e1dc: 07 10 00 74 sethi %hi(0x4001d000), %g3 /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = the_chain->first ; 4000e1e0: 03 10 00 74 sethi %hi(0x4001d000), %g1 4000e1e4: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 4001d100 <_POSIX_signals_Wait_queue> 4000e1e8: 10 80 00 0b b 4000e214 4000e1ec: 86 10 e1 04 or %g3, 0x104, %g3 !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 4000e1f0: c8 00 a1 60 ld [ %g2 + 0x160 ], %g4 #endif /* * Is this thread is actually blocked waiting for the signal? */ if (the_thread->Wait.option & mask) 4000e1f4: 80 8c 00 01 btst %l0, %g1 4000e1f8: 12 80 00 46 bne 4000e310 4000e1fc: 82 10 00 02 mov %g2, %g1 /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 4000e200: c8 01 20 cc ld [ %g4 + 0xcc ], %g4 4000e204: 80 ac 00 04 andncc %l0, %g4, %g0 4000e208: 32 80 00 43 bne,a 4000e314 4000e20c: 84 10 20 01 mov 1, %g2 the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 4000e210: c4 00 80 00 ld [ %g2 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4000e214: 80 a0 80 03 cmp %g2, %g3 4000e218: 32 bf ff f6 bne,a 4000e1f0 4000e21c: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 4000e220: 03 10 00 70 sethi %hi(0x4001c000), %g1 4000e224: c8 08 60 84 ldub [ %g1 + 0x84 ], %g4 ! 4001c084 4000e228: 05 10 00 72 sethi %hi(0x4001c800), %g2 4000e22c: 88 01 20 01 inc %g4 4000e230: 84 10 a1 48 or %g2, 0x148, %g2 */ #define _POSIX_signals_Is_interested( _api, _mask ) \ ( ~(_api)->signals_blocked & (_mask) ) int killinfo( 4000e234: 82 10 20 00 clr %g1 4000e238: 90 00 a0 0c add %g2, 0xc, %o0 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 4000e23c: 17 04 00 00 sethi %hi(0x10000000), %o3 for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { /* * This can occur when no one is interested and ITRON is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 4000e240: c6 00 80 00 ld [ %g2 ], %g3 4000e244: 80 a0 e0 00 cmp %g3, 0 4000e248: 22 80 00 2c be,a 4000e2f8 4000e24c: 84 00 a0 04 add %g2, 4, %g2 continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 4000e250: c6 00 e0 04 ld [ %g3 + 4 ], %g3 if ( !the_info ) continue; #endif maximum = the_info->maximum; object_table = the_info->local_table; 4000e254: 9a 10 20 01 mov 1, %o5 4000e258: f4 00 e0 1c ld [ %g3 + 0x1c ], %i2 for ( index = 1 ; index <= maximum ; index++ ) { 4000e25c: 10 80 00 23 b 4000e2e8 4000e260: de 10 e0 10 lduh [ %g3 + 0x10 ], %o7 the_thread = (Thread_Control *) object_table[ index ]; 4000e264: c6 06 80 03 ld [ %i2 + %g3 ], %g3 if ( !the_thread ) 4000e268: 80 a0 e0 00 cmp %g3, 0 4000e26c: 02 80 00 1d be 4000e2e0 4000e270: 98 10 00 04 mov %g4, %o4 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 4000e274: d8 00 e0 14 ld [ %g3 + 0x14 ], %o4 4000e278: 80 a3 00 04 cmp %o4, %g4 4000e27c: 38 80 00 19 bgu,a 4000e2e0 4000e280: 98 10 00 04 mov %g4, %o4 DEBUG_STEP("2"); /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 4000e284: d4 00 e1 60 ld [ %g3 + 0x160 ], %o2 4000e288: d4 02 a0 cc ld [ %o2 + 0xcc ], %o2 4000e28c: 80 ac 00 0a andncc %l0, %o2, %g0 4000e290: 22 80 00 14 be,a 4000e2e0 4000e294: 98 10 00 04 mov %g4, %o4 * * NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1 * so we never have to worry about deferencing a NULL * interested thread. */ if ( the_thread->current_priority < interested_priority ) { 4000e298: 80 a3 00 04 cmp %o4, %g4 4000e29c: 2a 80 00 11 bcs,a 4000e2e0 4000e2a0: 82 10 00 03 mov %g3, %g1 * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( !_States_Is_ready( interested->current_state ) ) { 4000e2a4: d2 00 60 10 ld [ %g1 + 0x10 ], %o1 4000e2a8: 80 a2 60 00 cmp %o1, 0 4000e2ac: 22 80 00 0d be,a 4000e2e0 4000e2b0: 98 10 00 04 mov %g4, %o4 <== NOT EXECUTED /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 4000e2b4: d4 00 e0 10 ld [ %g3 + 0x10 ], %o2 4000e2b8: 80 a2 a0 00 cmp %o2, 0 4000e2bc: 22 80 00 09 be,a 4000e2e0 4000e2c0: 82 10 00 03 mov %g3, %g1 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 4000e2c4: 80 8a 40 0b btst %o1, %o3 4000e2c8: 32 80 00 06 bne,a 4000e2e0 4000e2cc: 98 10 00 04 mov %g4, %o4 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 4000e2d0: 80 8a 80 0b btst %o2, %o3 4000e2d4: 32 80 00 03 bne,a 4000e2e0 4000e2d8: 82 10 00 03 mov %g3, %g1 4000e2dc: 98 10 00 04 mov %g4, %o4 #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 4000e2e0: 9a 03 60 01 inc %o5 4000e2e4: 88 10 00 0c mov %o4, %g4 4000e2e8: 80 a3 40 0f cmp %o5, %o7 4000e2ec: 28 bf ff de bleu,a 4000e264 4000e2f0: 87 2b 60 02 sll %o5, 2, %g3 4000e2f4: 84 00 a0 04 add %g2, 4, %g2 * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 4000e2f8: 80 a0 80 08 cmp %g2, %o0 4000e2fc: 32 bf ff d2 bne,a 4000e244 4000e300: c6 00 80 00 ld [ %g2 ], %g3 } } } } if ( interested ) { 4000e304: 80 a0 60 00 cmp %g1, 0 4000e308: 02 80 00 0b be 4000e334 4000e30c: 01 00 00 00 nop * thread needs to do the post context switch extension so it can * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 4000e310: 84 10 20 01 mov 1, %g2 ! 1 /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 4000e314: 90 10 00 01 mov %g1, %o0 * thread needs to do the post context switch extension so it can * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 4000e318: c4 28 60 74 stb %g2, [ %g1 + 0x74 ] /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 4000e31c: 92 10 00 19 mov %i1, %o1 4000e320: 40 00 00 5d call 4000e494 <_POSIX_signals_Unblock_thread> 4000e324: 94 07 bf f4 add %fp, -12, %o2 4000e328: 80 8a 20 ff btst 0xff, %o0 4000e32c: 12 80 00 20 bne 4000e3ac 4000e330: 01 00 00 00 nop /* * We may have woken up a thread but we definitely need to post the * signal to the process wide information set. */ _POSIX_signals_Set_process_signals( mask ); 4000e334: 40 00 00 47 call 4000e450 <_POSIX_signals_Set_process_signals> 4000e338: 90 10 00 10 mov %l0, %o0 if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 4000e33c: 83 2e 60 04 sll %i1, 4, %g1 4000e340: b3 2e 60 02 sll %i1, 2, %i1 4000e344: b2 20 40 19 sub %g1, %i1, %i1 4000e348: 03 10 00 73 sethi %hi(0x4001cc00), %g1 4000e34c: 82 10 63 74 or %g1, 0x374, %g1 ! 4001cf74 <_POSIX_signals_Vectors> 4000e350: c2 00 40 19 ld [ %g1 + %i1 ], %g1 4000e354: 80 a0 60 02 cmp %g1, 2 4000e358: 12 80 00 15 bne 4000e3ac 4000e35c: 11 10 00 74 sethi %hi(0x4001d000), %o0 psiginfo = (POSIX_signals_Siginfo_node *) 4000e360: 7f ff f4 8e call 4000b598 <_Chain_Get> 4000e364: 90 12 20 f4 or %o0, 0xf4, %o0 ! 4001d0f4 <_POSIX_signals_Inactive_siginfo> _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 4000e368: a0 92 20 00 orcc %o0, 0, %l0 4000e36c: 12 80 00 08 bne 4000e38c 4000e370: 92 07 bf f4 add %fp, -12, %o1 _Thread_Enable_dispatch(); 4000e374: 7f ff e4 d6 call 400076cc <_Thread_Enable_dispatch> 4000e378: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EAGAIN ); 4000e37c: 40 00 00 f7 call 4000e758 <__errno> 4000e380: 01 00 00 00 nop 4000e384: 10 bf ff 67 b 4000e120 4000e388: 82 10 20 0b mov 0xb, %g1 ! b } psiginfo->Info = *siginfo; 4000e38c: 90 04 20 08 add %l0, 8, %o0 4000e390: 40 00 03 2d call 4000f044 4000e394: 94 10 20 0c mov 0xc, %o2 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 4000e398: 11 10 00 74 sethi %hi(0x4001d000), %o0 4000e39c: 92 10 00 10 mov %l0, %o1 4000e3a0: 90 12 21 44 or %o0, 0x144, %o0 4000e3a4: 7f ff de f6 call 40005f7c <_Chain_Append> 4000e3a8: 90 02 00 19 add %o0, %i1, %o0 } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 4000e3ac: 7f ff e4 c8 call 400076cc <_Thread_Enable_dispatch> 4000e3b0: 01 00 00 00 nop 4000e3b4: 90 10 20 00 clr %o0 ! 0 return 0; } 4000e3b8: b0 10 00 08 mov %o0, %i0 4000e3bc: 81 c7 e0 08 ret 4000e3c0: 81 e8 00 00 restore