00109b5c <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109b5c: 55 push %ebp 109b5d: 89 e5 mov %esp,%ebp 109b5f: 57 push %edi 109b60: 56 push %esi 109b61: 53 push %ebx 109b62: 83 ec 2c sub $0x2c,%esp 109b65: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_event_set event_condition; rtems_event_set seized_events; rtems_option option_set; RTEMS_API_Control *api; api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 109b68: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi option_set = (rtems_option) the_thread->Wait.option; 109b6e: 8b 43 30 mov 0x30(%ebx),%eax 109b71: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109b74: 9c pushf 109b75: fa cli 109b76: 58 pop %eax pending_events = api->pending_events; 109b77: 8b 17 mov (%edi),%edx 109b79: 89 55 d4 mov %edx,-0x2c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109b7c: 8b 73 24 mov 0x24(%ebx),%esi seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 109b7f: 21 f2 and %esi,%edx 109b81: 75 07 jne 109b8a <_Event_Surrender+0x2e> _ISR_Enable( level ); 109b83: 50 push %eax 109b84: 9d popf return; 109b85: e9 b0 00 00 00 jmp 109c3a <_Event_Surrender+0xde> /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 109b8a: 8b 0d 84 42 12 00 mov 0x124284,%ecx 109b90: 85 c9 test %ecx,%ecx 109b92: 74 49 je 109bdd <_Event_Surrender+0x81> 109b94: 3b 1d a8 42 12 00 cmp 0x1242a8,%ebx 109b9a: 75 41 jne 109bdd <_Event_Surrender+0x81> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109b9c: 8b 0d c4 4a 12 00 mov 0x124ac4,%ecx /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 109ba2: 83 f9 02 cmp $0x2,%ecx 109ba5: 74 09 je 109bb0 <_Event_Surrender+0x54> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109ba7: 8b 0d c4 4a 12 00 mov 0x124ac4,%ecx /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 109bad: 49 dec %ecx 109bae: 75 2d jne 109bdd <_Event_Surrender+0x81> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109bb0: 39 f2 cmp %esi,%edx 109bb2: 74 06 je 109bba <_Event_Surrender+0x5e> 109bb4: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109bb8: 74 1f je 109bd9 <_Event_Surrender+0x7d> api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 109bba: 89 d6 mov %edx,%esi 109bbc: f7 d6 not %esi 109bbe: 23 75 d4 and -0x2c(%ebp),%esi 109bc1: 89 37 mov %esi,(%edi) the_thread->Wait.count = 0; 109bc3: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109bca: 8b 4b 28 mov 0x28(%ebx),%ecx 109bcd: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109bcf: c7 05 c4 4a 12 00 03 movl $0x3,0x124ac4 109bd6: 00 00 00 } _ISR_Enable( level ); 109bd9: 50 push %eax 109bda: 9d popf return; 109bdb: eb 5d jmp 109c3a <_Event_Surrender+0xde> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109bdd: f6 43 11 01 testb $0x1,0x11(%ebx) 109be1: 74 55 je 109c38 <_Event_Surrender+0xdc> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109be3: 39 f2 cmp %esi,%edx 109be5: 74 06 je 109bed <_Event_Surrender+0x91> 109be7: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109beb: 74 4b je 109c38 <_Event_Surrender+0xdc> api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 109bed: 89 d6 mov %edx,%esi 109bef: f7 d6 not %esi 109bf1: 23 75 d4 and -0x2c(%ebp),%esi 109bf4: 89 37 mov %esi,(%edi) the_thread->Wait.count = 0; 109bf6: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109bfd: 8b 4b 28 mov 0x28(%ebx),%ecx 109c00: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109c02: 50 push %eax 109c03: 9d popf 109c04: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109c05: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109c09: 74 06 je 109c11 <_Event_Surrender+0xb5> _ISR_Enable( level ); 109c0b: 50 push %eax 109c0c: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109c0d: 51 push %ecx 109c0e: 51 push %ecx 109c0f: eb 17 jmp 109c28 <_Event_Surrender+0xcc> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109c11: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109c18: 50 push %eax 109c19: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109c1a: 83 ec 0c sub $0xc,%esp 109c1d: 8d 43 48 lea 0x48(%ebx),%eax 109c20: 50 push %eax 109c21: e8 f2 2e 00 00 call 10cb18 <_Watchdog_Remove> 109c26: 58 pop %eax 109c27: 5a pop %edx 109c28: 68 f8 ff 03 10 push $0x1003fff8 109c2d: 53 push %ebx 109c2e: e8 91 1c 00 00 call 10b8c4 <_Thread_Clear_state> 109c33: 83 c4 10 add $0x10,%esp 109c36: eb 02 jmp 109c3a <_Event_Surrender+0xde> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109c38: 50 push %eax <== NOT EXECUTED 109c39: 9d popf <== NOT EXECUTED } 109c3a: 8d 65 f4 lea -0xc(%ebp),%esp 109c3d: 5b pop %ebx 109c3e: 5e pop %esi 109c3f: 5f pop %edi 109c40: c9 leave 109c41: c3 ret 0010afa4 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10afa4: 55 push %ebp 10afa5: 89 e5 mov %esp,%ebp 10afa7: 53 push %ebx 10afa8: 83 ec 08 sub $0x8,%esp 10afab: 8b 45 08 mov 0x8(%ebp),%eax 10afae: 8b 55 0c mov 0xc(%ebp),%edx 10afb1: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10afb4: a3 90 42 12 00 mov %eax,0x124290 _Internal_errors_What_happened.is_internal = is_internal; 10afb9: 88 15 94 42 12 00 mov %dl,0x124294 _Internal_errors_What_happened.the_error = the_error; 10afbf: 89 1d 98 42 12 00 mov %ebx,0x124298 _User_extensions_Fatal( the_source, is_internal, the_error ); 10afc5: 53 push %ebx 10afc6: 0f b6 d2 movzbl %dl,%edx 10afc9: 52 push %edx 10afca: 50 push %eax 10afcb: e8 13 19 00 00 call 10c8e3 <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10afd0: c7 05 84 43 12 00 05 movl $0x5,0x124384 <== NOT EXECUTED 10afd7: 00 00 00 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10afda: fa cli <== NOT EXECUTED 10afdb: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10afdd: f4 hlt <== NOT EXECUTED 10afde: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afe1: eb fe jmp 10afe1 <_Internal_error_Occurred+0x3d> <== NOT EXECUTED 0010a08c <_POSIX_Timer_TSR>: * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR( Objects_Id timer __attribute__((unused)), void *data) { 10a08c: 55 push %ebp 10a08d: 89 e5 mov %esp,%ebp 10a08f: 53 push %ebx 10a090: 83 ec 04 sub $0x4,%esp 10a093: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a096: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a099: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 10a09d: 75 06 jne 10a0a5 <_POSIX_Timer_TSR+0x19> ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { 10a09f: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10a0a3: 74 34 je 10a0d9 <_POSIX_Timer_TSR+0x4d> activated = _POSIX_Timer_Insert_helper( 10a0a5: 83 ec 0c sub $0xc,%esp 10a0a8: 53 push %ebx 10a0a9: 68 8c a0 10 00 push $0x10a08c 10a0ae: ff 73 08 pushl 0x8(%ebx) 10a0b1: ff 73 64 pushl 0x64(%ebx) 10a0b4: 8d 43 10 lea 0x10(%ebx),%eax 10a0b7: 50 push %eax 10a0b8: e8 eb 50 00 00 call 10f1a8 <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a0bd: 83 c4 20 add $0x20,%esp 10a0c0: 84 c0 test %al,%al 10a0c2: 74 30 je 10a0f4 <_POSIX_Timer_TSR+0x68> return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a0c4: 83 ec 0c sub $0xc,%esp 10a0c7: 8d 43 6c lea 0x6c(%ebx),%eax 10a0ca: 50 push %eax 10a0cb: e8 34 14 00 00 call 10b504 <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a0d0: c6 43 3c 03 movb $0x3,0x3c(%ebx) /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a0d4: 83 c4 10 add $0x10,%esp 10a0d7: eb 04 jmp 10a0dd <_POSIX_Timer_TSR+0x51> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a0d9: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 10a0dd: 50 push %eax 10a0de: 50 push %eax 10a0df: ff 73 44 pushl 0x44(%ebx) 10a0e2: ff 73 38 pushl 0x38(%ebx) 10a0e5: e8 8e 4c 00 00 call 10ed78 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a0ea: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10a0f1: 83 c4 10 add $0x10,%esp } 10a0f4: 8b 5d fc mov -0x4(%ebp),%ebx 10a0f7: c9 leave 10a0f8: c3 ret 0010c160 <_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 ) { 10c160: 55 push %ebp 10c161: 89 e5 mov %esp,%ebp 10c163: 57 push %edi 10c164: 56 push %esi 10c165: 53 push %ebx 10c166: 83 ec 10 sub $0x10,%esp 10c169: 8b 4d 08 mov 0x8(%ebp),%ecx 10c16c: 8b 45 0c mov 0xc(%ebp),%eax */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10c16f: 8d 50 3c lea 0x3c(%eax),%edx 10c172: 89 50 38 mov %edx,0x38(%eax) the_chain->permanent_null = NULL; 10c175: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax) the_chain->last = _Chain_Head(the_chain); 10c17c: 8d 50 38 lea 0x38(%eax),%edx 10c17f: 89 50 40 mov %edx,0x40(%eax) Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10c182: 8b 58 14 mov 0x14(%eax),%ebx header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10c185: 89 de mov %ebx,%esi 10c187: c1 ee 06 shr $0x6,%esi 10c18a: 6b f6 0c imul $0xc,%esi,%esi 10c18d: 8d 34 31 lea (%ecx,%esi,1),%esi block_state = the_thread_queue->state; 10c190: 8b 79 38 mov 0x38(%ecx),%edi if ( _Thread_queue_Is_reverse_search( priority ) ) 10c193: f6 c3 20 test $0x20,%bl 10c196: 75 70 jne 10c208 <_Thread_queue_Enqueue_priority+0xa8> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10c198: 8d 56 04 lea 0x4(%esi),%edx 10c19b: 89 55 e8 mov %edx,-0x18(%ebp) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10c19e: 9c pushf 10c19f: fa cli 10c1a0: 8f 45 f0 popl -0x10(%ebp) search_thread = (Thread_Control *) header->first; 10c1a3: 8b 16 mov (%esi),%edx 10c1a5: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) 10c1ac: 89 75 e4 mov %esi,-0x1c(%ebp) while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c1af: eb 1f jmp 10c1d0 <_Thread_queue_Enqueue_priority+0x70> search_priority = search_thread->current_priority; 10c1b1: 8b 72 14 mov 0x14(%edx),%esi 10c1b4: 89 75 ec mov %esi,-0x14(%ebp) if ( priority <= search_priority ) 10c1b7: 39 f3 cmp %esi,%ebx 10c1b9: 76 1a jbe 10c1d5 <_Thread_queue_Enqueue_priority+0x75> break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c1bb: ff 75 f0 pushl -0x10(%ebp) 10c1be: 9d popf 10c1bf: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c1c0: 85 7a 10 test %edi,0x10(%edx) 10c1c3: 75 09 jne 10c1ce <_Thread_queue_Enqueue_priority+0x6e> 10c1c5: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED _ISR_Enable( level ); 10c1c8: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c1cb: 9d popf <== NOT EXECUTED goto restart_forward_search; 10c1cc: eb d0 jmp 10c19e <_Thread_queue_Enqueue_priority+0x3e> <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; 10c1ce: 8b 12 mov (%edx),%edx 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 ) ) { 10c1d0: 3b 55 e8 cmp -0x18(%ebp),%edx 10c1d3: 75 dc jne 10c1b1 <_Thread_queue_Enqueue_priority+0x51> 10c1d5: 8b 75 f0 mov -0x10(%ebp),%esi } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c1d8: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c1dc: 0f 85 a9 00 00 00 jne 10c28b <_Thread_queue_Enqueue_priority+0x12b> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c1e2: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c1e9: 3b 5d ec cmp -0x14(%ebp),%ebx 10c1ec: 0f 84 82 00 00 00 je 10c274 <_Thread_queue_Enqueue_priority+0x114> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c1f2: 8b 5a 04 mov 0x4(%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c1f5: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c1f7: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c1fa: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c1fc: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c1ff: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c202: ff 75 f0 pushl -0x10(%ebp) 10c205: 9d popf 10c206: eb 65 jmp 10c26d <_Thread_queue_Enqueue_priority+0x10d> return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10c208: 0f b6 15 f4 01 12 00 movzbl 0x1201f4,%edx 10c20f: 42 inc %edx 10c210: 89 55 ec mov %edx,-0x14(%ebp) _ISR_Disable( level ); 10c213: 9c pushf 10c214: fa cli 10c215: 8f 45 f0 popl -0x10(%ebp) search_thread = (Thread_Control *) header->last; 10c218: 8b 56 08 mov 0x8(%esi),%edx 10c21b: 89 75 e8 mov %esi,-0x18(%ebp) while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c21e: eb 20 jmp 10c240 <_Thread_queue_Enqueue_priority+0xe0> search_priority = search_thread->current_priority; 10c220: 8b 72 14 mov 0x14(%edx),%esi 10c223: 89 75 ec mov %esi,-0x14(%ebp) if ( priority >= search_priority ) 10c226: 39 f3 cmp %esi,%ebx 10c228: 73 1b jae 10c245 <_Thread_queue_Enqueue_priority+0xe5> break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10c22a: ff 75 f0 pushl -0x10(%ebp) 10c22d: 9d popf 10c22e: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c22f: 85 7a 10 test %edi,0x10(%edx) 10c232: 75 09 jne 10c23d <_Thread_queue_Enqueue_priority+0xdd> 10c234: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED _ISR_Enable( level ); 10c237: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c23a: 9d popf <== NOT EXECUTED goto restart_reverse_search; 10c23b: eb cb jmp 10c208 <_Thread_queue_Enqueue_priority+0xa8> <== NOT EXECUTED } search_thread = (Thread_Control *) 10c23d: 8b 52 04 mov 0x4(%edx),%edx 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 ) ) { 10c240: 3b 55 e8 cmp -0x18(%ebp),%edx 10c243: 75 db jne 10c220 <_Thread_queue_Enqueue_priority+0xc0> 10c245: 8b 75 f0 mov -0x10(%ebp),%esi } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c248: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c24c: 75 3d jne 10c28b <_Thread_queue_Enqueue_priority+0x12b> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c24e: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c255: 3b 5d ec cmp -0x14(%ebp),%ebx 10c258: 74 1a je 10c274 <_Thread_queue_Enqueue_priority+0x114> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c25a: 8b 1a mov (%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c25c: 89 18 mov %ebx,(%eax) the_node->previous = search_node; 10c25e: 89 50 04 mov %edx,0x4(%eax) search_node->next = the_node; 10c261: 89 02 mov %eax,(%edx) next_node->previous = the_node; 10c263: 89 43 04 mov %eax,0x4(%ebx) the_thread->Wait.queue = the_thread_queue; 10c266: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c269: ff 75 f0 pushl -0x10(%ebp) 10c26c: 9d popf 10c26d: b8 01 00 00 00 mov $0x1,%eax return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c272: eb 1f jmp 10c293 <_Thread_queue_Enqueue_priority+0x133> 10c274: 83 c2 3c add $0x3c,%edx equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10c277: 8b 5a 04 mov 0x4(%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c27a: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c27c: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c27f: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c281: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c284: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c287: 56 push %esi 10c288: 9d popf 10c289: eb e2 jmp 10c26d <_Thread_queue_Enqueue_priority+0x10d> * 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; 10c28b: 8b 45 10 mov 0x10(%ebp),%eax 10c28e: 89 30 mov %esi,(%eax) return the_thread_queue->sync_state; 10c290: 8b 41 30 mov 0x30(%ecx),%eax } 10c293: 83 c4 10 add $0x10,%esp 10c296: 5b pop %ebx 10c297: 5e pop %esi 10c298: 5f pop %edi 10c299: c9 leave 10c29a: c3 ret 001165c0 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 1165c0: 55 push %ebp 1165c1: 89 e5 mov %esp,%ebp 1165c3: 57 push %edi 1165c4: 56 push %esi 1165c5: 53 push %ebx 1165c6: 83 ec 4c sub $0x4c,%esp 1165c9: 8b 5d 08 mov 0x8(%ebp),%ebx 1165cc: 8d 45 dc lea -0x24(%ebp),%eax 1165cf: 8d 55 e0 lea -0x20(%ebp),%edx 1165d2: 89 55 b4 mov %edx,-0x4c(%ebp) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 1165d5: 89 55 dc mov %edx,-0x24(%ebp) the_chain->permanent_null = NULL; 1165d8: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_chain->last = _Chain_Head(the_chain); 1165df: 89 45 e4 mov %eax,-0x1c(%ebp) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 1165e2: 8d 75 d0 lea -0x30(%ebp),%esi 1165e5: 8d 55 d4 lea -0x2c(%ebp),%edx 1165e8: 89 55 b0 mov %edx,-0x50(%ebp) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 1165eb: 89 55 d0 mov %edx,-0x30(%ebp) the_chain->permanent_null = NULL; 1165ee: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) the_chain->last = _Chain_Head(the_chain); 1165f5: 89 75 d8 mov %esi,-0x28(%ebp) */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1165f8: 8d 53 30 lea 0x30(%ebx),%edx 1165fb: 89 55 c0 mov %edx,-0x40(%ebp) /* * 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 ); 1165fe: 8d 7b 68 lea 0x68(%ebx),%edi static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 116601: 8d 4b 08 lea 0x8(%ebx),%ecx 116604: 89 4d b8 mov %ecx,-0x48(%ebp) static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 116607: 8d 53 40 lea 0x40(%ebx),%edx 11660a: 89 55 bc mov %edx,-0x44(%ebp) { /* * 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; 11660d: 8d 4d dc lea -0x24(%ebp),%ecx 116610: 89 4b 78 mov %ecx,0x78(%ebx) static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 116613: a1 0c d7 13 00 mov 0x13d70c,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 116618: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 11661b: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 11661e: 51 push %ecx 11661f: 8d 4d d0 lea -0x30(%ebp),%ecx 116622: 51 push %ecx 116623: 29 d0 sub %edx,%eax 116625: 50 push %eax 116626: ff 75 c0 pushl -0x40(%ebp) 116629: e8 ca 36 00 00 call 119cf8 <_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(); 11662e: a1 50 d6 13 00 mov 0x13d650,%eax 116633: 89 45 c4 mov %eax,-0x3c(%ebp) Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 116636: 8b 43 74 mov 0x74(%ebx),%eax /* * 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 ) { 116639: 83 c4 10 add $0x10,%esp 11663c: 39 45 c4 cmp %eax,-0x3c(%ebp) 11663f: 76 13 jbe 116654 <_Timer_server_Body+0x94> /* * 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 ); 116641: 52 push %edx 116642: 8d 55 d0 lea -0x30(%ebp),%edx 116645: 52 push %edx 116646: 8b 4d c4 mov -0x3c(%ebp),%ecx 116649: 29 c1 sub %eax,%ecx 11664b: 51 push %ecx 11664c: 57 push %edi 11664d: e8 a6 36 00 00 call 119cf8 <_Watchdog_Adjust_to_chain> 116652: eb 0f jmp 116663 <_Timer_server_Body+0xa3> } else if ( snapshot < last_snapshot ) { 116654: 73 10 jae 116666 <_Timer_server_Body+0xa6> /* * 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 ); 116656: 51 push %ecx 116657: 2b 45 c4 sub -0x3c(%ebp),%eax 11665a: 50 push %eax 11665b: 6a 01 push $0x1 11665d: 57 push %edi 11665e: e8 29 36 00 00 call 119c8c <_Watchdog_Adjust> 116663: 83 c4 10 add $0x10,%esp } watchdogs->last_snapshot = snapshot; 116666: 8b 45 c4 mov -0x3c(%ebp),%eax 116669: 89 43 74 mov %eax,0x74(%ebx) } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 11666c: 8b 43 78 mov 0x78(%ebx),%eax 11666f: 83 ec 0c sub $0xc,%esp 116672: 50 push %eax 116673: e8 3c 07 00 00 call 116db4 <_Chain_Get> if ( timer == NULL ) { 116678: 83 c4 10 add $0x10,%esp 11667b: 85 c0 test %eax,%eax 11667d: 74 29 je 1166a8 <_Timer_server_Body+0xe8> static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 11667f: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 116682: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 116685: 75 0b jne 116692 <_Timer_server_Body+0xd2> <== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116687: 52 push %edx <== NOT EXECUTED 116688: 52 push %edx <== NOT EXECUTED 116689: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11668c: 50 push %eax <== NOT EXECUTED 11668d: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 116690: eb 0c jmp 11669e <_Timer_server_Body+0xde> <== NOT EXECUTED } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116692: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 116695: 75 d5 jne 11666c <_Timer_server_Body+0xac> <== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116697: 51 push %ecx <== NOT EXECUTED 116698: 51 push %ecx <== NOT EXECUTED 116699: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11669c: 50 push %eax <== NOT EXECUTED 11669d: 57 push %edi <== NOT EXECUTED 11669e: e8 dd 36 00 00 call 119d80 <_Watchdog_Insert> <== NOT EXECUTED 1166a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1166a6: eb c4 jmp 11666c <_Timer_server_Body+0xac> <== NOT EXECUTED * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 1166a8: 9c pushf 1166a9: fa cli 1166aa: 58 pop %eax if ( _Chain_Is_empty( insert_chain ) ) { 1166ab: 8b 55 b4 mov -0x4c(%ebp),%edx 1166ae: 39 55 dc cmp %edx,-0x24(%ebp) 1166b1: 75 13 jne 1166c6 <_Timer_server_Body+0x106> ts->insert_chain = NULL; 1166b3: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) _ISR_Enable( level ); 1166ba: 50 push %eax 1166bb: 9d popf _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 ) ) { 1166bc: 8b 4d b0 mov -0x50(%ebp),%ecx 1166bf: 39 4d d0 cmp %ecx,-0x30(%ebp) 1166c2: 75 09 jne 1166cd <_Timer_server_Body+0x10d> 1166c4: eb 3e jmp 116704 <_Timer_server_Body+0x144> ts->insert_chain = NULL; _ISR_Enable( level ); break; } else { _ISR_Enable( level ); 1166c6: 50 push %eax <== NOT EXECUTED 1166c7: 9d popf <== NOT EXECUTED 1166c8: e9 46 ff ff ff jmp 116613 <_Timer_server_Body+0x53> <== 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 ); 1166cd: 9c pushf 1166ce: fa cli 1166cf: 5a pop %edx */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 1166d0: 8b 45 d0 mov -0x30(%ebp),%eax */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 1166d3: 3b 45 b0 cmp -0x50(%ebp),%eax 1166d6: 74 25 je 1166fd <_Timer_server_Body+0x13d> { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 1166d8: 8b 08 mov (%eax),%ecx the_chain->first = new_first; 1166da: 89 4d d0 mov %ecx,-0x30(%ebp) new_first->previous = _Chain_Head(the_chain); 1166dd: 89 71 04 mov %esi,0x4(%ecx) watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { 1166e0: 85 c0 test %eax,%eax 1166e2: 74 19 je 1166fd <_Timer_server_Body+0x13d> watchdog->state = WATCHDOG_INACTIVE; 1166e4: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 1166eb: 52 push %edx 1166ec: 9d popf /* * 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 ); 1166ed: 52 push %edx 1166ee: 52 push %edx 1166ef: ff 70 24 pushl 0x24(%eax) 1166f2: ff 70 20 pushl 0x20(%eax) 1166f5: ff 50 1c call *0x1c(%eax) } 1166f8: 83 c4 10 add $0x10,%esp 1166fb: eb d0 jmp 1166cd <_Timer_server_Body+0x10d> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 1166fd: 52 push %edx 1166fe: 9d popf 1166ff: e9 09 ff ff ff jmp 11660d <_Timer_server_Body+0x4d> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 116704: c6 43 7c 00 movb $0x0,0x7c(%ebx) 116708: a1 c0 d5 13 00 mov 0x13d5c0,%eax 11670d: 40 inc %eax 11670e: a3 c0 d5 13 00 mov %eax,0x13d5c0 /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 116713: 50 push %eax 116714: 50 push %eax 116715: 6a 08 push $0x8 116717: ff 33 pushl (%ebx) 116719: e8 4a 2e 00 00 call 119568 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 11671e: 89 d8 mov %ebx,%eax 116720: e8 0f fe ff ff call 116534 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 116725: 89 d8 mov %ebx,%eax 116727: e8 4e fe ff ff call 11657a <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 11672c: e8 14 25 00 00 call 118c45 <_Thread_Enable_dispatch> ts->active = true; 116731: c6 43 7c 01 movb $0x1,0x7c(%ebx) static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 116735: 59 pop %ecx 116736: ff 75 b8 pushl -0x48(%ebp) 116739: e8 5a 37 00 00 call 119e98 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 11673e: 5a pop %edx 11673f: ff 75 bc pushl -0x44(%ebp) 116742: e8 51 37 00 00 call 119e98 <_Watchdog_Remove> 116747: 83 c4 10 add $0x10,%esp 11674a: e9 be fe ff ff jmp 11660d <_Timer_server_Body+0x4d> 0011674f <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 11674f: 55 push %ebp 116750: 89 e5 mov %esp,%ebp 116752: 57 push %edi 116753: 56 push %esi 116754: 53 push %ebx 116755: 83 ec 2c sub $0x2c,%esp 116758: 8b 5d 08 mov 0x8(%ebp),%ebx 11675b: 8b 45 0c mov 0xc(%ebp),%eax if ( ts->insert_chain == NULL ) { 11675e: 8b 53 78 mov 0x78(%ebx),%edx 116761: 85 d2 test %edx,%edx 116763: 0f 85 e6 00 00 00 jne 11684f <_Timer_server_Schedule_operation_method+0x100> 116769: 8b 15 c0 d5 13 00 mov 0x13d5c0,%edx 11676f: 42 inc %edx 116770: 89 15 c0 d5 13 00 mov %edx,0x13d5c0 * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116776: 8b 50 38 mov 0x38(%eax),%edx 116779: 83 fa 01 cmp $0x1,%edx 11677c: 75 5a jne 1167d8 <_Timer_server_Schedule_operation_method+0x89> /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 11677e: 9c pushf 11677f: fa cli 116780: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116783: 8b 0d 0c d7 13 00 mov 0x13d70c,%ecx last_snapshot = ts->Interval_watchdogs.last_snapshot; 116789: 8b 73 3c mov 0x3c(%ebx),%esi */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 11678c: 8b 53 30 mov 0x30(%ebx),%edx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 11678f: 8d 7b 34 lea 0x34(%ebx),%edi 116792: 39 fa cmp %edi,%edx 116794: 74 19 je 1167af <_Timer_server_Schedule_operation_method+0x60> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116796: 89 cf mov %ecx,%edi 116798: 29 f7 sub %esi,%edi 11679a: 89 7d e4 mov %edi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 11679d: 8b 7a 10 mov 0x10(%edx),%edi if (delta_interval > delta) { 1167a0: 31 f6 xor %esi,%esi 1167a2: 3b 7d e4 cmp -0x1c(%ebp),%edi 1167a5: 76 05 jbe 1167ac <_Timer_server_Schedule_operation_method+0x5d> delta_interval -= delta; 1167a7: 89 fe mov %edi,%esi 1167a9: 2b 75 e4 sub -0x1c(%ebp),%esi } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 1167ac: 89 72 10 mov %esi,0x10(%edx) } ts->Interval_watchdogs.last_snapshot = snapshot; 1167af: 89 4b 3c mov %ecx,0x3c(%ebx) _ISR_Enable( level ); 1167b2: ff 75 e0 pushl -0x20(%ebp) 1167b5: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 1167b6: 57 push %edi 1167b7: 57 push %edi 1167b8: 83 c0 10 add $0x10,%eax 1167bb: 50 push %eax 1167bc: 8d 43 30 lea 0x30(%ebx),%eax 1167bf: 50 push %eax 1167c0: e8 bb 35 00 00 call 119d80 <_Watchdog_Insert> if ( !ts->active ) { 1167c5: 8a 43 7c mov 0x7c(%ebx),%al 1167c8: 83 c4 10 add $0x10,%esp 1167cb: 84 c0 test %al,%al 1167cd: 75 74 jne 116843 <_Timer_server_Schedule_operation_method+0xf4> _Timer_server_Reset_interval_system_watchdog( ts ); 1167cf: 89 d8 mov %ebx,%eax 1167d1: e8 5e fd ff ff call 116534 <_Timer_server_Reset_interval_system_watchdog> 1167d6: eb 6b jmp 116843 <_Timer_server_Schedule_operation_method+0xf4> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 1167d8: 83 fa 03 cmp $0x3,%edx 1167db: 75 66 jne 116843 <_Timer_server_Schedule_operation_method+0xf4> /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 1167dd: 9c pushf 1167de: fa cli 1167df: 8f 45 e0 popl -0x20(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 1167e2: 8b 0d 50 d6 13 00 mov 0x13d650,%ecx last_snapshot = ts->TOD_watchdogs.last_snapshot; 1167e8: 8b 53 74 mov 0x74(%ebx),%edx */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 1167eb: 8b 73 68 mov 0x68(%ebx),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 1167ee: 8d 7b 6c lea 0x6c(%ebx),%edi 1167f1: 39 fe cmp %edi,%esi 1167f3: 74 27 je 11681c <_Timer_server_Schedule_operation_method+0xcd> if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 1167f5: 8b 7e 10 mov 0x10(%esi),%edi 1167f8: 89 7d d4 mov %edi,-0x2c(%ebp) if ( snapshot > last_snapshot ) { 1167fb: 39 d1 cmp %edx,%ecx 1167fd: 76 15 jbe 116814 <_Timer_server_Schedule_operation_method+0xc5> /* * We advanced in time. */ delta = snapshot - last_snapshot; 1167ff: 89 cf mov %ecx,%edi 116801: 29 d7 sub %edx,%edi 116803: 89 7d e4 mov %edi,-0x1c(%ebp) if (delta_interval > delta) { 116806: 31 d2 xor %edx,%edx 116808: 39 7d d4 cmp %edi,-0x2c(%ebp) 11680b: 76 0c jbe 116819 <_Timer_server_Schedule_operation_method+0xca> delta_interval -= delta; 11680d: 8b 55 d4 mov -0x2c(%ebp),%edx 116810: 29 fa sub %edi,%edx 116812: eb 05 jmp 116819 <_Timer_server_Schedule_operation_method+0xca> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 116814: 03 55 d4 add -0x2c(%ebp),%edx delta_interval += delta; 116817: 29 ca sub %ecx,%edx } first_watchdog->delta_interval = delta_interval; 116819: 89 56 10 mov %edx,0x10(%esi) } ts->TOD_watchdogs.last_snapshot = snapshot; 11681c: 89 4b 74 mov %ecx,0x74(%ebx) _ISR_Enable( level ); 11681f: ff 75 e0 pushl -0x20(%ebp) 116822: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116823: 56 push %esi 116824: 56 push %esi 116825: 83 c0 10 add $0x10,%eax 116828: 50 push %eax 116829: 8d 43 68 lea 0x68(%ebx),%eax 11682c: 50 push %eax 11682d: e8 4e 35 00 00 call 119d80 <_Watchdog_Insert> if ( !ts->active ) { 116832: 8a 43 7c mov 0x7c(%ebx),%al 116835: 83 c4 10 add $0x10,%esp 116838: 84 c0 test %al,%al 11683a: 75 07 jne 116843 <_Timer_server_Schedule_operation_method+0xf4> _Timer_server_Reset_tod_system_watchdog( ts ); 11683c: 89 d8 mov %ebx,%eax 11683e: e8 37 fd ff ff call 11657a <_Timer_server_Reset_tod_system_watchdog> * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); } } 116843: 8d 65 f4 lea -0xc(%ebp),%esp 116846: 5b pop %ebx 116847: 5e pop %esi 116848: 5f pop %edi 116849: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 11684a: e9 f6 23 00 00 jmp 118c45 <_Thread_Enable_dispatch> * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 11684f: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED 116852: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 116855: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } } 116858: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11685b: 5b pop %ebx <== NOT EXECUTED 11685c: 5e pop %esi <== NOT EXECUTED 11685d: 5f pop %edi <== NOT EXECUTED 11685e: c9 leave <== NOT EXECUTED * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 11685f: e9 2c 05 00 00 jmp 116d90 <_Chain_Append> <== NOT EXECUTED 001106ac : } void pthread_exit( void *value_ptr ) { 1106ac: 55 push %ebp 1106ad: 89 e5 mov %esp,%ebp 1106af: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 1106b2: ff 75 08 pushl 0x8(%ebp) 1106b5: ff 35 a8 42 12 00 pushl 0x1242a8 1106bb: e8 88 ff ff ff call 110648 <_POSIX_Thread_Exit> 1106c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1106c3: c9 leave <== NOT EXECUTED 1106c4: c3 ret <== NOT EXECUTED 0010a434 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a434: 55 push %ebp 10a435: 89 e5 mov %esp,%ebp 10a437: 53 push %ebx 10a438: 83 ec 04 sub $0x4,%esp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10a43b: a1 74 62 12 00 mov 0x126274,%eax 10a440: 85 c0 test %eax,%eax 10a442: 75 48 jne 10a48c return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a444: a1 98 62 12 00 mov 0x126298,%eax 10a449: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax 10a44f: 8b 15 dc 61 12 00 mov 0x1261dc,%edx 10a455: 42 inc %edx 10a456: 89 15 dc 61 12 00 mov %edx,0x1261dc _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a45c: 31 db xor %ebx,%ebx 10a45e: 83 b8 d4 00 00 00 00 cmpl $0x0,0xd4(%eax) 10a465: 75 0a jne 10a471 /* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate)); int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype)); void _EXFUN(pthread_testcancel, (void)); 10a467: 83 b8 dc 00 00 00 00 cmpl $0x0,0xdc(%eax) 10a46e: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a471: e8 6f 22 00 00 call 10c6e5 <_Thread_Enable_dispatch> if ( cancel ) 10a476: 84 db test %bl,%bl 10a478: 74 12 je 10a48c _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a47a: 50 push %eax 10a47b: 50 push %eax 10a47c: 6a ff push $0xffffffff 10a47e: ff 35 98 62 12 00 pushl 0x126298 10a484: e8 a7 4c 00 00 call 10f130 <_POSIX_Thread_Exit> 10a489: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a48c: 8b 5d fc mov -0x4(%ebp),%ebx 10a48f: c9 leave 10a490: c3 ret 0010ba50 : rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 10ba50: 55 push %ebp 10ba51: 89 e5 mov %esp,%ebp 10ba53: 56 push %esi 10ba54: 53 push %ebx 10ba55: 83 ec 10 sub $0x10,%esp 10ba58: 8b 55 08 mov 0x8(%ebp),%edx 10ba5b: 8b 75 0c mov 0xc(%ebp),%esi 10ba5e: 8b 5d 10 mov 0x10(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10ba61: b8 16 00 00 00 mov $0x16,%eax 10ba66: 80 3d c4 41 12 00 00 cmpb $0x0,0x1241c4 10ba6d: 74 5d je 10bacc return RTEMS_NOT_CONFIGURED; if ( !note ) 10ba6f: b0 09 mov $0x9,%al 10ba71: 85 db test %ebx,%ebx 10ba73: 74 57 je 10bacc /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10ba75: b0 0a mov $0xa,%al 10ba77: 83 fe 0f cmp $0xf,%esi 10ba7a: 77 50 ja 10bacc /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10ba7c: 85 d2 test %edx,%edx 10ba7e: 74 0a je 10ba8a _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 10ba80: a1 3c 85 12 00 mov 0x12853c,%eax 10ba85: 3b 50 08 cmp 0x8(%eax),%edx 10ba88: 75 13 jne 10ba9d api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10ba8a: a1 3c 85 12 00 mov 0x12853c,%eax 10ba8f: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax 10ba95: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10ba99: 89 03 mov %eax,(%ebx) 10ba9b: eb 2d jmp 10baca return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10ba9d: 50 push %eax 10ba9e: 50 push %eax 10ba9f: 8d 45 f4 lea -0xc(%ebp),%eax 10baa2: 50 push %eax 10baa3: 52 push %edx 10baa4: e8 7b 1c 00 00 call 10d724 <_Thread_Get> 10baa9: 89 c2 mov %eax,%edx switch ( location ) { 10baab: 83 c4 10 add $0x10,%esp 10baae: b8 04 00 00 00 mov $0x4,%eax 10bab3: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10bab7: 75 13 jne 10bacc case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10bab9: 8b 82 f4 00 00 00 mov 0xf4(%edx),%eax <== NOT EXECUTED 10babf: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax <== NOT EXECUTED 10bac3: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10bac5: e8 37 1c 00 00 call 10d701 <_Thread_Enable_dispatch> <== NOT EXECUTED 10baca: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bacc: 8d 65 f8 lea -0x8(%ebp),%esp 10bacf: 5b pop %ebx 10bad0: 5e pop %esi 10bad1: c9 leave 10bad2: c3 ret