=============================================================================== 0010ce08 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10ce08: 55 push %ebp 10ce09: 89 e5 mov %esp,%ebp 10ce0b: 53 push %ebx 10ce0c: 83 ec 04 sub $0x4,%esp 10ce0f: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10ce12: 8b 15 3c 88 12 00 mov 0x12883c,%edx * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10ce18: 9c pushf 10ce19: fa cli 10ce1a: 58 pop %eax if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10ce1b: 8b 4b 44 mov 0x44(%ebx),%ecx 10ce1e: 85 c9 test %ecx,%ecx 10ce20: 75 0b jne 10ce2d <_CORE_RWLock_Release+0x25> _ISR_Enable( level ); 10ce22: 50 push %eax 10ce23: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ce24: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) return CORE_RWLOCK_SUCCESSFUL; 10ce2b: eb 72 jmp 10ce9f <_CORE_RWLock_Release+0x97> } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10ce2d: 49 dec %ecx 10ce2e: 75 0f jne 10ce3f <_CORE_RWLock_Release+0x37> the_rwlock->number_of_readers -= 1; 10ce30: 8b 4b 48 mov 0x48(%ebx),%ecx 10ce33: 49 dec %ecx 10ce34: 89 4b 48 mov %ecx,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10ce37: 85 c9 test %ecx,%ecx 10ce39: 74 04 je 10ce3f <_CORE_RWLock_Release+0x37> /* must be unlocked again */ _ISR_Enable( level ); 10ce3b: 50 push %eax 10ce3c: 9d popf return CORE_RWLOCK_SUCCESSFUL; 10ce3d: eb 60 jmp 10ce9f <_CORE_RWLock_Release+0x97> } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce3f: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10ce46: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10ce4d: 50 push %eax 10ce4e: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10ce4f: 83 ec 0c sub $0xc,%esp 10ce52: 53 push %ebx 10ce53: e8 60 17 00 00 call 10e5b8 <_Thread_queue_Dequeue> if ( next ) { 10ce58: 83 c4 10 add $0x10,%esp 10ce5b: 85 c0 test %eax,%eax 10ce5d: 74 40 je 10ce9f <_CORE_RWLock_Release+0x97> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10ce5f: 83 78 30 01 cmpl $0x1,0x30(%eax) 10ce63: 75 09 jne 10ce6e <_CORE_RWLock_Release+0x66> the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10ce65: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10ce6c: eb 31 jmp 10ce9f <_CORE_RWLock_Release+0x97> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10ce6e: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10ce71: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 10ce78: 83 ec 0c sub $0xc,%esp 10ce7b: 53 push %ebx 10ce7c: e8 2f 1b 00 00 call 10e9b0 <_Thread_queue_First> if ( !next || 10ce81: 83 c4 10 add $0x10,%esp 10ce84: 85 c0 test %eax,%eax 10ce86: 74 17 je 10ce9f <_CORE_RWLock_Release+0x97> 10ce88: 83 78 30 01 cmpl $0x1,0x30(%eax) 10ce8c: 74 11 je 10ce9f <_CORE_RWLock_Release+0x97><== NEVER TAKEN next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 10ce8e: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10ce91: 52 push %edx 10ce92: 52 push %edx 10ce93: 50 push %eax 10ce94: 53 push %ebx 10ce95: e8 06 1a 00 00 call 10e8a0 <_Thread_queue_Extract> } 10ce9a: 83 c4 10 add $0x10,%esp 10ce9d: eb d9 jmp 10ce78 <_CORE_RWLock_Release+0x70> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10ce9f: 31 c0 xor %eax,%eax 10cea1: 8b 5d fc mov -0x4(%ebp),%ebx 10cea4: c9 leave 10cea5: c3 ret =============================================================================== 0010cea8 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10cea8: 55 push %ebp 10cea9: 89 e5 mov %esp,%ebp 10ceab: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10ceae: 8d 45 f4 lea -0xc(%ebp),%eax 10ceb1: 50 push %eax 10ceb2: ff 75 08 pushl 0x8(%ebp) 10ceb5: e8 aa 13 00 00 call 10e264 <_Thread_Get> switch ( location ) { 10ceba: 83 c4 10 add $0x10,%esp 10cebd: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10cec1: 75 17 jne 10ceda <_CORE_RWLock_Timeout+0x32><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10cec3: 83 ec 0c sub $0xc,%esp 10cec6: 50 push %eax 10cec7: e8 b0 1b 00 00 call 10ea7c <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10cecc: a1 f0 82 12 00 mov 0x1282f0,%eax 10ced1: 48 dec %eax 10ced2: a3 f0 82 12 00 mov %eax,0x1282f0 10ced7: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10ceda: c9 leave 10cedb: c3 ret =============================================================================== 00117368 <_CORE_message_queue_Broadcast>: Objects_Id id __attribute__((unused)), CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)), #endif uint32_t *count ) { 117368: 55 push %ebp 117369: 89 e5 mov %esp,%ebp 11736b: 57 push %edi 11736c: 56 push %esi 11736d: 53 push %ebx 11736e: 83 ec 1c sub $0x1c,%esp 117371: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; 117374: b8 01 00 00 00 mov $0x1,%eax { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 117379: 8b 55 10 mov 0x10(%ebp),%edx 11737c: 3b 53 4c cmp 0x4c(%ebx),%edx 11737f: 77 4e ja 1173cf <_CORE_message_queue_Broadcast+0x67><== NEVER TAKEN * 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 ) { 117381: 83 7b 48 00 cmpl $0x0,0x48(%ebx) 117385: 75 09 jne 117390 <_CORE_message_queue_Broadcast+0x28> 117387: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 11738e: eb 23 jmp 1173b3 <_CORE_message_queue_Broadcast+0x4b> *count = 0; 117390: 8b 45 1c mov 0x1c(%ebp),%eax 117393: c7 00 00 00 00 00 movl $0x0,(%eax) 117399: eb 32 jmp 1173cd <_CORE_message_queue_Broadcast+0x65> */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { waitp = &the_thread->Wait; number_broadcasted += 1; 11739b: ff 45 e4 incl -0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 11739e: 8b 42 2c mov 0x2c(%edx),%eax 1173a1: 89 c7 mov %eax,%edi 1173a3: 8b 75 0c mov 0xc(%ebp),%esi 1173a6: 8b 4d 10 mov 0x10(%ebp),%ecx 1173a9: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 1173ab: 8b 42 28 mov 0x28(%edx),%eax 1173ae: 8b 55 10 mov 0x10(%ebp),%edx 1173b1: 89 10 mov %edx,(%eax) /* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = 1173b3: 83 ec 0c sub $0xc,%esp 1173b6: 53 push %ebx 1173b7: e8 94 24 00 00 call 119850 <_Thread_queue_Dequeue> 1173bc: 89 c2 mov %eax,%edx 1173be: 83 c4 10 add $0x10,%esp 1173c1: 85 c0 test %eax,%eax 1173c3: 75 d6 jne 11739b <_CORE_message_queue_Broadcast+0x33> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 1173c5: 8b 55 e4 mov -0x1c(%ebp),%edx 1173c8: 8b 45 1c mov 0x1c(%ebp),%eax 1173cb: 89 10 mov %edx,(%eax) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 1173cd: 31 c0 xor %eax,%eax } 1173cf: 8d 65 f4 lea -0xc(%ebp),%esp 1173d2: 5b pop %ebx 1173d3: 5e pop %esi 1173d4: 5f pop %edi 1173d5: c9 leave 1173d6: c3 ret =============================================================================== 00112214 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { 112214: 55 push %ebp 112215: 89 e5 mov %esp,%ebp 112217: 57 push %edi 112218: 56 push %esi 112219: 53 push %ebx 11221a: 83 ec 1c sub $0x1c,%esp 11221d: 8b 5d 08 mov 0x8(%ebp),%ebx 112220: 8b 7d 10 mov 0x10(%ebp),%edi 112223: 8b 55 14 mov 0x14(%ebp),%edx size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 112226: 89 7b 44 mov %edi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 112229: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 112230: 89 53 4c mov %edx,0x4c(%ebx) CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 112233: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) the_message_queue->notify_argument = the_argument; 11223a: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) /* * Round size up to multiple of a pointer for chain init and * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { 112241: 89 d0 mov %edx,%eax 112243: f6 c2 03 test $0x3,%dl 112246: 74 0c je 112254 <_CORE_message_queue_Initialize+0x40> allocated_message_size += sizeof(uint32_t); 112248: 83 c0 04 add $0x4,%eax allocated_message_size &= ~(sizeof(uint32_t) - 1); 11224b: 83 e0 fc and $0xfffffffc,%eax } if (allocated_message_size < maximum_message_size) return false; 11224e: 31 f6 xor %esi,%esi if (allocated_message_size & (sizeof(uint32_t) - 1)) { allocated_message_size += sizeof(uint32_t); allocated_message_size &= ~(sizeof(uint32_t) - 1); } if (allocated_message_size < maximum_message_size) 112250: 39 d0 cmp %edx,%eax 112252: 72 68 jb 1122bc <_CORE_message_queue_Initialize+0xa8><== NEVER TAKEN /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); 112254: 8d 50 14 lea 0x14(%eax),%edx /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * 112257: 89 d1 mov %edx,%ecx 112259: 0f af cf imul %edi,%ecx (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) return false; 11225c: 31 f6 xor %esi,%esi * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 11225e: 39 c1 cmp %eax,%ecx 112260: 72 5a jb 1122bc <_CORE_message_queue_Initialize+0xa8><== NEVER TAKEN /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); 112262: 83 ec 0c sub $0xc,%esp 112265: 51 push %ecx 112266: 89 55 e4 mov %edx,-0x1c(%ebp) 112269: e8 74 27 00 00 call 1149e2 <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 11226e: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 112271: 83 c4 10 add $0x10,%esp 112274: 85 c0 test %eax,%eax 112276: 8b 55 e4 mov -0x1c(%ebp),%edx 112279: 74 41 je 1122bc <_CORE_message_queue_Initialize+0xa8> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 11227b: 52 push %edx 11227c: 57 push %edi 11227d: 50 push %eax 11227e: 8d 43 68 lea 0x68(%ebx),%eax 112281: 50 push %eax 112282: e8 b5 4a 00 00 call 116d3c <_Chain_Initialize> RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 112287: 8d 43 54 lea 0x54(%ebx),%eax 11228a: 89 43 50 mov %eax,0x50(%ebx) head->next = tail; head->previous = NULL; 11228d: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 112294: 8d 43 50 lea 0x50(%ebx),%eax 112297: 89 43 58 mov %eax,0x58(%ebx) allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 11229a: 6a 06 push $0x6 11229c: 68 80 00 00 00 push $0x80 1122a1: 8b 45 0c mov 0xc(%ebp),%eax 1122a4: 83 38 01 cmpl $0x1,(%eax) 1122a7: 0f 94 c0 sete %al 1122aa: 0f b6 c0 movzbl %al,%eax 1122ad: 50 push %eax 1122ae: 53 push %ebx 1122af: e8 04 1f 00 00 call 1141b8 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 1122b4: 83 c4 20 add $0x20,%esp 1122b7: be 01 00 00 00 mov $0x1,%esi } 1122bc: 89 f0 mov %esi,%eax 1122be: 8d 65 f4 lea -0xc(%ebp),%esp 1122c1: 5b pop %ebx 1122c2: 5e pop %esi 1122c3: 5f pop %edi 1122c4: c9 leave 1122c5: c3 ret =============================================================================== 001122c8 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 1122c8: 55 push %ebp 1122c9: 89 e5 mov %esp,%ebp 1122cb: 57 push %edi 1122cc: 56 push %esi 1122cd: 53 push %ebx 1122ce: 83 ec 2c sub $0x2c,%esp 1122d1: 8b 55 08 mov 0x8(%ebp),%edx 1122d4: 8b 45 0c mov 0xc(%ebp),%eax 1122d7: 89 45 dc mov %eax,-0x24(%ebp) 1122da: 8b 5d 10 mov 0x10(%ebp),%ebx 1122dd: 89 5d e0 mov %ebx,-0x20(%ebp) 1122e0: 8b 4d 14 mov 0x14(%ebp),%ecx 1122e3: 8b 75 1c mov 0x1c(%ebp),%esi 1122e6: 89 75 d4 mov %esi,-0x2c(%ebp) 1122e9: 8a 45 18 mov 0x18(%ebp),%al 1122ec: 88 45 db mov %al,-0x25(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; executing = _Thread_Executing; 1122ef: a1 94 c9 12 00 mov 0x12c994,%eax executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 1122f4: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _ISR_Disable( level ); 1122fb: 9c pushf 1122fc: fa cli 1122fd: 8f 45 e4 popl -0x1c(%ebp) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 112300: 8b 5a 50 mov 0x50(%edx),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 112303: 8d 72 54 lea 0x54(%edx),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 112306: 39 f3 cmp %esi,%ebx 112308: 0f 84 8a 00 00 00 je 112398 <_CORE_message_queue_Seize+0xd0> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 11230e: 8b 33 mov (%ebx),%esi head->next = new_first; 112310: 89 72 50 mov %esi,0x50(%edx) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 112313: 8d 7a 50 lea 0x50(%edx),%edi 112316: 89 7e 04 mov %edi,0x4(%esi) executing = _Thread_Executing; executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { 112319: 85 db test %ebx,%ebx 11231b: 74 7b je 112398 <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN the_message_queue->number_of_pending_messages -= 1; 11231d: ff 4a 48 decl 0x48(%edx) _ISR_Enable( level ); 112320: ff 75 e4 pushl -0x1c(%ebp) 112323: 9d popf *size_p = the_message->Contents.size; 112324: 8b 43 0c mov 0xc(%ebx),%eax 112327: 89 01 mov %eax,(%ecx) _Thread_Executing->Wait.count = 112329: 8b 73 08 mov 0x8(%ebx),%esi 11232c: a1 94 c9 12 00 mov 0x12c994,%eax 112331: 89 70 24 mov %esi,0x24(%eax) _CORE_message_queue_Get_message_priority( the_message ); _CORE_message_queue_Copy_buffer( the_message->Contents.buffer, 112334: 8d 73 10 lea 0x10(%ebx),%esi 112337: 89 75 e4 mov %esi,-0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 11233a: 8b 09 mov (%ecx),%ecx 11233c: 8b 7d e0 mov -0x20(%ebp),%edi 11233f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) * is not, then we can go ahead and free the buffer. * * NOTE: If we note that the queue was not full before this receive, * then we can avoid this dequeue. */ the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 112341: 83 ec 0c sub $0xc,%esp 112344: 52 push %edx 112345: 89 55 d0 mov %edx,-0x30(%ebp) 112348: e8 33 1b 00 00 call 113e80 <_Thread_queue_Dequeue> if ( !the_thread ) { 11234d: 83 c4 10 add $0x10,%esp 112350: 85 c0 test %eax,%eax 112352: 8b 55 d0 mov -0x30(%ebp),%edx 112355: 75 15 jne 11236c <_CORE_message_queue_Seize+0xa4> RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer ( CORE_message_queue_Control *the_message_queue, CORE_message_queue_Buffer_control *the_message ) { _Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node ); 112357: 89 5d 0c mov %ebx,0xc(%ebp) 11235a: 83 c2 68 add $0x68,%edx 11235d: 89 55 08 mov %edx,0x8(%ebp) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 112360: 8d 65 f4 lea -0xc(%ebp),%esp 112363: 5b pop %ebx 112364: 5e pop %esi 112365: 5f pop %edi 112366: c9 leave 112367: e9 28 fe ff ff jmp 112194 <_Chain_Append> CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 11236c: 8b 48 24 mov 0x24(%eax),%ecx 11236f: 89 4b 08 mov %ecx,0x8(%ebx) */ _CORE_message_queue_Set_message_priority( the_message, the_thread->Wait.count ); the_message->Contents.size = (size_t) the_thread->Wait.option; 112372: 8b 48 30 mov 0x30(%eax),%ecx 112375: 89 4b 0c mov %ecx,0xc(%ebx) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 112378: 8b 70 2c mov 0x2c(%eax),%esi 11237b: 8b 7d e4 mov -0x1c(%ebp),%edi 11237e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 112380: 8b 43 08 mov 0x8(%ebx),%eax 112383: 89 45 10 mov %eax,0x10(%ebp) 112386: 89 5d 0c mov %ebx,0xc(%ebp) 112389: 89 55 08 mov %edx,0x8(%ebp) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 11238c: 8d 65 f4 lea -0xc(%ebp),%esp 11238f: 5b pop %ebx 112390: 5e pop %esi 112391: 5f pop %edi 112392: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 112393: e9 dc 49 00 00 jmp 116d74 <_CORE_message_queue_Insert_message> return; } #endif } if ( !wait ) { 112398: 80 7d db 00 cmpb $0x0,-0x25(%ebp) 11239c: 75 13 jne 1123b1 <_CORE_message_queue_Seize+0xe9> _ISR_Enable( level ); 11239e: ff 75 e4 pushl -0x1c(%ebp) 1123a1: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 1123a2: c7 40 34 04 00 00 00 movl $0x4,0x34(%eax) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 1123a9: 8d 65 f4 lea -0xc(%ebp),%esp 1123ac: 5b pop %ebx 1123ad: 5e pop %esi 1123ae: 5f pop %edi 1123af: c9 leave 1123b0: c3 ret RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 1123b1: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; return; } _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 1123b8: 89 50 44 mov %edx,0x44(%eax) executing->Wait.id = id; 1123bb: 8b 5d dc mov -0x24(%ebp),%ebx 1123be: 89 58 20 mov %ebx,0x20(%eax) executing->Wait.return_argument_second.mutable_object = buffer; 1123c1: 8b 75 e0 mov -0x20(%ebp),%esi 1123c4: 89 70 2c mov %esi,0x2c(%eax) executing->Wait.return_argument = size_p; 1123c7: 89 48 28 mov %ecx,0x28(%eax) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 1123ca: ff 75 e4 pushl -0x1c(%ebp) 1123cd: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 1123ce: c7 45 10 68 42 11 00 movl $0x114268,0x10(%ebp) 1123d5: 8b 45 d4 mov -0x2c(%ebp),%eax 1123d8: 89 45 0c mov %eax,0xc(%ebp) 1123db: 89 55 08 mov %edx,0x8(%ebp) } 1123de: 8d 65 f4 lea -0xc(%ebp),%esp 1123e1: 5b pop %ebx 1123e2: 5e pop %esi 1123e3: 5f pop %edi 1123e4: c9 leave executing->Wait.return_argument_second.mutable_object = buffer; executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 1123e5: e9 a2 1b 00 00 jmp 113f8c <_Thread_queue_Enqueue_with_handler> =============================================================================== 0010ac29 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10ac29: 55 push %ebp 10ac2a: 89 e5 mov %esp,%ebp 10ac2c: 53 push %ebx 10ac2d: 83 ec 14 sub $0x14,%esp 10ac30: 8b 5d 08 mov 0x8(%ebp),%ebx 10ac33: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10ac36: a1 e0 42 12 00 mov 0x1242e0,%eax 10ac3b: 85 c0 test %eax,%eax 10ac3d: 74 19 je 10ac58 <_CORE_mutex_Seize+0x2f> 10ac3f: 84 d2 test %dl,%dl 10ac41: 74 15 je 10ac58 <_CORE_mutex_Seize+0x2f><== NEVER TAKEN 10ac43: 83 3d 5c 44 12 00 01 cmpl $0x1,0x12445c 10ac4a: 76 0c jbe 10ac58 <_CORE_mutex_Seize+0x2f> 10ac4c: 53 push %ebx 10ac4d: 6a 12 push $0x12 10ac4f: 6a 00 push $0x0 10ac51: 6a 00 push $0x0 10ac53: e8 e4 05 00 00 call 10b23c <_Internal_error_Occurred> 10ac58: 51 push %ecx 10ac59: 51 push %ecx 10ac5a: 8d 45 18 lea 0x18(%ebp),%eax 10ac5d: 50 push %eax 10ac5e: 53 push %ebx 10ac5f: 88 55 f4 mov %dl,-0xc(%ebp) 10ac62: e8 8d 47 00 00 call 10f3f4 <_CORE_mutex_Seize_interrupt_trylock> 10ac67: 83 c4 10 add $0x10,%esp 10ac6a: 85 c0 test %eax,%eax 10ac6c: 8a 55 f4 mov -0xc(%ebp),%dl 10ac6f: 74 48 je 10acb9 <_CORE_mutex_Seize+0x90> 10ac71: 84 d2 test %dl,%dl 10ac73: 75 12 jne 10ac87 <_CORE_mutex_Seize+0x5e> 10ac75: ff 75 18 pushl 0x18(%ebp) 10ac78: 9d popf 10ac79: a1 2c 48 12 00 mov 0x12482c,%eax 10ac7e: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) 10ac85: eb 32 jmp 10acb9 <_CORE_mutex_Seize+0x90> 10ac87: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10ac8e: a1 2c 48 12 00 mov 0x12482c,%eax 10ac93: 89 58 44 mov %ebx,0x44(%eax) 10ac96: 8b 55 0c mov 0xc(%ebp),%edx 10ac99: 89 50 20 mov %edx,0x20(%eax) 10ac9c: a1 e0 42 12 00 mov 0x1242e0,%eax 10aca1: 40 inc %eax 10aca2: a3 e0 42 12 00 mov %eax,0x1242e0 10aca7: ff 75 18 pushl 0x18(%ebp) 10acaa: 9d popf 10acab: 50 push %eax 10acac: 50 push %eax 10acad: ff 75 14 pushl 0x14(%ebp) 10acb0: 53 push %ebx 10acb1: e8 26 ff ff ff call 10abdc <_CORE_mutex_Seize_interrupt_blocking> 10acb6: 83 c4 10 add $0x10,%esp } 10acb9: 8b 5d fc mov -0x4(%ebp),%ebx 10acbc: c9 leave 10acbd: c3 ret =============================================================================== 0010ade4 <_CORE_semaphore_Surrender>: CORE_semaphore_Status _CORE_semaphore_Surrender( CORE_semaphore_Control *the_semaphore, Objects_Id id, CORE_semaphore_API_mp_support_callout api_semaphore_mp_support ) { 10ade4: 55 push %ebp 10ade5: 89 e5 mov %esp,%ebp 10ade7: 53 push %ebx 10ade8: 83 ec 10 sub $0x10,%esp 10adeb: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10adee: 53 push %ebx 10adef: e8 5c 16 00 00 call 10c450 <_Thread_queue_Dequeue> 10adf4: 89 c2 mov %eax,%edx 10adf6: 83 c4 10 add $0x10,%esp { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10adf9: 31 c0 xor %eax,%eax if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10adfb: 85 d2 test %edx,%edx 10adfd: 75 15 jne 10ae14 <_CORE_semaphore_Surrender+0x30> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 10adff: 9c pushf 10ae00: fa cli 10ae01: 59 pop %ecx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10ae02: 8b 53 48 mov 0x48(%ebx),%edx the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10ae05: b0 04 mov $0x4,%al (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10ae07: 3b 53 40 cmp 0x40(%ebx),%edx 10ae0a: 73 06 jae 10ae12 <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN the_semaphore->count += 1; 10ae0c: 42 inc %edx 10ae0d: 89 53 48 mov %edx,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10ae10: 30 c0 xor %al,%al _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 10ae12: 51 push %ecx 10ae13: 9d popf } return status; } 10ae14: 8b 5d fc mov -0x4(%ebp),%ebx 10ae17: c9 leave 10ae18: c3 ret =============================================================================== 00109d48 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109d48: 55 push %ebp 109d49: 89 e5 mov %esp,%ebp 109d4b: 57 push %edi 109d4c: 56 push %esi 109d4d: 53 push %ebx 109d4e: 83 ec 2c sub $0x2c,%esp 109d51: 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 ]; 109d54: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi option_set = (rtems_option) the_thread->Wait.option; 109d5a: 8b 43 30 mov 0x30(%ebx),%eax 109d5d: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109d60: 9c pushf 109d61: fa cli 109d62: 58 pop %eax pending_events = api->pending_events; 109d63: 8b 17 mov (%edi),%edx 109d65: 89 55 d4 mov %edx,-0x2c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109d68: 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 ) ) { 109d6b: 21 f2 and %esi,%edx 109d6d: 75 07 jne 109d76 <_Event_Surrender+0x2e> _ISR_Enable( level ); 109d6f: 50 push %eax 109d70: 9d popf return; 109d71: e9 af 00 00 00 jmp 109e25 <_Event_Surrender+0xdd> /* * 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() && 109d76: 83 3d 28 48 12 00 00 cmpl $0x0,0x124828 109d7d: 74 49 je 109dc8 <_Event_Surrender+0x80> 109d7f: 3b 1d 2c 48 12 00 cmp 0x12482c,%ebx 109d85: 75 41 jne 109dc8 <_Event_Surrender+0x80> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109d87: 8b 0d 00 4c 12 00 mov 0x124c00,%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() && _Thread_Is_executing( the_thread ) && 109d8d: 83 f9 02 cmp $0x2,%ecx 109d90: 74 09 je 109d9b <_Event_Surrender+0x53> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109d92: 8b 0d 00 4c 12 00 mov 0x124c00,%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() && _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109d98: 49 dec %ecx 109d99: 75 2d jne 109dc8 <_Event_Surrender+0x80> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109d9b: 39 f2 cmp %esi,%edx 109d9d: 74 06 je 109da5 <_Event_Surrender+0x5d> 109d9f: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109da3: 74 1f je 109dc4 <_Event_Surrender+0x7c> <== NEVER TAKEN RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear( rtems_event_set the_event_set, rtems_event_set the_mask ) { return ( the_event_set & ~(the_mask) ); 109da5: 89 d6 mov %edx,%esi 109da7: f7 d6 not %esi 109da9: 23 75 d4 and -0x2c(%ebp),%esi 109dac: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 109dae: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109db5: 8b 4b 28 mov 0x28(%ebx),%ecx 109db8: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109dba: c7 05 00 4c 12 00 03 movl $0x3,0x124c00 109dc1: 00 00 00 } _ISR_Enable( level ); 109dc4: 50 push %eax 109dc5: 9d popf return; 109dc6: eb 5d jmp 109e25 <_Event_Surrender+0xdd> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109dc8: f6 43 11 01 testb $0x1,0x11(%ebx) 109dcc: 74 55 je 109e23 <_Event_Surrender+0xdb> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109dce: 39 f2 cmp %esi,%edx 109dd0: 74 06 je 109dd8 <_Event_Surrender+0x90> 109dd2: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109dd6: 74 4b je 109e23 <_Event_Surrender+0xdb> <== NEVER TAKEN 109dd8: 89 d6 mov %edx,%esi 109dda: f7 d6 not %esi 109ddc: 23 75 d4 and -0x2c(%ebp),%esi 109ddf: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 109de1: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109de8: 8b 4b 28 mov 0x28(%ebx),%ecx 109deb: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109ded: 50 push %eax 109dee: 9d popf 109def: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109df0: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109df4: 74 06 je 109dfc <_Event_Surrender+0xb4> _ISR_Enable( level ); 109df6: 50 push %eax 109df7: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109df8: 51 push %ecx 109df9: 51 push %ecx 109dfa: eb 17 jmp 109e13 <_Event_Surrender+0xcb> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109dfc: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109e03: 50 push %eax 109e04: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109e05: 83 ec 0c sub $0xc,%esp 109e08: 8d 43 48 lea 0x48(%ebx),%eax 109e0b: 50 push %eax 109e0c: e8 87 30 00 00 call 10ce98 <_Watchdog_Remove> 109e11: 58 pop %eax 109e12: 5a pop %edx 109e13: 68 f8 ff 03 10 push $0x1003fff8 109e18: 53 push %ebx 109e19: e8 8a 1f 00 00 call 10bda8 <_Thread_Clear_state> 109e1e: 83 c4 10 add $0x10,%esp 109e21: eb 02 jmp 109e25 <_Event_Surrender+0xdd> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109e23: 50 push %eax 109e24: 9d popf } 109e25: 8d 65 f4 lea -0xc(%ebp),%esp 109e28: 5b pop %ebx 109e29: 5e pop %esi 109e2a: 5f pop %edi 109e2b: c9 leave 109e2c: c3 ret =============================================================================== 00109e30 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109e30: 55 push %ebp 109e31: 89 e5 mov %esp,%ebp 109e33: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109e36: 8d 45 f4 lea -0xc(%ebp),%eax 109e39: 50 push %eax 109e3a: ff 75 08 pushl 0x8(%ebp) 109e3d: e8 ba 22 00 00 call 10c0fc <_Thread_Get> switch ( location ) { 109e42: 83 c4 10 add $0x10,%esp 109e45: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 109e49: 75 49 jne 109e94 <_Event_Timeout+0x64> <== NEVER TAKEN * * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 109e4b: 9c pushf 109e4c: fa cli 109e4d: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 109e4e: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 109e55: 3b 05 2c 48 12 00 cmp 0x12482c,%eax 109e5b: 75 13 jne 109e70 <_Event_Timeout+0x40> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 109e5d: 8b 0d 00 4c 12 00 mov 0x124c00,%ecx 109e63: 49 dec %ecx 109e64: 75 0a jne 109e70 <_Event_Timeout+0x40> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 109e66: c7 05 00 4c 12 00 02 movl $0x2,0x124c00 109e6d: 00 00 00 } the_thread->Wait.return_code = RTEMS_TIMEOUT; 109e70: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 109e77: 52 push %edx 109e78: 9d popf 109e79: 52 push %edx 109e7a: 52 push %edx 109e7b: 68 f8 ff 03 10 push $0x1003fff8 109e80: 50 push %eax 109e81: e8 22 1f 00 00 call 10bda8 <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 109e86: a1 e0 42 12 00 mov 0x1242e0,%eax 109e8b: 48 dec %eax 109e8c: a3 e0 42 12 00 mov %eax,0x1242e0 _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; 109e91: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 109e94: c9 leave 109e95: c3 ret =============================================================================== 0010fa53 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 10fa53: 55 push %ebp 10fa54: 89 e5 mov %esp,%ebp 10fa56: 57 push %edi 10fa57: 56 push %esi 10fa58: 53 push %ebx 10fa59: 83 ec 4c sub $0x4c,%esp 10fa5c: 8b 5d 08 mov 0x8(%ebp),%ebx 10fa5f: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 10fa62: 8b 43 20 mov 0x20(%ebx),%eax 10fa65: 89 45 c0 mov %eax,-0x40(%ebp) Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; 10fa68: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 10fa6f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 10fa76: 8b 53 10 mov 0x10(%ebx),%edx 10fa79: 89 55 c4 mov %edx,-0x3c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10fa7c: 8b 43 14 mov 0x14(%ebx),%eax uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size; 10fa7f: 8b 7b 30 mov 0x30(%ebx),%edi 10fa82: 89 7d bc mov %edi,-0x44(%ebp) uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { return false; 10fa85: 31 f6 xor %esi,%esi uintptr_t const free_size = stats->free_size; uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { 10fa87: 8b 7d 0c mov 0xc(%ebp),%edi 10fa8a: 01 cf add %ecx,%edi 10fa8c: 0f 82 d4 01 00 00 jb 10fc66 <_Heap_Extend+0x213> return false; } extend_area_ok = _Heap_Get_first_and_last_block( 10fa92: 52 push %edx 10fa93: 52 push %edx 10fa94: 8d 55 e0 lea -0x20(%ebp),%edx 10fa97: 52 push %edx 10fa98: 8d 55 e4 lea -0x1c(%ebp),%edx 10fa9b: 52 push %edx 10fa9c: 50 push %eax 10fa9d: ff 75 c4 pushl -0x3c(%ebp) 10faa0: 51 push %ecx 10faa1: ff 75 0c pushl 0xc(%ebp) 10faa4: e8 b6 b8 ff ff call 10b35f <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 10faa9: 83 c4 20 add $0x20,%esp 10faac: 84 c0 test %al,%al 10faae: 0f 84 b2 01 00 00 je 10fc66 <_Heap_Extend+0x213> 10fab4: 8b 4d c0 mov -0x40(%ebp),%ecx 10fab7: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 10fabe: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 10fac5: 31 f6 xor %esi,%esi 10fac7: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 10face: 8b 43 18 mov 0x18(%ebx),%eax 10fad1: 89 5d b8 mov %ebx,-0x48(%ebp) 10fad4: eb 02 jmp 10fad8 <_Heap_Extend+0x85> 10fad6: 89 c8 mov %ecx,%eax uintptr_t const sub_area_end = start_block->prev_size; 10fad8: 8b 19 mov (%ecx),%ebx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 10fada: 39 c7 cmp %eax,%edi 10fadc: 76 09 jbe 10fae7 <_Heap_Extend+0x94> 10fade: 39 5d 0c cmp %ebx,0xc(%ebp) 10fae1: 0f 82 7d 01 00 00 jb 10fc64 <_Heap_Extend+0x211> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fae7: 39 c7 cmp %eax,%edi 10fae9: 74 06 je 10faf1 <_Heap_Extend+0x9e> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10faeb: 39 df cmp %ebx,%edi 10faed: 72 07 jb 10faf6 <_Heap_Extend+0xa3> 10faef: eb 08 jmp 10faf9 <_Heap_Extend+0xa6> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10faf1: 89 4d d0 mov %ecx,-0x30(%ebp) 10faf4: eb 03 jmp 10faf9 <_Heap_Extend+0xa6> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10faf6: 89 4d c8 mov %ecx,-0x38(%ebp) RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10faf9: 8d 43 f8 lea -0x8(%ebx),%eax 10fafc: 89 45 d4 mov %eax,-0x2c(%ebp) 10faff: 89 d8 mov %ebx,%eax 10fb01: 31 d2 xor %edx,%edx 10fb03: f7 75 c4 divl -0x3c(%ebp) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 10fb06: 29 55 d4 sub %edx,-0x2c(%ebp) link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 10fb09: 3b 5d 0c cmp 0xc(%ebp),%ebx 10fb0c: 75 07 jne 10fb15 <_Heap_Extend+0xc2> start_block->prev_size = extend_area_end; 10fb0e: 89 39 mov %edi,(%ecx) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area( uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) 10fb10: 8b 75 d4 mov -0x2c(%ebp),%esi 10fb13: eb 08 jmp 10fb1d <_Heap_Extend+0xca> merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 10fb15: 73 06 jae 10fb1d <_Heap_Extend+0xca> 10fb17: 8b 55 d4 mov -0x2c(%ebp),%edx 10fb1a: 89 55 cc mov %edx,-0x34(%ebp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10fb1d: 8b 45 d4 mov -0x2c(%ebp),%eax 10fb20: 8b 48 04 mov 0x4(%eax),%ecx 10fb23: 83 e1 fe and $0xfffffffe,%ecx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10fb26: 01 c1 add %eax,%ecx link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 10fb28: 3b 4d c0 cmp -0x40(%ebp),%ecx 10fb2b: 75 a9 jne 10fad6 <_Heap_Extend+0x83> 10fb2d: 8b 5d b8 mov -0x48(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 10fb30: 8b 55 0c mov 0xc(%ebp),%edx 10fb33: 3b 53 18 cmp 0x18(%ebx),%edx 10fb36: 73 05 jae 10fb3d <_Heap_Extend+0xea> heap->area_begin = extend_area_begin; 10fb38: 89 53 18 mov %edx,0x18(%ebx) 10fb3b: eb 08 jmp 10fb45 <_Heap_Extend+0xf2> } else if ( heap->area_end < extend_area_end ) { 10fb3d: 39 7b 1c cmp %edi,0x1c(%ebx) 10fb40: 73 03 jae 10fb45 <_Heap_Extend+0xf2> heap->area_end = extend_area_end; 10fb42: 89 7b 1c mov %edi,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 10fb45: 8b 45 e0 mov -0x20(%ebp),%eax 10fb48: 8b 55 e4 mov -0x1c(%ebp),%edx heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = 10fb4b: 89 c1 mov %eax,%ecx 10fb4d: 29 d1 sub %edx,%ecx 10fb4f: 89 4d d4 mov %ecx,-0x2c(%ebp) (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; 10fb52: 89 3a mov %edi,(%edx) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 10fb54: 83 c9 01 or $0x1,%ecx 10fb57: 89 4a 04 mov %ecx,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 10fb5a: 8b 4d d4 mov -0x2c(%ebp),%ecx 10fb5d: 89 08 mov %ecx,(%eax) extend_last_block->size_and_flag = 0; 10fb5f: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 10fb66: 39 53 20 cmp %edx,0x20(%ebx) 10fb69: 76 05 jbe 10fb70 <_Heap_Extend+0x11d> heap->first_block = extend_first_block; 10fb6b: 89 53 20 mov %edx,0x20(%ebx) 10fb6e: eb 08 jmp 10fb78 <_Heap_Extend+0x125> } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 10fb70: 39 43 24 cmp %eax,0x24(%ebx) 10fb73: 73 03 jae 10fb78 <_Heap_Extend+0x125> heap->last_block = extend_last_block; 10fb75: 89 43 24 mov %eax,0x24(%ebx) } if ( merge_below_block != NULL ) { 10fb78: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fb7c: 74 3b je 10fbb9 <_Heap_Extend+0x166> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 10fb7e: 8b 43 10 mov 0x10(%ebx),%eax 10fb81: 89 45 d4 mov %eax,-0x2c(%ebp) uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 10fb84: 8b 4d 0c mov 0xc(%ebp),%ecx 10fb87: 83 c1 08 add $0x8,%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 10fb8a: 89 c8 mov %ecx,%eax 10fb8c: 31 d2 xor %edx,%edx 10fb8e: f7 75 d4 divl -0x2c(%ebp) if ( remainder != 0 ) { 10fb91: 85 d2 test %edx,%edx 10fb93: 74 05 je 10fb9a <_Heap_Extend+0x147> <== ALWAYS TAKEN return value - remainder + alignment; 10fb95: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED 10fb98: 29 d1 sub %edx,%ecx <== NOT EXECUTED uintptr_t const new_first_block_begin = 10fb9a: 8d 51 f8 lea -0x8(%ecx),%edx uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; 10fb9d: 8b 45 d0 mov -0x30(%ebp),%eax 10fba0: 8b 00 mov (%eax),%eax 10fba2: 89 41 f8 mov %eax,-0x8(%ecx) uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const new_first_block_begin = new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = 10fba5: 8b 45 d0 mov -0x30(%ebp),%eax 10fba8: 29 d0 sub %edx,%eax first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED; 10fbaa: 83 c8 01 or $0x1,%eax 10fbad: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 10fbb0: 89 d8 mov %ebx,%eax 10fbb2: e8 81 fe ff ff call 10fa38 <_Heap_Free_block> 10fbb7: eb 14 jmp 10fbcd <_Heap_Extend+0x17a> heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { _Heap_Merge_below( heap, extend_area_begin, merge_below_block ); } else if ( link_below_block != NULL ) { 10fbb9: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10fbbd: 74 0e je 10fbcd <_Heap_Extend+0x17a> _Heap_Link_below( 10fbbf: 8b 55 e0 mov -0x20(%ebp),%edx { uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const link_begin = (uintptr_t) link; last_block->size_and_flag = (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED; 10fbc2: 8b 45 c8 mov -0x38(%ebp),%eax 10fbc5: 29 d0 sub %edx,%eax 10fbc7: 83 c8 01 or $0x1,%eax 10fbca: 89 42 04 mov %eax,0x4(%edx) link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 10fbcd: 85 f6 test %esi,%esi 10fbcf: 74 30 je 10fc01 <_Heap_Extend+0x1ae> ) { uintptr_t const page_size = heap->page_size; uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const last_block_new_size = _Heap_Align_down( extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE, 10fbd1: 83 ef 08 sub $0x8,%edi uintptr_t extend_area_end ) { uintptr_t const page_size = heap->page_size; uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const last_block_new_size = _Heap_Align_down( 10fbd4: 29 f7 sub %esi,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10fbd6: 89 f8 mov %edi,%eax 10fbd8: 31 d2 xor %edx,%edx 10fbda: f7 73 10 divl 0x10(%ebx) 10fbdd: 29 d7 sub %edx,%edi ); Heap_Block *const new_last_block = _Heap_Block_at( last_block, last_block_new_size ); new_last_block->size_and_flag = (last_block->size_and_flag - last_block_new_size) 10fbdf: 8b 46 04 mov 0x4(%esi),%eax 10fbe2: 29 f8 sub %edi,%eax | HEAP_PREV_BLOCK_USED; 10fbe4: 83 c8 01 or $0x1,%eax 10fbe7: 89 44 37 04 mov %eax,0x4(%edi,%esi,1) RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 10fbeb: 8b 46 04 mov 0x4(%esi),%eax 10fbee: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 10fbf1: 09 f8 or %edi,%eax 10fbf3: 89 46 04 mov %eax,0x4(%esi) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 10fbf6: 89 f2 mov %esi,%edx 10fbf8: 89 d8 mov %ebx,%eax 10fbfa: e8 39 fe ff ff call 10fa38 <_Heap_Free_block> 10fbff: eb 21 jmp 10fc22 <_Heap_Extend+0x1cf> ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 10fc01: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10fc05: 74 1b je 10fc22 <_Heap_Extend+0x1cf> _Heap_Link_above( 10fc07: 8b 4d e0 mov -0x20(%ebp),%ecx ) { uintptr_t const link_begin = (uintptr_t) link; uintptr_t const first_block_begin = (uintptr_t) first_block; _Heap_Block_set_size( link, first_block_begin - link_begin ); 10fc0a: 8b 45 e4 mov -0x1c(%ebp),%eax 10fc0d: 2b 45 cc sub -0x34(%ebp),%eax RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 10fc10: 8b 7d cc mov -0x34(%ebp),%edi 10fc13: 8b 57 04 mov 0x4(%edi),%edx 10fc16: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 10fc19: 09 d0 or %edx,%eax 10fc1b: 89 47 04 mov %eax,0x4(%edi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 10fc1e: 83 49 04 01 orl $0x1,0x4(%ecx) extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 10fc22: 85 f6 test %esi,%esi 10fc24: 75 10 jne 10fc36 <_Heap_Extend+0x1e3> 10fc26: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fc2a: 75 0a jne 10fc36 <_Heap_Extend+0x1e3> _Heap_Free_block( heap, extend_first_block ); 10fc2c: 8b 55 e4 mov -0x1c(%ebp),%edx 10fc2f: 89 d8 mov %ebx,%eax 10fc31: e8 02 fe ff ff call 10fa38 <_Heap_Free_block> */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( heap->last_block, (uintptr_t) heap->first_block - (uintptr_t) heap->last_block 10fc36: 8b 53 24 mov 0x24(%ebx),%edx * This feature will be used to terminate the scattered heap area list. See * also _Heap_Extend(). */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( 10fc39: 8b 43 20 mov 0x20(%ebx),%eax 10fc3c: 29 d0 sub %edx,%eax RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 10fc3e: 8b 4a 04 mov 0x4(%edx),%ecx 10fc41: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 10fc44: 09 c8 or %ecx,%eax 10fc46: 89 42 04 mov %eax,0x4(%edx) } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 10fc49: 8b 43 30 mov 0x30(%ebx),%eax 10fc4c: 2b 45 bc sub -0x44(%ebp),%eax /* Statistics */ stats->size += extended_size; 10fc4f: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 10fc52: be 01 00 00 00 mov $0x1,%esi extended_size = stats->free_size - free_size; /* Statistics */ stats->size += extended_size; if ( extended_size_ptr != NULL ) 10fc57: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10fc5b: 74 09 je 10fc66 <_Heap_Extend+0x213> <== NEVER TAKEN *extended_size_ptr = extended_size; 10fc5d: 8b 55 14 mov 0x14(%ebp),%edx 10fc60: 89 02 mov %eax,(%edx) 10fc62: eb 02 jmp 10fc66 <_Heap_Extend+0x213> _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; 10fc64: 31 f6 xor %esi,%esi if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 10fc66: 89 f0 mov %esi,%eax 10fc68: 8d 65 f4 lea -0xc(%ebp),%esp 10fc6b: 5b pop %ebx 10fc6c: 5e pop %esi 10fc6d: 5f pop %edi 10fc6e: c9 leave 10fc6f: c3 ret =============================================================================== 0010f698 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 10f698: 55 push %ebp 10f699: 89 e5 mov %esp,%ebp 10f69b: 57 push %edi 10f69c: 56 push %esi 10f69d: 53 push %ebx 10f69e: 83 ec 14 sub $0x14,%esp 10f6a1: 8b 4d 08 mov 0x8(%ebp),%ecx 10f6a4: 8b 45 0c mov 0xc(%ebp),%eax 10f6a7: 8d 58 f8 lea -0x8(%eax),%ebx 10f6aa: 31 d2 xor %edx,%edx 10f6ac: f7 71 10 divl 0x10(%ecx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 10f6af: 29 d3 sub %edx,%ebx RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap( const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block 10f6b1: 8b 41 20 mov 0x20(%ecx),%eax 10f6b4: 89 45 ec mov %eax,-0x14(%ebp) && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f6b7: 31 d2 xor %edx,%edx 10f6b9: 39 c3 cmp %eax,%ebx 10f6bb: 72 08 jb 10f6c5 <_Heap_Free+0x2d> 10f6bd: 31 d2 xor %edx,%edx 10f6bf: 39 59 24 cmp %ebx,0x24(%ecx) 10f6c2: 0f 93 c2 setae %dl bool next_is_free = false; _Heap_Protection_block_check( heap, block ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 10f6c5: 31 c0 xor %eax,%eax uintptr_t next_block_size = 0; bool next_is_free = false; _Heap_Protection_block_check( heap, block ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { 10f6c7: 85 d2 test %edx,%edx 10f6c9: 0f 84 21 01 00 00 je 10f7f0 <_Heap_Free+0x158> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f6cf: 8b 43 04 mov 0x4(%ebx),%eax 10f6d2: 89 45 f0 mov %eax,-0x10(%ebp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10f6d5: 89 c6 mov %eax,%esi 10f6d7: 83 e6 fe and $0xfffffffe,%esi RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10f6da: 8d 14 33 lea (%ebx,%esi,1),%edx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f6dd: 31 ff xor %edi,%edi 10f6df: 3b 55 ec cmp -0x14(%ebp),%edx 10f6e2: 72 0a jb 10f6ee <_Heap_Free+0x56> <== NEVER TAKEN 10f6e4: 31 c0 xor %eax,%eax 10f6e6: 39 51 24 cmp %edx,0x24(%ecx) 10f6e9: 0f 93 c0 setae %al 10f6ec: 89 c7 mov %eax,%edi _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { _HAssert( false ); return false; 10f6ee: 31 c0 xor %eax,%eax block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10f6f0: 85 ff test %edi,%edi 10f6f2: 0f 84 f8 00 00 00 je 10f7f0 <_Heap_Free+0x158> <== NEVER TAKEN --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f6f8: 8b 7a 04 mov 0x4(%edx),%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { _HAssert( false ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10f6fb: f7 c7 01 00 00 00 test $0x1,%edi 10f701: 0f 84 e9 00 00 00 je 10f7f0 <_Heap_Free+0x158> <== NEVER TAKEN - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10f707: 83 e7 fe and $0xfffffffe,%edi 10f70a: 89 7d e8 mov %edi,-0x18(%ebp) if ( !_Heap_Protection_determine_block_free( heap, block ) ) { return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block 10f70d: 8b 41 24 mov 0x24(%ecx),%eax 10f710: 89 45 e4 mov %eax,-0x1c(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 10f713: 31 c0 xor %eax,%eax 10f715: 3b 55 e4 cmp -0x1c(%ebp),%edx 10f718: 74 0a je 10f724 <_Heap_Free+0x8c> 10f71a: 31 c0 xor %eax,%eax 10f71c: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 10f721: 0f 94 c0 sete %al if ( !_Heap_Protection_determine_block_free( heap, block ) ) { return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block 10f724: 88 45 e3 mov %al,-0x1d(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); if ( !_Heap_Is_prev_used( block ) ) { 10f727: f6 45 f0 01 testb $0x1,-0x10(%ebp) 10f72b: 75 62 jne 10f78f <_Heap_Free+0xf7> uintptr_t const prev_size = block->prev_size; 10f72d: 8b 03 mov (%ebx),%eax 10f72f: 89 45 f0 mov %eax,-0x10(%ebp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10f732: 29 c3 sub %eax,%ebx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f734: 31 ff xor %edi,%edi 10f736: 3b 5d ec cmp -0x14(%ebp),%ebx 10f739: 72 0a jb 10f745 <_Heap_Free+0xad> <== NEVER TAKEN 10f73b: 31 c0 xor %eax,%eax 10f73d: 39 5d e4 cmp %ebx,-0x1c(%ebp) 10f740: 0f 93 c0 setae %al 10f743: 89 c7 mov %eax,%edi Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size ); if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) { _HAssert( false ); return( false ); 10f745: 31 c0 xor %eax,%eax if ( !_Heap_Is_prev_used( block ) ) { uintptr_t const prev_size = block->prev_size; Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size ); if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) { 10f747: 85 ff test %edi,%edi 10f749: 0f 84 a1 00 00 00 je 10f7f0 <_Heap_Free+0x158> <== NEVER TAKEN return( false ); } /* As we always coalesce free blocks, the block that preceedes prev_block must have been used. */ if ( !_Heap_Is_prev_used ( prev_block) ) { 10f74f: f6 43 04 01 testb $0x1,0x4(%ebx) 10f753: 0f 84 97 00 00 00 je 10f7f0 <_Heap_Free+0x158> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 10f759: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f75d: 74 1a je 10f779 <_Heap_Free+0xe1> uintptr_t const size = block_size + prev_size + next_block_size; 10f75f: 8b 45 e8 mov -0x18(%ebp),%eax 10f762: 8d 04 06 lea (%esi,%eax,1),%eax 10f765: 03 45 f0 add -0x10(%ebp),%eax return _Heap_Free_list_tail(heap)->prev; } RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; 10f768: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = block->prev; 10f76b: 8b 52 0c mov 0xc(%edx),%edx prev->next = next; 10f76e: 89 7a 08 mov %edi,0x8(%edx) next->prev = prev; 10f771: 89 57 0c mov %edx,0xc(%edi) _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 10f774: ff 49 38 decl 0x38(%ecx) 10f777: eb 33 jmp 10f7ac <_Heap_Free+0x114> prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uintptr_t const size = block_size + prev_size; 10f779: 8b 45 f0 mov -0x10(%ebp),%eax 10f77c: 8d 04 06 lea (%esi,%eax,1),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f77f: 89 c7 mov %eax,%edi 10f781: 83 cf 01 or $0x1,%edi 10f784: 89 7b 04 mov %edi,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f787: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 10f78b: 89 02 mov %eax,(%edx) 10f78d: eb 56 jmp 10f7e5 <_Heap_Free+0x14d> } } else if ( next_is_free ) { /* coalesce next */ 10f78f: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f793: 74 24 je 10f7b9 <_Heap_Free+0x121> uintptr_t const size = block_size + next_block_size; 10f795: 8b 45 e8 mov -0x18(%ebp),%eax 10f798: 01 f0 add %esi,%eax RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace( Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *next = old_block->next; 10f79a: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = old_block->prev; 10f79d: 8b 52 0c mov 0xc(%edx),%edx new_block->next = next; 10f7a0: 89 7b 08 mov %edi,0x8(%ebx) new_block->prev = prev; 10f7a3: 89 53 0c mov %edx,0xc(%ebx) next->prev = new_block; 10f7a6: 89 5f 0c mov %ebx,0xc(%edi) prev->next = new_block; 10f7a9: 89 5a 08 mov %ebx,0x8(%edx) _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f7ac: 89 c2 mov %eax,%edx 10f7ae: 83 ca 01 or $0x1,%edx 10f7b1: 89 53 04 mov %edx,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 10f7b4: 89 04 03 mov %eax,(%ebx,%eax,1) 10f7b7: eb 2c jmp 10f7e5 <_Heap_Free+0x14d> RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 10f7b9: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 10f7bc: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 10f7bf: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 10f7c2: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 10f7c5: 89 58 0c mov %ebx,0xc(%eax) } else { /* no coalesce */ /* Add 'block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block ); block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 10f7c8: 89 f0 mov %esi,%eax 10f7ca: 83 c8 01 or $0x1,%eax 10f7cd: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f7d0: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 10f7d4: 89 32 mov %esi,(%edx) /* Statistics */ ++stats->free_blocks; 10f7d6: 8b 41 38 mov 0x38(%ecx),%eax 10f7d9: 40 inc %eax 10f7da: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 10f7dd: 39 41 3c cmp %eax,0x3c(%ecx) 10f7e0: 73 03 jae 10f7e5 <_Heap_Free+0x14d> stats->max_free_blocks = stats->free_blocks; 10f7e2: 89 41 3c mov %eax,0x3c(%ecx) } } /* Statistics */ --stats->used_blocks; 10f7e5: ff 49 40 decl 0x40(%ecx) ++stats->frees; 10f7e8: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 10f7eb: 01 71 30 add %esi,0x30(%ecx) return( true ); 10f7ee: b0 01 mov $0x1,%al } 10f7f0: 83 c4 14 add $0x14,%esp 10f7f3: 5b pop %ebx 10f7f4: 5e pop %esi 10f7f5: 5f pop %edi 10f7f6: c9 leave 10f7f7: c3 ret =============================================================================== 0011cc20 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11cc20: 55 push %ebp 11cc21: 89 e5 mov %esp,%ebp 11cc23: 57 push %edi 11cc24: 56 push %esi 11cc25: 53 push %ebx 11cc26: 8b 5d 08 mov 0x8(%ebp),%ebx 11cc29: 8b 75 0c mov 0xc(%ebp),%esi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 11cc2c: 8d 4e f8 lea -0x8(%esi),%ecx 11cc2f: 89 f0 mov %esi,%eax 11cc31: 31 d2 xor %edx,%edx 11cc33: f7 73 10 divl 0x10(%ebx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 11cc36: 29 d1 sub %edx,%ecx RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap( const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block 11cc38: 8b 53 20 mov 0x20(%ebx),%edx && (uintptr_t) block <= (uintptr_t) heap->last_block; 11cc3b: 31 ff xor %edi,%edi 11cc3d: 39 d1 cmp %edx,%ecx 11cc3f: 72 0a jb 11cc4b <_Heap_Size_of_alloc_area+0x2b> 11cc41: 31 c0 xor %eax,%eax 11cc43: 39 4b 24 cmp %ecx,0x24(%ebx) 11cc46: 0f 93 c0 setae %al 11cc49: 89 c7 mov %eax,%edi Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); Heap_Block *next_block = NULL; uintptr_t block_size = 0; if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 11cc4b: 31 c0 xor %eax,%eax uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr; Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); Heap_Block *next_block = NULL; uintptr_t block_size = 0; if ( !_Heap_Is_block_in_heap( heap, block ) ) { 11cc4d: 85 ff test %edi,%edi 11cc4f: 74 30 je 11cc81 <_Heap_Size_of_alloc_area+0x61> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 11cc51: 8b 41 04 mov 0x4(%ecx),%eax 11cc54: 83 e0 fe and $0xfffffffe,%eax RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 11cc57: 01 c1 add %eax,%ecx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 11cc59: 31 ff xor %edi,%edi 11cc5b: 39 d1 cmp %edx,%ecx 11cc5d: 72 0a jb 11cc69 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN 11cc5f: 31 c0 xor %eax,%eax 11cc61: 39 4b 24 cmp %ecx,0x24(%ebx) 11cc64: 0f 93 c0 setae %al 11cc67: 89 c7 mov %eax,%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) ) { return false; 11cc69: 31 c0 xor %eax,%eax } block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( 11cc6b: 85 ff test %edi,%edi 11cc6d: 74 12 je 11cc81 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 11cc6f: f6 41 04 01 testb $0x1,0x4(%ecx) 11cc73: 74 0c je 11cc81 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11cc75: 29 f1 sub %esi,%ecx 11cc77: 8d 51 04 lea 0x4(%ecx),%edx 11cc7a: 8b 45 10 mov 0x10(%ebp),%eax 11cc7d: 89 10 mov %edx,(%eax) return true; 11cc7f: b0 01 mov $0x1,%al } 11cc81: 5b pop %ebx 11cc82: 5e pop %esi 11cc83: 5f pop %edi 11cc84: c9 leave 11cc85: c3 ret =============================================================================== 0010bc1a <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10bc1a: 55 push %ebp 10bc1b: 89 e5 mov %esp,%ebp 10bc1d: 57 push %edi 10bc1e: 56 push %esi 10bc1f: 53 push %ebx 10bc20: 83 ec 4c sub $0x4c,%esp 10bc23: 8b 75 08 mov 0x8(%ebp),%esi 10bc26: 8b 5d 0c mov 0xc(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10bc29: 8b 46 10 mov 0x10(%esi),%eax 10bc2c: 89 45 d8 mov %eax,-0x28(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10bc2f: 8b 4e 14 mov 0x14(%esi),%ecx 10bc32: 89 4d d4 mov %ecx,-0x2c(%ebp) Heap_Block *const first_block = heap->first_block; 10bc35: 8b 46 20 mov 0x20(%esi),%eax 10bc38: 89 45 d0 mov %eax,-0x30(%ebp) Heap_Block *const last_block = heap->last_block; 10bc3b: 8b 4e 24 mov 0x24(%esi),%ecx 10bc3e: 89 4d c8 mov %ecx,-0x38(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10bc41: c7 45 e4 dc bb 10 00 movl $0x10bbdc,-0x1c(%ebp) 10bc48: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10bc4c: 74 07 je 10bc55 <_Heap_Walk+0x3b> 10bc4e: c7 45 e4 e1 bb 10 00 movl $0x10bbe1,-0x1c(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; 10bc55: b0 01 mov $0x1,%al Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; if ( !_System_state_Is_up( _System_state_Get() ) ) { 10bc57: 83 3d e4 64 12 00 03 cmpl $0x3,0x1264e4 10bc5e: 0f 85 e8 02 00 00 jne 10bf4c <_Heap_Walk+0x332> Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; (*printer)( 10bc64: 52 push %edx 10bc65: ff 76 0c pushl 0xc(%esi) 10bc68: ff 76 08 pushl 0x8(%esi) 10bc6b: ff 75 c8 pushl -0x38(%ebp) 10bc6e: ff 75 d0 pushl -0x30(%ebp) 10bc71: ff 76 1c pushl 0x1c(%esi) 10bc74: ff 76 18 pushl 0x18(%esi) 10bc77: ff 75 d4 pushl -0x2c(%ebp) 10bc7a: ff 75 d8 pushl -0x28(%ebp) 10bc7d: 68 91 f7 11 00 push $0x11f791 10bc82: 6a 00 push $0x0 10bc84: 53 push %ebx 10bc85: ff 55 e4 call *-0x1c(%ebp) heap->area_begin, heap->area_end, first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { 10bc88: 83 c4 30 add $0x30,%esp 10bc8b: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10bc8f: 75 0b jne 10bc9c <_Heap_Walk+0x82> (*printer)( source, true, "page size is zero\n" ); 10bc91: 50 push %eax 10bc92: 68 22 f8 11 00 push $0x11f822 10bc97: e9 6b 02 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10bc9c: f6 45 d8 03 testb $0x3,-0x28(%ebp) 10bca0: 74 0d je 10bcaf <_Heap_Walk+0x95> (*printer)( 10bca2: ff 75 d8 pushl -0x28(%ebp) 10bca5: 68 35 f8 11 00 push $0x11f835 10bcaa: e9 58 02 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bcaf: 8b 45 d4 mov -0x2c(%ebp),%eax 10bcb2: 31 d2 xor %edx,%edx 10bcb4: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10bcb7: 85 d2 test %edx,%edx 10bcb9: 74 0d je 10bcc8 <_Heap_Walk+0xae> (*printer)( 10bcbb: ff 75 d4 pushl -0x2c(%ebp) 10bcbe: 68 53 f8 11 00 push $0x11f853 10bcc3: e9 3f 02 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10bcc8: 8b 45 d0 mov -0x30(%ebp),%eax 10bccb: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bcce: 31 d2 xor %edx,%edx 10bcd0: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( 10bcd3: 85 d2 test %edx,%edx 10bcd5: 74 0d je 10bce4 <_Heap_Walk+0xca> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10bcd7: ff 75 d0 pushl -0x30(%ebp) 10bcda: 68 77 f8 11 00 push $0x11f877 10bcdf: e9 23 02 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10bce4: 8b 45 d0 mov -0x30(%ebp),%eax 10bce7: f6 40 04 01 testb $0x1,0x4(%eax) 10bceb: 75 0b jne 10bcf8 <_Heap_Walk+0xde> (*printer)( 10bced: 57 push %edi 10bcee: 68 a8 f8 11 00 push $0x11f8a8 10bcf3: e9 0f 02 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10bcf8: 8b 4d c8 mov -0x38(%ebp),%ecx 10bcfb: 8b 79 04 mov 0x4(%ecx),%edi 10bcfe: 83 e7 fe and $0xfffffffe,%edi RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10bd01: 01 cf add %ecx,%edi ); return false; } if ( _Heap_Is_free( last_block ) ) { 10bd03: f6 47 04 01 testb $0x1,0x4(%edi) 10bd07: 75 0b jne 10bd14 <_Heap_Walk+0xfa> (*printer)( 10bd09: 56 push %esi 10bd0a: 68 d6 f8 11 00 push $0x11f8d6 10bd0f: e9 f3 01 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> ); return false; } if ( 10bd14: 3b 7d d0 cmp -0x30(%ebp),%edi 10bd17: 74 0b je 10bd24 <_Heap_Walk+0x10a> <== ALWAYS TAKEN _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10bd19: 51 push %ecx <== NOT EXECUTED 10bd1a: 68 eb f8 11 00 push $0x11f8eb <== NOT EXECUTED 10bd1f: e9 e3 01 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> <== NOT EXECUTED int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10bd24: 8b 46 10 mov 0x10(%esi),%eax 10bd27: 89 45 e0 mov %eax,-0x20(%ebp) block = next_block; } while ( block != first_block ); return true; } 10bd2a: 8b 4e 08 mov 0x8(%esi),%ecx Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); 10bd2d: 89 75 dc mov %esi,-0x24(%ebp) 10bd30: eb 75 jmp 10bda7 <_Heap_Walk+0x18d> const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10bd32: 31 c0 xor %eax,%eax 10bd34: 39 4e 20 cmp %ecx,0x20(%esi) 10bd37: 77 08 ja 10bd41 <_Heap_Walk+0x127> 10bd39: 31 c0 xor %eax,%eax 10bd3b: 39 4e 24 cmp %ecx,0x24(%esi) 10bd3e: 0f 93 c0 setae %al const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { 10bd41: 85 c0 test %eax,%eax 10bd43: 75 0b jne 10bd50 <_Heap_Walk+0x136> (*printer)( 10bd45: 51 push %ecx 10bd46: 68 1a f9 11 00 push $0x11f91a 10bd4b: e9 b7 01 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10bd50: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bd53: 31 d2 xor %edx,%edx 10bd55: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10bd58: 85 d2 test %edx,%edx 10bd5a: 74 0b je 10bd67 <_Heap_Walk+0x14d> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10bd5c: 51 push %ecx 10bd5d: 68 3a f9 11 00 push $0x11f93a 10bd62: e9 a0 01 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10bd67: 8b 41 04 mov 0x4(%ecx),%eax 10bd6a: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10bd6d: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10bd72: 74 0b je 10bd7f <_Heap_Walk+0x165> (*printer)( 10bd74: 51 push %ecx 10bd75: 68 6a f9 11 00 push $0x11f96a 10bd7a: e9 88 01 00 00 jmp 10bf07 <_Heap_Walk+0x2ed> ); return false; } if ( free_block->prev != prev_block ) { 10bd7f: 8b 41 0c mov 0xc(%ecx),%eax 10bd82: 3b 45 dc cmp -0x24(%ebp),%eax 10bd85: 74 1a je 10bda1 <_Heap_Walk+0x187> (*printer)( 10bd87: 83 ec 0c sub $0xc,%esp 10bd8a: 50 push %eax 10bd8b: 51 push %ecx 10bd8c: 68 86 f9 11 00 push $0x11f986 10bd91: 6a 01 push $0x1 10bd93: 53 push %ebx 10bd94: ff 55 e4 call *-0x1c(%ebp) 10bd97: 83 c4 20 add $0x20,%esp if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 10bd9a: 31 c0 xor %eax,%eax 10bd9c: e9 ab 01 00 00 jmp 10bf4c <_Heap_Walk+0x332> return false; } prev_block = free_block; free_block = free_block->next; 10bda1: 89 4d dc mov %ecx,-0x24(%ebp) 10bda4: 8b 49 08 mov 0x8(%ecx),%ecx const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { 10bda7: 39 f1 cmp %esi,%ecx 10bda9: 75 87 jne 10bd32 <_Heap_Walk+0x118> 10bdab: 89 5d dc mov %ebx,-0x24(%ebp) 10bdae: eb 02 jmp 10bdb2 <_Heap_Walk+0x198> block->prev_size ); } block = next_block; } while ( block != first_block ); 10bdb0: 89 df mov %ebx,%edi return true; } 10bdb2: 8b 4f 04 mov 0x4(%edi),%ecx 10bdb5: 89 4d cc mov %ecx,-0x34(%ebp) 10bdb8: 83 e1 fe and $0xfffffffe,%ecx 10bdbb: 89 4d e0 mov %ecx,-0x20(%ebp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10bdbe: 8d 1c 0f lea (%edi,%ecx,1),%ebx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10bdc1: 31 c0 xor %eax,%eax 10bdc3: 39 5e 20 cmp %ebx,0x20(%esi) 10bdc6: 77 08 ja 10bdd0 <_Heap_Walk+0x1b6> <== NEVER TAKEN 10bdc8: 31 c0 xor %eax,%eax 10bdca: 39 5e 24 cmp %ebx,0x24(%esi) 10bdcd: 0f 93 c0 setae %al bool const prev_used = _Heap_Is_prev_used( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); uintptr_t const next_block_begin = (uintptr_t) next_block; bool const is_not_last_block = block != last_block; if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10bdd0: 85 c0 test %eax,%eax 10bdd2: 75 11 jne 10bde5 <_Heap_Walk+0x1cb> 10bdd4: 89 d9 mov %ebx,%ecx 10bdd6: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bdd9: 83 ec 0c sub $0xc,%esp 10bddc: 51 push %ecx 10bddd: 57 push %edi 10bdde: 68 b8 f9 11 00 push $0x11f9b8 10bde3: eb ac jmp 10bd91 <_Heap_Walk+0x177> uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); bool const prev_used = _Heap_Is_prev_used( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); uintptr_t const next_block_begin = (uintptr_t) next_block; bool const is_not_last_block = block != last_block; 10bde5: 3b 7d c8 cmp -0x38(%ebp),%edi 10bde8: 0f 95 c1 setne %cl RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bdeb: 8b 45 e0 mov -0x20(%ebp),%eax 10bdee: 31 d2 xor %edx,%edx 10bdf0: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10bdf3: 85 d2 test %edx,%edx 10bdf5: 74 15 je 10be0c <_Heap_Walk+0x1f2> 10bdf7: 84 c9 test %cl,%cl 10bdf9: 74 11 je 10be0c <_Heap_Walk+0x1f2> 10bdfb: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bdfe: 83 ec 0c sub $0xc,%esp 10be01: ff 75 e0 pushl -0x20(%ebp) 10be04: 57 push %edi 10be05: 68 e5 f9 11 00 push $0x11f9e5 10be0a: eb 85 jmp 10bd91 <_Heap_Walk+0x177> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10be0c: 8b 45 d4 mov -0x2c(%ebp),%eax 10be0f: 39 45 e0 cmp %eax,-0x20(%ebp) 10be12: 73 18 jae 10be2c <_Heap_Walk+0x212> 10be14: 84 c9 test %cl,%cl 10be16: 74 14 je 10be2c <_Heap_Walk+0x212> <== NEVER TAKEN 10be18: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be1b: 52 push %edx 10be1c: 52 push %edx 10be1d: 50 push %eax 10be1e: ff 75 e0 pushl -0x20(%ebp) 10be21: 57 push %edi 10be22: 68 13 fa 11 00 push $0x11fa13 10be27: e9 65 ff ff ff jmp 10bd91 <_Heap_Walk+0x177> ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10be2c: 39 fb cmp %edi,%ebx 10be2e: 77 18 ja 10be48 <_Heap_Walk+0x22e> 10be30: 84 c9 test %cl,%cl 10be32: 74 14 je 10be48 <_Heap_Walk+0x22e> 10be34: 89 d9 mov %ebx,%ecx 10be36: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be39: 83 ec 0c sub $0xc,%esp 10be3c: 51 push %ecx 10be3d: 57 push %edi 10be3e: 68 3e fa 11 00 push $0x11fa3e 10be43: e9 49 ff ff ff jmp 10bd91 <_Heap_Walk+0x177> block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 10be48: 8b 4d cc mov -0x34(%ebp),%ecx 10be4b: 83 e1 01 and $0x1,%ecx 10be4e: 89 4d c4 mov %ecx,-0x3c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10be51: f6 43 04 01 testb $0x1,0x4(%ebx) 10be55: 0f 85 ba 00 00 00 jne 10bf15 <_Heap_Walk+0x2fb> block = next_block; } while ( block != first_block ); return true; } 10be5b: 8b 46 08 mov 0x8(%esi),%eax 10be5e: 89 45 c0 mov %eax,-0x40(%ebp) block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? 10be61: 8b 4f 08 mov 0x8(%edi),%ecx 10be64: 89 4d b4 mov %ecx,-0x4c(%ebp) Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10be67: ba 5e f7 11 00 mov $0x11f75e,%edx 10be6c: 3b 4e 0c cmp 0xc(%esi),%ecx 10be6f: 74 0e je 10be7f <_Heap_Walk+0x265> " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 10be71: ba 95 f6 11 00 mov $0x11f695,%edx 10be76: 39 f1 cmp %esi,%ecx 10be78: 75 05 jne 10be7f <_Heap_Walk+0x265> 10be7a: ba 6d f7 11 00 mov $0x11f76d,%edx false, "block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n", block, block_size, block->prev, block->prev == first_free_block ? 10be7f: 8b 47 0c mov 0xc(%edi),%eax 10be82: 89 45 cc mov %eax,-0x34(%ebp) Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10be85: b8 77 f7 11 00 mov $0x11f777,%eax 10be8a: 8b 4d c0 mov -0x40(%ebp),%ecx 10be8d: 39 4d cc cmp %ecx,-0x34(%ebp) 10be90: 74 0f je 10bea1 <_Heap_Walk+0x287> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10be92: b8 95 f6 11 00 mov $0x11f695,%eax 10be97: 39 75 cc cmp %esi,-0x34(%ebp) 10be9a: 75 05 jne 10bea1 <_Heap_Walk+0x287> 10be9c: b8 87 f7 11 00 mov $0x11f787,%eax Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10bea1: 83 ec 0c sub $0xc,%esp 10bea4: 52 push %edx 10bea5: ff 75 b4 pushl -0x4c(%ebp) 10bea8: 50 push %eax 10bea9: ff 75 cc pushl -0x34(%ebp) 10beac: ff 75 e0 pushl -0x20(%ebp) 10beaf: 57 push %edi 10beb0: 68 72 fa 11 00 push $0x11fa72 10beb5: 6a 00 push $0x0 10beb7: ff 75 dc pushl -0x24(%ebp) 10beba: ff 55 e4 call *-0x1c(%ebp) block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { 10bebd: 8b 03 mov (%ebx),%eax 10bebf: 83 c4 30 add $0x30,%esp 10bec2: 39 45 e0 cmp %eax,-0x20(%ebp) 10bec5: 74 16 je 10bedd <_Heap_Walk+0x2c3> 10bec7: 89 d9 mov %ebx,%ecx 10bec9: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10becc: 56 push %esi 10becd: 51 push %ecx 10bece: 50 push %eax 10becf: ff 75 e0 pushl -0x20(%ebp) 10bed2: 57 push %edi 10bed3: 68 a7 fa 11 00 push $0x11faa7 10bed8: e9 b4 fe ff ff jmp 10bd91 <_Heap_Walk+0x177> ); return false; } if ( !prev_used ) { 10bedd: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bee1: 75 0b jne 10beee <_Heap_Walk+0x2d4> 10bee3: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bee6: 57 push %edi 10bee7: 68 e0 fa 11 00 push $0x11fae0 10beec: eb 19 jmp 10bf07 <_Heap_Walk+0x2ed> block = next_block; } while ( block != first_block ); return true; } 10beee: 8b 46 08 mov 0x8(%esi),%eax 10bef1: eb 07 jmp 10befa <_Heap_Walk+0x2e0> { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { if ( free_block == block ) { 10bef3: 39 f8 cmp %edi,%eax 10bef5: 74 4a je 10bf41 <_Heap_Walk+0x327> return true; } free_block = free_block->next; 10bef7: 8b 40 08 mov 0x8(%eax),%eax ) { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { 10befa: 39 f0 cmp %esi,%eax 10befc: 75 f5 jne 10bef3 <_Heap_Walk+0x2d9> 10befe: 8b 5d dc mov -0x24(%ebp),%ebx return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10bf01: 57 push %edi 10bf02: 68 4b fb 11 00 push $0x11fb4b 10bf07: 6a 01 push $0x1 10bf09: 53 push %ebx 10bf0a: ff 55 e4 call *-0x1c(%ebp) 10bf0d: 83 c4 10 add $0x10,%esp 10bf10: e9 85 fe ff ff jmp 10bd9a <_Heap_Walk+0x180> if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 10bf15: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bf19: 74 0e je 10bf29 <_Heap_Walk+0x30f> (*printer)( 10bf1b: 83 ec 0c sub $0xc,%esp 10bf1e: ff 75 e0 pushl -0x20(%ebp) 10bf21: 57 push %edi 10bf22: 68 0f fb 11 00 push $0x11fb0f 10bf27: eb 0d jmp 10bf36 <_Heap_Walk+0x31c> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10bf29: 51 push %ecx 10bf2a: 51 push %ecx 10bf2b: ff 37 pushl (%edi) 10bf2d: ff 75 e0 pushl -0x20(%ebp) 10bf30: 57 push %edi 10bf31: 68 26 fb 11 00 push $0x11fb26 10bf36: 6a 00 push $0x0 10bf38: ff 75 dc pushl -0x24(%ebp) 10bf3b: ff 55 e4 call *-0x1c(%ebp) 10bf3e: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10bf41: 3b 5d d0 cmp -0x30(%ebp),%ebx 10bf44: 0f 85 66 fe ff ff jne 10bdb0 <_Heap_Walk+0x196> return true; 10bf4a: b0 01 mov $0x1,%al } 10bf4c: 8d 65 f4 lea -0xc(%ebp),%esp 10bf4f: 5b pop %ebx 10bf50: 5e pop %esi 10bf51: 5f pop %edi 10bf52: c9 leave 10bf53: c3 ret =============================================================================== 0010b23c <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10b23c: 55 push %ebp 10b23d: 89 e5 mov %esp,%ebp 10b23f: 53 push %ebx 10b240: 83 ec 08 sub $0x8,%esp 10b243: 8b 45 08 mov 0x8(%ebp),%eax 10b246: 8b 55 0c mov 0xc(%ebp),%edx 10b249: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10b24c: a3 98 43 12 00 mov %eax,0x124398 _Internal_errors_What_happened.is_internal = is_internal; 10b251: 88 15 9c 43 12 00 mov %dl,0x12439c _Internal_errors_What_happened.the_error = the_error; 10b257: 89 1d a0 43 12 00 mov %ebx,0x1243a0 _User_extensions_Fatal( the_source, is_internal, the_error ); 10b25d: 53 push %ebx 10b25e: 0f b6 d2 movzbl %dl,%edx 10b261: 52 push %edx 10b262: 50 push %eax 10b263: e8 f7 19 00 00 call 10cc5f <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10b268: c7 05 5c 44 12 00 05 movl $0x5,0x12445c <== NOT EXECUTED 10b26f: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b272: fa cli <== NOT EXECUTED 10b273: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b275: f4 hlt <== NOT EXECUTED 10b276: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b279: eb fe jmp 10b279 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010b2cc <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b2cc: 55 push %ebp 10b2cd: 89 e5 mov %esp,%ebp 10b2cf: 56 push %esi 10b2d0: 53 push %ebx 10b2d1: 8b 5d 08 mov 0x8(%ebp),%ebx * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) return NULL; 10b2d4: 31 c9 xor %ecx,%ecx * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 10b2d6: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10b2da: 74 53 je 10b32f <_Objects_Allocate+0x63><== NEVER TAKEN /* * OK. The manager should be initialized and configured to have objects. * With any luck, it is safe to attempt to allocate an object. */ the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b2dc: 8d 73 20 lea 0x20(%ebx),%esi 10b2df: 83 ec 0c sub $0xc,%esp 10b2e2: 56 push %esi 10b2e3: e8 30 f7 ff ff call 10aa18 <_Chain_Get> 10b2e8: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10b2ea: 83 c4 10 add $0x10,%esp 10b2ed: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10b2f1: 74 3c je 10b32f <_Objects_Allocate+0x63> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b2f3: 85 c0 test %eax,%eax 10b2f5: 75 1a jne 10b311 <_Objects_Allocate+0x45> _Objects_Extend_information( information ); 10b2f7: 83 ec 0c sub $0xc,%esp 10b2fa: 53 push %ebx 10b2fb: e8 60 00 00 00 call 10b360 <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b300: 89 34 24 mov %esi,(%esp) 10b303: e8 10 f7 ff ff call 10aa18 <_Chain_Get> 10b308: 89 c1 mov %eax,%ecx } if ( the_object ) { 10b30a: 83 c4 10 add $0x10,%esp 10b30d: 85 c0 test %eax,%eax 10b30f: 74 1e je 10b32f <_Objects_Allocate+0x63> uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10b311: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10b315: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10b319: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10b31b: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10b31f: 31 d2 xor %edx,%edx 10b321: f7 f6 div %esi information->inactive_per_block[ block ]--; 10b323: c1 e0 02 shl $0x2,%eax 10b326: 03 43 30 add 0x30(%ebx),%eax 10b329: ff 08 decl (%eax) information->inactive--; 10b32b: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10b32f: 89 c8 mov %ecx,%eax 10b331: 8d 65 f8 lea -0x8(%ebp),%esp 10b334: 5b pop %ebx 10b335: 5e pop %esi 10b336: c9 leave 10b337: c3 ret =============================================================================== 0010b654 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10b654: 55 push %ebp 10b655: 89 e5 mov %esp,%ebp 10b657: 57 push %edi 10b658: 56 push %esi 10b659: 53 push %ebx 10b65a: 83 ec 0c sub $0xc,%esp 10b65d: 8b 75 08 mov 0x8(%ebp),%esi 10b660: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 10b663: 31 db xor %ebx,%ebx ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10b665: 66 85 ff test %di,%di 10b668: 74 37 je 10b6a1 <_Objects_Get_information+0x4d> /* * This call implicitly validates the_api so we do not call * _Objects_Is_api_valid above here. */ the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10b66a: 83 ec 0c sub $0xc,%esp 10b66d: 56 push %esi 10b66e: e8 85 41 00 00 call 10f7f8 <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10b673: 83 c4 10 add $0x10,%esp 10b676: 85 c0 test %eax,%eax 10b678: 74 27 je 10b6a1 <_Objects_Get_information+0x4d> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10b67a: 0f b7 ff movzwl %di,%edi 10b67d: 39 c7 cmp %eax,%edi 10b67f: 77 20 ja 10b6a1 <_Objects_Get_information+0x4d> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b681: 8b 04 b5 b8 42 12 00 mov 0x1242b8(,%esi,4),%eax 10b688: 85 c0 test %eax,%eax 10b68a: 74 15 je 10b6a1 <_Objects_Get_information+0x4d><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10b68c: 8b 1c b8 mov (%eax,%edi,4),%ebx if ( !info ) 10b68f: 85 db test %ebx,%ebx 10b691: 74 0e je 10b6a1 <_Objects_Get_information+0x4d><== NEVER TAKEN * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) return NULL; 10b693: 31 c0 xor %eax,%eax 10b695: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx) 10b69a: 0f 95 c0 setne %al 10b69d: f7 d8 neg %eax 10b69f: 21 c3 and %eax,%ebx #endif return info; } 10b6a1: 89 d8 mov %ebx,%eax 10b6a3: 8d 65 f4 lea -0xc(%ebp),%esp 10b6a6: 5b pop %ebx 10b6a7: 5e pop %esi 10b6a8: 5f pop %edi 10b6a9: c9 leave 10b6aa: c3 ret =============================================================================== 00118ac0 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 118ac0: 55 push %ebp 118ac1: 89 e5 mov %esp,%ebp 118ac3: 53 push %ebx 118ac4: 8b 55 08 mov 0x8(%ebp),%edx 118ac7: 8b 4d 10 mov 0x10(%ebp),%ecx /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 118aca: b8 01 00 00 00 mov $0x1,%eax 118acf: 2b 42 08 sub 0x8(%edx),%eax 118ad2: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 118ad5: 0f b7 5a 10 movzwl 0x10(%edx),%ebx 118ad9: 39 c3 cmp %eax,%ebx 118adb: 72 12 jb 118aef <_Objects_Get_no_protection+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { 118add: 8b 52 1c mov 0x1c(%edx),%edx 118ae0: 8b 04 82 mov (%edx,%eax,4),%eax 118ae3: 85 c0 test %eax,%eax 118ae5: 74 08 je 118aef <_Objects_Get_no_protection+0x2f><== NEVER TAKEN *location = OBJECTS_LOCAL; 118ae7: c7 01 00 00 00 00 movl $0x0,(%ecx) return the_object; 118aed: eb 08 jmp 118af7 <_Objects_Get_no_protection+0x37> /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 118aef: c7 01 01 00 00 00 movl $0x1,(%ecx) return NULL; 118af5: 31 c0 xor %eax,%eax } 118af7: 5b pop %ebx 118af8: c9 leave 118af9: c3 ret =============================================================================== 0010c880 <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10c880: 55 push %ebp 10c881: 89 e5 mov %esp,%ebp 10c883: 53 push %ebx 10c884: 83 ec 14 sub $0x14,%esp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10c887: 8b 45 08 mov 0x8(%ebp),%eax 10c88a: 85 c0 test %eax,%eax 10c88c: 75 08 jne 10c896 <_Objects_Id_to_name+0x16> 10c88e: a1 98 78 12 00 mov 0x127898,%eax 10c893: 8b 40 08 mov 0x8(%eax),%eax 10c896: 89 c2 mov %eax,%edx 10c898: c1 ea 18 shr $0x18,%edx 10c89b: 83 e2 07 and $0x7,%edx */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 10c89e: 8d 4a ff lea -0x1(%edx),%ecx the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 10c8a1: bb 03 00 00 00 mov $0x3,%ebx 10c8a6: 83 f9 02 cmp $0x2,%ecx 10c8a9: 77 36 ja 10c8e1 <_Objects_Id_to_name+0x61> 10c8ab: eb 3b jmp 10c8e8 <_Objects_Id_to_name+0x68> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10c8ad: 89 c1 mov %eax,%ecx 10c8af: c1 e9 1b shr $0x1b,%ecx if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10c8b2: 8b 14 8a mov (%edx,%ecx,4),%edx if ( !information ) 10c8b5: 85 d2 test %edx,%edx 10c8b7: 74 28 je 10c8e1 <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10c8b9: 80 7a 38 00 cmpb $0x0,0x38(%edx) 10c8bd: 75 22 jne 10c8e1 <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 10c8bf: 51 push %ecx 10c8c0: 8d 4d f4 lea -0xc(%ebp),%ecx 10c8c3: 51 push %ecx 10c8c4: 50 push %eax 10c8c5: 52 push %edx 10c8c6: e8 5d ff ff ff call 10c828 <_Objects_Get> if ( !the_object ) 10c8cb: 83 c4 10 add $0x10,%esp 10c8ce: 85 c0 test %eax,%eax 10c8d0: 74 0f je 10c8e1 <_Objects_Id_to_name+0x61> return OBJECTS_INVALID_ID; *name = the_object->name; 10c8d2: 8b 50 0c mov 0xc(%eax),%edx 10c8d5: 8b 45 0c mov 0xc(%ebp),%eax 10c8d8: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10c8da: e8 9f 09 00 00 call 10d27e <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10c8df: 31 db xor %ebx,%ebx } 10c8e1: 89 d8 mov %ebx,%eax 10c8e3: 8b 5d fc mov -0x4(%ebp),%ebx 10c8e6: c9 leave 10c8e7: c3 ret the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 10c8e8: 8b 14 95 24 73 12 00 mov 0x127324(,%edx,4),%edx 10c8ef: 85 d2 test %edx,%edx 10c8f1: 75 ba jne 10c8ad <_Objects_Id_to_name+0x2d> 10c8f3: eb ec jmp 10c8e1 <_Objects_Id_to_name+0x61> =============================================================================== 0010e2b8 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10e2b8: 55 push %ebp 10e2b9: 89 e5 mov %esp,%ebp 10e2bb: 57 push %edi 10e2bc: 56 push %esi 10e2bd: 53 push %ebx 10e2be: 83 ec 30 sub $0x30,%esp 10e2c1: 8b 75 08 mov 0x8(%ebp),%esi 10e2c4: 8b 5d 14 mov 0x14(%ebp),%ebx 10e2c7: 8a 55 18 mov 0x18(%ebp),%dl POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); 10e2ca: 8d 45 e4 lea -0x1c(%ebp),%eax RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( mqd_t id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) _Objects_Get( 10e2cd: 50 push %eax 10e2ce: 56 push %esi 10e2cf: 68 f4 cc 12 00 push $0x12ccf4 10e2d4: 88 55 d4 mov %dl,-0x2c(%ebp) 10e2d7: e8 fc 2a 00 00 call 110dd8 <_Objects_Get> switch ( location ) { 10e2dc: 83 c4 10 add $0x10,%esp 10e2df: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10e2e3: 8a 55 d4 mov -0x2c(%ebp),%dl 10e2e6: 0f 85 aa 00 00 00 jne 10e396 <_POSIX_Message_queue_Receive_support+0xde> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10e2ec: 8b 78 14 mov 0x14(%eax),%edi 10e2ef: 89 f9 mov %edi,%ecx 10e2f1: 83 e1 03 and $0x3,%ecx 10e2f4: 49 dec %ecx 10e2f5: 75 0a jne 10e301 <_POSIX_Message_queue_Receive_support+0x49> _Thread_Enable_dispatch(); 10e2f7: e8 2e 35 00 00 call 11182a <_Thread_Enable_dispatch> 10e2fc: e9 95 00 00 00 jmp 10e396 <_POSIX_Message_queue_Receive_support+0xde> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10e301: 8b 40 10 mov 0x10(%eax),%eax if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10e304: 8b 48 68 mov 0x68(%eax),%ecx 10e307: 39 4d 10 cmp %ecx,0x10(%ebp) 10e30a: 73 15 jae 10e321 <_POSIX_Message_queue_Receive_support+0x69> _Thread_Enable_dispatch(); 10e30c: e8 19 35 00 00 call 11182a <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10e311: e8 52 8b 00 00 call 116e68 <__errno> 10e316: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10e31c: e9 80 00 00 00 jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10e321: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10e328: 31 c9 xor %ecx,%ecx 10e32a: 84 d2 test %dl,%dl 10e32c: 74 09 je 10e337 <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true; 10e32e: 81 e7 00 40 00 00 and $0x4000,%edi 10e334: 0f 94 c1 sete %cl do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10e337: 52 push %edx 10e338: 52 push %edx 10e339: ff 75 1c pushl 0x1c(%ebp) 10e33c: 0f b6 c9 movzbl %cl,%ecx 10e33f: 51 push %ecx 10e340: 8d 55 e0 lea -0x20(%ebp),%edx 10e343: 52 push %edx 10e344: ff 75 0c pushl 0xc(%ebp) 10e347: 56 push %esi 10e348: 83 c0 1c add $0x1c,%eax 10e34b: 50 push %eax 10e34c: e8 7f 1c 00 00 call 10ffd0 <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10e351: 83 c4 20 add $0x20,%esp 10e354: e8 d1 34 00 00 call 11182a <_Thread_Enable_dispatch> *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10e359: a1 6c cd 12 00 mov 0x12cd6c,%eax RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core( CORE_message_queue_Submit_types priority ) { /* absolute value without a library dependency */ return ((priority >= 0) ? priority : -priority); 10e35e: 8b 50 24 mov 0x24(%eax),%edx 10e361: c1 fa 1f sar $0x1f,%edx 10e364: 8b 48 24 mov 0x24(%eax),%ecx 10e367: 31 d1 xor %edx,%ecx 10e369: 89 0b mov %ecx,(%ebx) 10e36b: 29 13 sub %edx,(%ebx) if ( !_Thread_Executing->Wait.return_code ) 10e36d: 83 78 34 00 cmpl $0x0,0x34(%eax) 10e371: 75 05 jne 10e378 <_POSIX_Message_queue_Receive_support+0xc0> return length_out; 10e373: 8b 45 e0 mov -0x20(%ebp),%eax 10e376: eb 2c jmp 10e3a4 <_POSIX_Message_queue_Receive_support+0xec> rtems_set_errno_and_return_minus_one( 10e378: e8 eb 8a 00 00 call 116e68 <__errno> 10e37d: 89 c3 mov %eax,%ebx 10e37f: 83 ec 0c sub $0xc,%esp 10e382: a1 6c cd 12 00 mov 0x12cd6c,%eax 10e387: ff 70 34 pushl 0x34(%eax) 10e38a: e8 ed 01 00 00 call 10e57c <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10e38f: 89 03 mov %eax,(%ebx) 10e391: 83 c4 10 add $0x10,%esp 10e394: eb 0b jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e396: e8 cd 8a 00 00 call 116e68 <__errno> 10e39b: c7 00 09 00 00 00 movl $0x9,(%eax) 10e3a1: 83 c8 ff or $0xffffffff,%eax } 10e3a4: 8d 65 f4 lea -0xc(%ebp),%esp 10e3a7: 5b pop %ebx 10e3a8: 5e pop %esi 10e3a9: 5f pop %edi 10e3aa: c9 leave 10e3ab: c3 ret =============================================================================== 0010e94c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 10e94c: 55 push %ebp 10e94d: 89 e5 mov %esp,%ebp 10e94f: 83 ec 08 sub $0x8,%esp 10e952: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e955: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10e95b: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10e962: 75 2c jne 10e990 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN 10e964: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 10e96b: 75 23 jne 10e990 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44> thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 10e96d: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10e974: 74 1a je 10e990 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10e976: a1 d0 52 12 00 mov 0x1252d0,%eax 10e97b: 48 dec %eax 10e97c: a3 d0 52 12 00 mov %eax,0x1252d0 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 10e981: 50 push %eax 10e982: 50 push %eax 10e983: 6a ff push $0xffffffff 10e985: 52 push %edx 10e986: e8 51 08 00 00 call 10f1dc <_POSIX_Thread_Exit> 10e98b: 83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 10e98e: c9 leave 10e98f: c3 ret 10e990: c9 leave thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); } else _Thread_Enable_dispatch(); 10e991: e9 ec da ff ff jmp 10c482 <_Thread_Enable_dispatch> =============================================================================== 0010fbd4 <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 10fbd4: 55 push %ebp 10fbd5: 89 e5 mov %esp,%ebp 10fbd7: 57 push %edi 10fbd8: 56 push %esi 10fbd9: 53 push %ebx 10fbda: 83 ec 28 sub $0x28,%esp 10fbdd: 8b 55 08 mov 0x8(%ebp),%edx 10fbe0: 8b 5d 0c mov 0xc(%ebp),%ebx 10fbe3: 8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10fbe6: ff 33 pushl (%ebx) 10fbe8: 89 55 e0 mov %edx,-0x20(%ebp) 10fbeb: e8 c4 ff ff ff call 10fbb4 <_POSIX_Priority_Is_valid> 10fbf0: 83 c4 10 add $0x10,%esp return EINVAL; 10fbf3: be 16 00 00 00 mov $0x16,%esi struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10fbf8: 84 c0 test %al,%al 10fbfa: 8b 55 e0 mov -0x20(%ebp),%edx 10fbfd: 0f 84 a4 00 00 00 je 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10fc03: c7 07 00 00 00 00 movl $0x0,(%edi) *budget_callout = NULL; 10fc09: 8b 45 14 mov 0x14(%ebp),%eax 10fc0c: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 10fc12: 85 d2 test %edx,%edx 10fc14: 75 0b jne 10fc21 <_POSIX_Thread_Translate_sched_param+0x4d> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10fc16: c7 07 01 00 00 00 movl $0x1,(%edi) 10fc1c: e9 83 00 00 00 jmp 10fca4 <_POSIX_Thread_Translate_sched_param+0xd0> return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 10fc21: 31 f6 xor %esi,%esi if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 10fc23: 83 fa 01 cmp $0x1,%edx 10fc26: 74 7f je 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 10fc28: 83 fa 02 cmp $0x2,%edx 10fc2b: 75 08 jne 10fc35 <_POSIX_Thread_Translate_sched_param+0x61> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 10fc2d: c7 07 02 00 00 00 movl $0x2,(%edi) return 0; 10fc33: eb 72 jmp 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; 10fc35: be 16 00 00 00 mov $0x16,%esi if ( policy == SCHED_RR ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; return 0; } if ( policy == SCHED_SPORADIC ) { 10fc3a: 83 fa 04 cmp $0x4,%edx 10fc3d: 75 68 jne 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3> if ( (param->sched_ss_repl_period.tv_sec == 0) && 10fc3f: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10fc43: 75 06 jne 10fc4b <_POSIX_Thread_Translate_sched_param+0x77> 10fc45: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10fc49: 74 5c je 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3> (param->sched_ss_repl_period.tv_nsec == 0) ) return EINVAL; if ( (param->sched_ss_init_budget.tv_sec == 0) && 10fc4b: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fc4f: 75 0b jne 10fc5c <_POSIX_Thread_Translate_sched_param+0x88> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; 10fc51: be 16 00 00 00 mov $0x16,%esi if ( policy == SCHED_SPORADIC ) { if ( (param->sched_ss_repl_period.tv_sec == 0) && (param->sched_ss_repl_period.tv_nsec == 0) ) return EINVAL; if ( (param->sched_ss_init_budget.tv_sec == 0) && 10fc56: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fc5a: 74 4b je 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 10fc5c: 83 ec 0c sub $0xc,%esp 10fc5f: 8d 43 08 lea 0x8(%ebx),%eax 10fc62: 50 push %eax 10fc63: e8 18 de ff ff call 10da80 <_Timespec_To_ticks> 10fc68: 89 45 e4 mov %eax,-0x1c(%ebp) _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 10fc6b: 8d 43 10 lea 0x10(%ebx),%eax 10fc6e: 89 04 24 mov %eax,(%esp) 10fc71: e8 0a de ff ff call 10da80 <_Timespec_To_ticks> if ( (param->sched_ss_init_budget.tv_sec == 0) && (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 10fc76: 83 c4 10 add $0x10,%esp _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; 10fc79: be 16 00 00 00 mov $0x16,%esi if ( (param->sched_ss_init_budget.tv_sec == 0) && (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 10fc7e: 39 45 e4 cmp %eax,-0x1c(%ebp) 10fc81: 72 24 jb 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3> _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) ) 10fc83: 83 ec 0c sub $0xc,%esp 10fc86: ff 73 04 pushl 0x4(%ebx) 10fc89: e8 26 ff ff ff call 10fbb4 <_POSIX_Priority_Is_valid> 10fc8e: 83 c4 10 add $0x10,%esp 10fc91: 84 c0 test %al,%al 10fc93: 74 12 je 10fca7 <_POSIX_Thread_Translate_sched_param+0xd3> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 10fc95: c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 10fc9b: 8b 45 14 mov 0x14(%ebp),%eax 10fc9e: c7 00 e9 a7 10 00 movl $0x10a7e9,(%eax) return 0; 10fca4: 66 31 f6 xor %si,%si } return EINVAL; } 10fca7: 89 f0 mov %esi,%eax 10fca9: 8d 65 f4 lea -0xc(%ebp),%esp 10fcac: 5b pop %ebx 10fcad: 5e pop %esi 10fcae: 5f pop %edi 10fcaf: c9 leave 10fcb0: c3 ret =============================================================================== 0010a4ec <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10a4ec: 55 push %ebp 10a4ed: 89 e5 mov %esp,%ebp 10a4ef: 57 push %edi 10a4f0: 56 push %esi 10a4f1: 53 push %ebx 10a4f2: 83 ec 6c sub $0x6c,%esp uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = Configuration_POSIX_API.User_initialization_threads_table; 10a4f5: 8b 3d 10 12 12 00 mov 0x121210,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10a4fb: 8b 15 0c 12 12 00 mov 0x12120c,%edx if ( !user_threads || maximum == 0 ) 10a501: 85 d2 test %edx,%edx 10a503: 74 54 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a505: 85 ff test %edi,%edi 10a507: 74 50 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a509: 31 db xor %ebx,%ebx for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 10a50b: 8d 75 a4 lea -0x5c(%ebp),%esi 10a50e: 83 ec 0c sub $0xc,%esp 10a511: 56 push %esi 10a512: 89 55 94 mov %edx,-0x6c(%ebp) 10a515: e8 9a 57 00 00 call 10fcb4 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10a51a: 5a pop %edx 10a51b: 59 pop %ecx 10a51c: 6a 02 push $0x2 10a51e: 56 push %esi 10a51f: e8 b8 57 00 00 call 10fcdc (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10a524: 59 pop %ecx 10a525: 58 pop %eax 10a526: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10a52a: 56 push %esi 10a52b: e8 d8 57 00 00 call 10fd08 status = pthread_create( 10a530: 6a 00 push $0x0 10a532: ff 34 df pushl (%edi,%ebx,8) 10a535: 56 push %esi 10a536: 8d 45 e4 lea -0x1c(%ebp),%eax 10a539: 50 push %eax 10a53a: e8 e5 fc ff ff call 10a224 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10a53f: 83 c4 20 add $0x20,%esp 10a542: 85 c0 test %eax,%eax 10a544: 8b 55 94 mov -0x6c(%ebp),%edx 10a547: 74 0b je 10a554 <_POSIX_Threads_Initialize_user_threads_body+0x68> _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 10a549: 52 push %edx 10a54a: 50 push %eax 10a54b: 6a 01 push $0x1 10a54d: 6a 02 push $0x2 10a54f: e8 f8 1b 00 00 call 10c14c <_Internal_error_Occurred> * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 10a554: 43 inc %ebx 10a555: 39 d3 cmp %edx,%ebx 10a557: 72 b5 jb 10a50e <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); } } 10a559: 8d 65 f4 lea -0xc(%ebp),%esp 10a55c: 5b pop %ebx 10a55d: 5e pop %esi 10a55e: 5f pop %edi 10a55f: c9 leave 10a560: c3 ret =============================================================================== 0010ed2f <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 10ed2f: 55 push %ebp 10ed30: 89 e5 mov %esp,%ebp 10ed32: 56 push %esi 10ed33: 53 push %ebx 10ed34: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ed37: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget ); 10ed3d: 83 ec 0c sub $0xc,%esp 10ed40: 8d 86 98 00 00 00 lea 0x98(%esi),%eax 10ed46: 50 push %eax 10ed47: e8 44 0e 00 00 call 10fb90 <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 10ed4c: 89 43 78 mov %eax,0x78(%ebx) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10ed4f: 0f b6 05 f4 01 12 00 movzbl 0x1201f4,%eax 10ed56: 2b 86 88 00 00 00 sub 0x88(%esi),%eax new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); the_thread->real_priority = new_priority; 10ed5c: 89 43 18 mov %eax,0x18(%ebx) */ #if 0 printk( "TSR %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 10ed5f: 83 c4 10 add $0x10,%esp 10ed62: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10ed66: 75 12 jne 10ed7a <_POSIX_Threads_Sporadic_budget_TSR+0x4b><== NEVER TAKEN /* * If this would make them less important, then do not change it. */ if ( the_thread->current_priority > new_priority ) { 10ed68: 39 43 14 cmp %eax,0x14(%ebx) 10ed6b: 76 0d jbe 10ed7a <_POSIX_Threads_Sporadic_budget_TSR+0x4b> _Thread_Change_priority( the_thread, new_priority, true ); 10ed6d: 52 push %edx 10ed6e: 6a 01 push $0x1 10ed70: 50 push %eax 10ed71: 53 push %ebx 10ed72: e8 1d cf ff ff call 10bc94 <_Thread_Change_priority> 10ed77: 83 c4 10 add $0x10,%esp #endif } } /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ); 10ed7a: 83 ec 0c sub $0xc,%esp 10ed7d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax 10ed83: 50 push %eax 10ed84: e8 07 0e 00 00 call 10fb90 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10ed89: 89 86 b4 00 00 00 mov %eax,0xb4(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10ed8f: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 10ed92: 81 c6 a8 00 00 00 add $0xa8,%esi 10ed98: 89 75 0c mov %esi,0xc(%ebp) 10ed9b: c7 45 08 c4 43 12 00 movl $0x1243c4,0x8(%ebp) } 10eda2: 8d 65 f8 lea -0x8(%ebp),%esp 10eda5: 5b pop %ebx 10eda6: 5e pop %esi 10eda7: c9 leave 10eda8: e9 d3 df ff ff jmp 10cd80 <_Watchdog_Insert> =============================================================================== 0010edad <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10edad: 55 push %ebp 10edae: 89 e5 mov %esp,%ebp 10edb0: 83 ec 08 sub $0x8,%esp 10edb3: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10edb6: 8b 88 ec 00 00 00 mov 0xec(%eax),%ecx /* * 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 */ 10edbc: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 10edc3: 0f b6 15 f4 01 12 00 movzbl 0x1201f4,%edx 10edca: 2b 91 8c 00 00 00 sub 0x8c(%ecx),%edx new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority); the_thread->real_priority = new_priority; 10edd0: 89 50 18 mov %edx,0x18(%eax) */ #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 ) { 10edd3: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10edd7: 75 12 jne 10edeb <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN /* * 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 ) { 10edd9: 39 50 14 cmp %edx,0x14(%eax) 10eddc: 73 0d jae 10edeb <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN _Thread_Change_priority( the_thread, new_priority, true ); 10edde: 51 push %ecx 10eddf: 6a 01 push $0x1 10ede1: 52 push %edx 10ede2: 50 push %eax 10ede3: e8 ac ce ff ff call 10bc94 <_Thread_Change_priority> 10ede8: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 10edeb: c9 leave 10edec: c3 ret =============================================================================== 0010a2ac <_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) { 10a2ac: 55 push %ebp 10a2ad: 89 e5 mov %esp,%ebp 10a2af: 53 push %ebx 10a2b0: 83 ec 04 sub $0x4,%esp 10a2b3: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a2b6: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a2b9: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 10a2bd: 75 06 jne 10a2c5 <_POSIX_Timer_TSR+0x19> 10a2bf: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10a2c3: 74 34 je 10a2f9 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10a2c5: 83 ec 0c sub $0xc,%esp 10a2c8: 53 push %ebx 10a2c9: 68 ac a2 10 00 push $0x10a2ac 10a2ce: ff 73 08 pushl 0x8(%ebx) 10a2d1: ff 73 64 pushl 0x64(%ebx) 10a2d4: 8d 43 10 lea 0x10(%ebx),%eax 10a2d7: 50 push %eax 10a2d8: e8 b3 56 00 00 call 10f990 <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a2dd: 83 c4 20 add $0x20,%esp 10a2e0: 84 c0 test %al,%al 10a2e2: 74 30 je 10a314 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a2e4: 83 ec 0c sub $0xc,%esp 10a2e7: 8d 43 6c lea 0x6c(%ebx),%eax 10a2ea: 50 push %eax 10a2eb: e8 5c 14 00 00 call 10b74c <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a2f0: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10a2f4: 83 c4 10 add $0x10,%esp 10a2f7: eb 04 jmp 10a2fd <_POSIX_Timer_TSR+0x51> } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a2f9: 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 ) ) { 10a2fd: 50 push %eax 10a2fe: 50 push %eax 10a2ff: ff 73 44 pushl 0x44(%ebx) 10a302: ff 73 38 pushl 0x38(%ebx) 10a305: e8 5a 52 00 00 call 10f564 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a30a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10a311: 83 c4 10 add $0x10,%esp } 10a314: 8b 5d fc mov -0x4(%ebp),%ebx 10a317: c9 leave 10a318: c3 ret =============================================================================== 00110b5c <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 110b5c: 55 push %ebp 110b5d: 89 e5 mov %esp,%ebp 110b5f: 57 push %edi 110b60: 56 push %esi 110b61: 53 push %ebx 110b62: 83 ec 68 sub $0x68,%esp 110b65: 8b 5d 0c mov 0xc(%ebp),%ebx siginfo_t siginfo_struct; sigset_t saved_signals_blocked; Thread_Wait_information stored_thread_wait_information; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 110b68: 6a 01 push $0x1 110b6a: 0f b6 45 10 movzbl 0x10(%ebp),%eax 110b6e: 50 push %eax 110b6f: 8d 45 dc lea -0x24(%ebp),%eax 110b72: 50 push %eax 110b73: 53 push %ebx 110b74: ff 75 08 pushl 0x8(%ebp) 110b77: e8 8c 00 00 00 call 110c08 <_POSIX_signals_Clear_signals> 110b7c: 83 c4 20 add $0x20,%esp is_global, true ) ) return false; 110b7f: 31 c9 xor %ecx,%ecx { siginfo_t siginfo_struct; sigset_t saved_signals_blocked; Thread_Wait_information stored_thread_wait_information; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 110b81: 84 c0 test %al,%al 110b83: 74 78 je 110bfd <_POSIX_signals_Check_signal+0xa1> #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 110b85: 6b d3 0c imul $0xc,%ebx,%edx 110b88: 8b 82 68 48 12 00 mov 0x124868(%edx),%eax 110b8e: 83 f8 01 cmp $0x1,%eax 110b91: 74 6a je 110bfd <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 110b93: 8b 4d 08 mov 0x8(%ebp),%ecx 110b96: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 110b9c: 89 4d a4 mov %ecx,-0x5c(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 110b9f: 0b 8a 64 48 12 00 or 0x124864(%edx),%ecx 110ba5: 8b 75 08 mov 0x8(%ebp),%esi 110ba8: 89 8e d0 00 00 00 mov %ecx,0xd0(%esi) /* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait, 110bae: 8d 7d b4 lea -0x4c(%ebp),%edi 110bb1: 8b 35 2c 48 12 00 mov 0x12482c,%esi 110bb7: 83 c6 20 add $0x20,%esi 110bba: b9 0a 00 00 00 mov $0xa,%ecx 110bbf: f3 a5 rep movsl %ds:(%esi),%es:(%edi) sizeof( Thread_Wait_information )); /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 110bc1: 83 ba 60 48 12 00 02 cmpl $0x2,0x124860(%edx) 110bc8: 75 09 jne 110bd3 <_POSIX_signals_Check_signal+0x77> case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 110bca: 52 push %edx 110bcb: 6a 00 push $0x0 110bcd: 8d 55 dc lea -0x24(%ebp),%edx 110bd0: 52 push %edx 110bd1: eb 03 jmp 110bd6 <_POSIX_signals_Check_signal+0x7a> &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 110bd3: 83 ec 0c sub $0xc,%esp 110bd6: 53 push %ebx 110bd7: ff d0 call *%eax break; 110bd9: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 110bdc: 8b 3d 2c 48 12 00 mov 0x12482c,%edi 110be2: 83 c7 20 add $0x20,%edi 110be5: 8d 75 b4 lea -0x4c(%ebp),%esi 110be8: b9 0a 00 00 00 mov $0xa,%ecx 110bed: f3 a5 rep movsl %ds:(%esi),%es:(%edi) sizeof( Thread_Wait_information )); /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 110bef: 8b 75 a4 mov -0x5c(%ebp),%esi 110bf2: 8b 4d 08 mov 0x8(%ebp),%ecx 110bf5: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx) return true; 110bfb: b1 01 mov $0x1,%cl } 110bfd: 88 c8 mov %cl,%al 110bff: 8d 65 f4 lea -0xc(%ebp),%esp 110c02: 5b pop %ebx 110c03: 5e pop %esi 110c04: 5f pop %edi 110c05: c9 leave 110c06: c3 ret =============================================================================== 001110f0 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 1110f0: 55 push %ebp 1110f1: 89 e5 mov %esp,%ebp 1110f3: 53 push %ebx 1110f4: 8b 4d 08 mov 0x8(%ebp),%ecx clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 1110f7: 9c pushf 1110f8: fa cli 1110f9: 5a pop %edx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 1110fa: 6b c1 0c imul $0xc,%ecx,%eax 1110fd: 83 b8 60 48 12 00 02 cmpl $0x2,0x124860(%eax) 111104: 75 0e jne 111114 <_POSIX_signals_Clear_process_signals+0x24> RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 111106: 8d 98 5c 4a 12 00 lea 0x124a5c(%eax),%ebx if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 11110c: 39 98 58 4a 12 00 cmp %ebx,0x124a58(%eax) 111112: 75 0e jne 111122 <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN 111114: 49 dec %ecx 111115: b8 fe ff ff ff mov $0xfffffffe,%eax clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 11111a: d3 c0 rol %cl,%eax 11111c: 21 05 54 4a 12 00 and %eax,0x124a54 } _ISR_Enable( level ); 111122: 52 push %edx 111123: 9d popf } 111124: 5b pop %ebx 111125: c9 leave 111126: c3 ret =============================================================================== 0010ab64 <_POSIX_signals_Get_lowest>: #include int _POSIX_signals_Get_lowest( sigset_t set ) { 10ab64: 55 push %ebp 10ab65: 89 e5 mov %esp,%ebp 10ab67: 56 push %esi 10ab68: 53 push %ebx 10ab69: 8b 55 08 mov 0x8(%ebp),%edx int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ab6c: b8 1b 00 00 00 mov $0x1b,%eax 10ab71: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10ab76: 8d 48 ff lea -0x1(%eax),%ecx 10ab79: 89 de mov %ebx,%esi 10ab7b: d3 e6 shl %cl,%esi ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10ab7d: 85 d6 test %edx,%esi 10ab7f: 75 1e jne 10ab9f <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ab81: 40 inc %eax 10ab82: 83 f8 20 cmp $0x20,%eax 10ab85: 75 ef jne 10ab76 <_POSIX_signals_Get_lowest+0x12> 10ab87: b0 01 mov $0x1,%al 10ab89: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10ab8e: 8d 48 ff lea -0x1(%eax),%ecx 10ab91: 89 de mov %ebx,%esi 10ab93: d3 e6 shl %cl,%esi #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10ab95: 85 d6 test %edx,%esi 10ab97: 75 06 jne 10ab9f <_POSIX_signals_Get_lowest+0x3b> */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10ab99: 40 inc %eax 10ab9a: 83 f8 1b cmp $0x1b,%eax 10ab9d: 75 ef jne 10ab8e <_POSIX_signals_Get_lowest+0x2a><== ALWAYS TAKEN * a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; } 10ab9f: 5b pop %ebx 10aba0: 5e pop %esi 10aba1: c9 leave 10aba2: c3 ret =============================================================================== 001218e8 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 1218e8: 55 push %ebp 1218e9: 89 e5 mov %esp,%ebp 1218eb: 57 push %edi 1218ec: 56 push %esi 1218ed: 53 push %ebx 1218ee: 83 ec 0c sub $0xc,%esp 1218f1: 8b 5d 08 mov 0x8(%ebp),%ebx 1218f4: 8b 75 0c mov 0xc(%ebp),%esi POSIX_API_Control *api; sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1218f7: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 1218fd: 8d 4e ff lea -0x1(%esi),%ecx 121900: ba 01 00 00 00 mov $0x1,%edx 121905: d3 e2 shl %cl,%edx /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 121907: 8b 4b 10 mov 0x10(%ebx),%ecx 12190a: 89 cf mov %ecx,%edi 12190c: 81 e7 00 80 00 10 and $0x10008000,%edi 121912: 81 ff 00 80 00 10 cmp $0x10008000,%edi 121918: 75 58 jne 121972 <_POSIX_signals_Unblock_thread+0x8a> if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 12191a: 85 53 30 test %edx,0x30(%ebx) 12191d: 75 12 jne 121931 <_POSIX_signals_Unblock_thread+0x49> 12191f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 121925: f7 d0 not %eax /* * This should only be reached via pthread_kill(). */ return false; 121927: 31 ff xor %edi,%edi * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 121929: 85 c2 test %eax,%edx 12192b: 0f 84 b0 00 00 00 je 1219e1 <_POSIX_signals_Unblock_thread+0xf9> the_thread->Wait.return_code = EINTR; 121931: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 121938: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 12193b: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 12193f: 75 12 jne 121953 <_POSIX_signals_Unblock_thread+0x6b> the_info->si_signo = signo; 121941: 89 30 mov %esi,(%eax) the_info->si_code = SI_USER; 121943: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 12194a: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 121951: eb 0c jmp 12195f <_POSIX_signals_Unblock_thread+0x77> } else { *the_info = *info; 121953: b9 03 00 00 00 mov $0x3,%ecx 121958: 89 c7 mov %eax,%edi 12195a: 8b 75 10 mov 0x10(%ebp),%esi 12195d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 12195f: 83 ec 0c sub $0xc,%esp 121962: 53 push %ebx 121963: e8 88 f5 fe ff call 110ef0 <_Thread_queue_Extract_with_proxy> return true; 121968: 83 c4 10 add $0x10,%esp 12196b: bf 01 00 00 00 mov $0x1,%edi 121970: eb 6f jmp 1219e1 <_POSIX_signals_Unblock_thread+0xf9> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 121972: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 121978: f7 d0 not %eax } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; 12197a: 31 ff xor %edi,%edi } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 12197c: 85 c2 test %eax,%edx 12197e: 74 61 je 1219e1 <_POSIX_signals_Unblock_thread+0xf9> * it is not blocked, THEN * we need to dispatch at the end of this ISR. * + Any other combination, do nothing. */ if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) { 121980: f7 c1 00 00 00 10 test $0x10000000,%ecx 121986: 74 3d je 1219c5 <_POSIX_signals_Unblock_thread+0xdd> the_thread->Wait.return_code = EINTR; 121988: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) /* * In pthread_cond_wait, a thread will be blocking on a thread * queue, but is also interruptible by a POSIX signal. */ if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 12198f: f7 c1 e0 be 03 00 test $0x3bee0,%ecx 121995: 74 0b je 1219a2 <_POSIX_signals_Unblock_thread+0xba> _Thread_queue_Extract_with_proxy( the_thread ); 121997: 83 ec 0c sub $0xc,%esp 12199a: 53 push %ebx 12199b: e8 50 f5 fe ff call 110ef0 <_Thread_queue_Extract_with_proxy> 1219a0: eb 1e jmp 1219c0 <_POSIX_signals_Unblock_thread+0xd8> else if ( _States_Is_delaying(the_thread->current_state) ) { 1219a2: 80 e1 08 and $0x8,%cl 1219a5: 74 3a je 1219e1 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 1219a7: 83 ec 0c sub $0xc,%esp 1219aa: 8d 43 48 lea 0x48(%ebx),%eax 1219ad: 50 push %eax 1219ae: e8 9d fc fe ff call 111650 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 1219b3: 58 pop %eax 1219b4: 5a pop %edx 1219b5: 68 f8 ff 03 10 push $0x1003fff8 1219ba: 53 push %ebx 1219bb: e8 a0 eb fe ff call 110560 <_Thread_Clear_state> 1219c0: 83 c4 10 add $0x10,%esp 1219c3: eb 1c jmp 1219e1 <_POSIX_signals_Unblock_thread+0xf9> _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 1219c5: 85 c9 test %ecx,%ecx 1219c7: 75 18 jne 1219e1 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1219c9: 83 3d 9c a9 12 00 00 cmpl $0x0,0x12a99c 1219d0: 74 0f je 1219e1 <_POSIX_signals_Unblock_thread+0xf9> 1219d2: 3b 1d a0 a9 12 00 cmp 0x12a9a0,%ebx 1219d8: 75 07 jne 1219e1 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN _Thread_Dispatch_necessary = true; 1219da: c6 05 ac a9 12 00 01 movb $0x1,0x12a9ac } } return false; } 1219e1: 89 f8 mov %edi,%eax 1219e3: 8d 65 f4 lea -0xc(%ebp),%esp 1219e6: 5b pop %ebx 1219e7: 5e pop %esi 1219e8: 5f pop %edi 1219e9: c9 leave 1219ea: c3 ret =============================================================================== 0010b3b4 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10b3b4: 55 push %ebp 10b3b5: 89 e5 mov %esp,%ebp 10b3b7: 53 push %ebx 10b3b8: 83 ec 18 sub $0x18,%esp /* * When we get here, the Timer is already off the chain so we do not * have to worry about that -- hence no _Watchdog_Remove(). */ the_period = _Rate_monotonic_Get( id, &location ); 10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax 10b3be: 50 push %eax 10b3bf: ff 75 08 pushl 0x8(%ebp) 10b3c2: 68 14 73 12 00 push $0x127314 10b3c7: e8 d8 1a 00 00 call 10cea4 <_Objects_Get> 10b3cc: 89 c3 mov %eax,%ebx switch ( location ) { 10b3ce: 83 c4 10 add $0x10,%esp 10b3d1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10b3d5: 75 64 jne 10b43b <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10b3d7: 8b 40 40 mov 0x40(%eax),%eax if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b3da: f6 40 11 40 testb $0x40,0x11(%eax) 10b3de: 74 18 je 10b3f8 <_Rate_monotonic_Timeout+0x44> 10b3e0: 8b 53 08 mov 0x8(%ebx),%edx 10b3e3: 39 50 20 cmp %edx,0x20(%eax) 10b3e6: 75 10 jne 10b3f8 <_Rate_monotonic_Timeout+0x44> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10b3e8: 52 push %edx 10b3e9: 52 push %edx 10b3ea: 68 f8 ff 03 10 push $0x1003fff8 10b3ef: 50 push %eax 10b3f0: e8 5b 21 00 00 call 10d550 <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10b3f5: 59 pop %ecx 10b3f6: eb 10 jmp 10b408 <_Rate_monotonic_Timeout+0x54> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10b3f8: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 10b3fc: 75 2b jne 10b429 <_Rate_monotonic_Timeout+0x75> the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10b3fe: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) _Rate_monotonic_Initiate_statistics( the_period ); 10b405: 83 ec 0c sub $0xc,%esp 10b408: 53 push %ebx 10b409: e8 ec fa ff ff call 10aefa <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b40e: 8b 43 3c mov 0x3c(%ebx),%eax 10b411: 89 43 1c mov %eax,0x1c(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b414: 58 pop %eax 10b415: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 10b416: 83 c3 10 add $0x10,%ebx 10b419: 53 push %ebx 10b41a: 68 e8 74 12 00 push $0x1274e8 10b41f: e8 04 32 00 00 call 10e628 <_Watchdog_Insert> 10b424: 83 c4 10 add $0x10,%esp 10b427: eb 07 jmp 10b430 <_Rate_monotonic_Timeout+0x7c> } else the_period->state = RATE_MONOTONIC_EXPIRED; 10b429: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10b430: a1 04 74 12 00 mov 0x127404,%eax 10b435: 48 dec %eax 10b436: a3 04 74 12 00 mov %eax,0x127404 case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b43b: 8b 5d fc mov -0x4(%ebp),%ebx 10b43e: c9 leave 10b43f: c3 ret =============================================================================== 0010f810 <_Scheduler_priority_Block>: void _Scheduler_priority_Block( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { 10f810: 55 push %ebp 10f811: 89 e5 mov %esp,%ebp 10f813: 56 push %esi 10f814: 53 push %ebx 10f815: 8b 55 0c mov 0xc(%ebp),%edx RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_extract( Thread_Control *the_thread ) { Chain_Control *ready = the_thread->scheduler.priority->ready_chain; 10f818: 8b 82 8c 00 00 00 mov 0x8c(%edx),%eax 10f81e: 8b 00 mov (%eax),%eax if ( _Chain_Has_only_one_node( ready ) ) { 10f820: 8b 48 08 mov 0x8(%eax),%ecx 10f823: 39 08 cmp %ecx,(%eax) 10f825: 75 38 jne 10f85f <_Scheduler_priority_Block+0x4f> RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10f827: 8d 48 04 lea 0x4(%eax),%ecx 10f82a: 89 08 mov %ecx,(%eax) head->next = tail; head->previous = NULL; 10f82c: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) tail->previous = head; 10f833: 89 40 08 mov %eax,0x8(%eax) _Chain_Initialize_empty( ready ); _Priority_bit_map_Remove( &the_thread->scheduler.priority->Priority_map ); 10f836: 8b 8a 8c 00 00 00 mov 0x8c(%edx),%ecx RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor &= the_priority_map->block_minor; 10f83c: 8b 59 04 mov 0x4(%ecx),%ebx 10f83f: 66 8b 03 mov (%ebx),%ax 10f842: 66 23 41 0e and 0xe(%ecx),%ax 10f846: 66 89 03 mov %ax,(%ebx) if ( *the_priority_map->minor == 0 ) 10f849: 66 85 c0 test %ax,%ax 10f84c: 75 1b jne 10f869 <_Scheduler_priority_Block+0x59> _Priority_Major_bit_map &= the_priority_map->block_major; 10f84e: 66 a1 3c 48 12 00 mov 0x12483c,%ax 10f854: 23 41 0c and 0xc(%ecx),%eax 10f857: 66 a3 3c 48 12 00 mov %ax,0x12483c 10f85d: eb 0a jmp 10f869 <_Scheduler_priority_Block+0x59> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10f85f: 8b 0a mov (%edx),%ecx previous = the_node->previous; 10f861: 8b 42 04 mov 0x4(%edx),%eax next->previous = previous; 10f864: 89 41 04 mov %eax,0x4(%ecx) previous->next = next; 10f867: 89 08 mov %ecx,(%eax) { _Scheduler_priority_Ready_queue_extract(the_thread); /* TODO: flash critical section */ if ( _Thread_Is_heir( the_thread ) ) 10f869: 3b 15 30 48 12 00 cmp 0x124830,%edx 10f86f: 75 42 jne 10f8b3 <_Scheduler_priority_Block+0xa3> RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void ) { Priority_bit_map_Control minor; Priority_bit_map_Control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major ); 10f871: 66 8b 35 3c 48 12 00 mov 0x12483c,%si 10f878: 31 c9 xor %ecx,%ecx 10f87a: 89 cb mov %ecx,%ebx 10f87c: 66 0f bc de bsf %si,%bx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10f880: 0f b7 db movzwl %bx,%ebx 10f883: 66 8b b4 1b 40 48 12 mov 0x124840(%ebx,%ebx,1),%si 10f88a: 00 10f88b: 66 0f bc ce bsf %si,%cx return (_Priority_Bits_index( major ) << 4) + 10f88f: c1 e3 04 shl $0x4,%ebx 10f892: 0f b7 c9 movzwl %cx,%ecx 10f895: 8d 04 0b lea (%ebx,%ecx,1),%eax Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10f898: 6b c0 0c imul $0xc,%eax,%eax 10f89b: 8b 4d 08 mov 0x8(%ebp),%ecx 10f89e: 03 01 add (%ecx),%eax _Scheduler_priority_Block_body(the_scheduler, the_thread); } 10f8a0: 8b 18 mov (%eax),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10f8a2: 83 c0 04 add $0x4,%eax return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10f8a5: 31 c9 xor %ecx,%ecx Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10f8a7: 39 c3 cmp %eax,%ebx 10f8a9: 74 02 je 10f8ad <_Scheduler_priority_Block+0x9d><== NEVER TAKEN return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); 10f8ab: 89 d9 mov %ebx,%ecx RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10f8ad: 89 0d 30 48 12 00 mov %ecx,0x124830 /* TODO: flash critical section */ if ( _Thread_Is_heir( the_thread ) ) _Scheduler_priority_Schedule_body(the_scheduler); if ( _Thread_Is_executing( the_thread ) ) 10f8b3: 3b 15 2c 48 12 00 cmp 0x12482c,%edx 10f8b9: 75 07 jne 10f8c2 <_Scheduler_priority_Block+0xb2> _Thread_Dispatch_necessary = true; 10f8bb: c6 05 38 48 12 00 01 movb $0x1,0x124838 10f8c2: 5b pop %ebx 10f8c3: 5e pop %esi 10f8c4: c9 leave 10f8c5: c3 ret =============================================================================== 0010baac <_Scheduler_priority_Schedule>: */ void _Scheduler_priority_Schedule( Scheduler_Control *the_scheduler ) { 10baac: 55 push %ebp 10baad: 89 e5 mov %esp,%ebp 10baaf: 53 push %ebx RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void ) { Priority_bit_map_Control minor; Priority_bit_map_Control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major ); 10bab0: 66 8b 1d 3c 48 12 00 mov 0x12483c,%bx 10bab7: 31 d2 xor %edx,%edx 10bab9: 89 d1 mov %edx,%ecx 10babb: 66 0f bc cb bsf %bx,%cx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10babf: 0f b7 c9 movzwl %cx,%ecx 10bac2: 66 8b 9c 09 40 48 12 mov 0x124840(%ecx,%ecx,1),%bx 10bac9: 00 10baca: 66 0f bc d3 bsf %bx,%dx return (_Priority_Bits_index( major ) << 4) + 10bace: c1 e1 04 shl $0x4,%ecx 10bad1: 0f b7 d2 movzwl %dx,%edx 10bad4: 8d 04 11 lea (%ecx,%edx,1),%eax Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10bad7: 6b c0 0c imul $0xc,%eax,%eax 10bada: 8b 55 08 mov 0x8(%ebp),%edx 10badd: 03 02 add (%edx),%eax _Scheduler_priority_Schedule_body( the_scheduler ); } 10badf: 8b 08 mov (%eax),%ecx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10bae1: 83 c0 04 add $0x4,%eax return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10bae4: 31 d2 xor %edx,%edx Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10bae6: 39 c1 cmp %eax,%ecx 10bae8: 74 02 je 10baec <_Scheduler_priority_Schedule+0x40><== NEVER TAKEN return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); 10baea: 89 ca mov %ecx,%edx RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10baec: 89 15 30 48 12 00 mov %edx,0x124830 10baf2: 5b pop %ebx 10baf3: c9 leave 10baf4: c3 ret =============================================================================== 0010acb4 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10acb4: 55 push %ebp 10acb5: 89 e5 mov %esp,%ebp 10acb7: 56 push %esi 10acb8: 53 push %ebx 10acb9: 8b 4d 08 mov 0x8(%ebp),%ecx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); 10acbc: 8b 35 84 42 12 00 mov 0x124284,%esi (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; 10acc2: 31 db xor %ebx,%ebx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10acc4: 85 c9 test %ecx,%ecx 10acc6: 74 57 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10acc8: b8 40 42 0f 00 mov $0xf4240,%eax 10accd: 31 d2 xor %edx,%edx 10accf: f7 f6 div %esi rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10acd1: 39 41 18 cmp %eax,0x18(%ecx) 10acd4: 73 49 jae 10ad1f <_TOD_Validate+0x6b> (the_tod->ticks >= ticks_per_second) || 10acd6: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10acda: 77 43 ja 10ad1f <_TOD_Validate+0x6b> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10acdc: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10ace0: 77 3d ja 10ad1f <_TOD_Validate+0x6b> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10ace2: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10ace6: 77 37 ja 10ad1f <_TOD_Validate+0x6b> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10ace8: 8b 41 04 mov 0x4(%ecx),%eax rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || 10aceb: 85 c0 test %eax,%eax 10aced: 74 30 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->month == 0) || 10acef: 83 f8 0c cmp $0xc,%eax 10acf2: 77 2b ja 10ad1f <_TOD_Validate+0x6b> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10acf4: 8b 31 mov (%ecx),%esi (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || 10acf6: 81 fe c3 07 00 00 cmp $0x7c3,%esi 10acfc: 76 21 jbe 10ad1f <_TOD_Validate+0x6b> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10acfe: 8b 51 08 mov 0x8(%ecx),%edx (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10ad01: 85 d2 test %edx,%edx 10ad03: 74 1a je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10ad05: 83 e6 03 and $0x3,%esi 10ad08: 75 09 jne 10ad13 <_TOD_Validate+0x5f> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10ad0a: 8b 04 85 6c 14 12 00 mov 0x12146c(,%eax,4),%eax 10ad11: eb 07 jmp 10ad1a <_TOD_Validate+0x66> else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad13: 8b 04 85 38 14 12 00 mov 0x121438(,%eax,4),%eax * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 10ad1a: 39 c2 cmp %eax,%edx 10ad1c: 0f 96 c3 setbe %bl if ( the_tod->day > days_in_month ) return false; return true; } 10ad1f: 88 d8 mov %bl,%al 10ad21: 5b pop %ebx 10ad22: 5e pop %esi 10ad23: c9 leave 10ad24: c3 ret =============================================================================== 0010bc94 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10bc94: 55 push %ebp 10bc95: 89 e5 mov %esp,%ebp 10bc97: 57 push %edi 10bc98: 56 push %esi 10bc99: 53 push %ebx 10bc9a: 83 ec 28 sub $0x28,%esp 10bc9d: 8b 5d 08 mov 0x8(%ebp),%ebx 10bca0: 8b 75 0c mov 0xc(%ebp),%esi 10bca3: 8a 45 10 mov 0x10(%ebp),%al 10bca6: 88 45 e7 mov %al,-0x19(%ebp) */ /* * Save original state */ original_state = the_thread->current_state; 10bca9: 8b 7b 10 mov 0x10(%ebx),%edi /* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread ); 10bcac: 53 push %ebx 10bcad: e8 1a 0c 00 00 call 10c8cc <_Thread_Set_transient> /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 10bcb2: 83 c4 10 add $0x10,%esp 10bcb5: 39 73 14 cmp %esi,0x14(%ebx) 10bcb8: 74 0c je 10bcc6 <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10bcba: 50 push %eax 10bcbb: 50 push %eax 10bcbc: 56 push %esi 10bcbd: 53 push %ebx 10bcbe: e8 a9 0b 00 00 call 10c86c <_Thread_Set_priority> 10bcc3: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10bcc6: 9c pushf 10bcc7: fa cli 10bcc8: 5e pop %esi /* * If the thread has more than STATES_TRANSIENT set, then it is blocked, * If it is blocked on a thread queue, then we need to requeue it. */ state = the_thread->current_state; 10bcc9: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10bccc: 83 f8 04 cmp $0x4,%eax 10bccf: 74 2f je 10bd00 <_Thread_Change_priority+0x6c> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10bcd1: 83 e7 04 and $0x4,%edi 10bcd4: 75 08 jne 10bcde <_Thread_Change_priority+0x4a><== NEVER TAKEN RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 10bcd6: 89 c2 mov %eax,%edx 10bcd8: 83 e2 fb and $0xfffffffb,%edx 10bcdb: 89 53 10 mov %edx,0x10(%ebx) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10bcde: 56 push %esi 10bcdf: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10bce0: a9 e0 be 03 00 test $0x3bee0,%eax 10bce5: 0f 84 b5 00 00 00 je 10bda0 <_Thread_Change_priority+0x10c> _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10bceb: 89 5d 0c mov %ebx,0xc(%ebp) 10bcee: 8b 43 44 mov 0x44(%ebx),%eax 10bcf1: 89 45 08 mov %eax,0x8(%ebp) if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 10bcf4: 8d 65 f4 lea -0xc(%ebp),%esp 10bcf7: 5b pop %ebx 10bcf8: 5e pop %esi 10bcf9: 5f pop %edi 10bcfa: c9 leave /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10bcfb: e9 e4 0a 00 00 jmp 10c7e4 <_Thread_queue_Requeue> } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10bd00: 83 e7 04 and $0x4,%edi 10bd03: 75 6b jne 10bd70 <_Thread_Change_priority+0xdc><== NEVER TAKEN * Ready Queue with interrupts off. * * FIXME: hard-coded for priority scheduling. Might be ok since this * function is specific to priority scheduling? */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10bd05: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( prepend_it ) 10bd0c: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10bd10: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 10bd16: 74 2b je 10bd43 <_Thread_Change_priority+0xaf> RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10bd18: 8b 50 04 mov 0x4(%eax),%edx 10bd1b: 66 8b 48 0a mov 0xa(%eax),%cx 10bd1f: 66 09 0a or %cx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bd22: 66 8b 15 3c 48 12 00 mov 0x12483c,%dx 10bd29: 0b 50 08 or 0x8(%eax),%edx 10bd2c: 66 89 15 3c 48 12 00 mov %dx,0x12483c Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); _Chain_Prepend_unprotected( the_thread->scheduler.priority->ready_chain, 10bd33: 8b 00 mov (%eax),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10bd35: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10bd38: 8b 10 mov (%eax),%edx after_node->next = the_node; 10bd3a: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10bd3c: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10bd3e: 89 5a 04 mov %ebx,0x4(%edx) 10bd41: eb 2d jmp 10bd70 <_Thread_Change_priority+0xdc> RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10bd43: 8b 50 04 mov 0x4(%eax),%edx 10bd46: 66 8b 48 0a mov 0xa(%eax),%cx 10bd4a: 66 09 0a or %cx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bd4d: 66 8b 15 3c 48 12 00 mov 0x12483c,%dx 10bd54: 0b 50 08 or 0x8(%eax),%edx 10bd57: 66 89 15 3c 48 12 00 mov %dx,0x12483c Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); _Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain, 10bd5e: 8b 00 mov (%eax),%eax Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10bd60: 8b 50 08 mov 0x8(%eax),%edx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 10bd63: 8d 48 04 lea 0x4(%eax),%ecx 10bd66: 89 0b mov %ecx,(%ebx) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10bd68: 89 58 08 mov %ebx,0x8(%eax) old_last->next = the_node; 10bd6b: 89 1a mov %ebx,(%edx) the_node->previous = old_last; 10bd6d: 89 53 04 mov %edx,0x4(%ebx) _Scheduler_priority_Ready_queue_enqueue_first( the_thread ); else _Scheduler_priority_Ready_queue_enqueue( the_thread ); } _ISR_Flash( level ); 10bd70: 56 push %esi 10bd71: 9d popf 10bd72: fa cli */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( Scheduler_Control *the_scheduler ) { the_scheduler->Operations.schedule( the_scheduler ); 10bd73: 83 ec 0c sub $0xc,%esp 10bd76: 68 68 43 12 00 push $0x124368 10bd7b: ff 15 6c 43 12 00 call *0x12436c * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10bd81: a1 2c 48 12 00 mov 0x12482c,%eax * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Scheduler_Schedule(&_Scheduler); if ( !_Thread_Is_executing_also_the_heir() && 10bd86: 83 c4 10 add $0x10,%esp 10bd89: 3b 05 30 48 12 00 cmp 0x124830,%eax 10bd8f: 74 0d je 10bd9e <_Thread_Change_priority+0x10a> 10bd91: 80 78 74 00 cmpb $0x0,0x74(%eax) 10bd95: 74 07 je 10bd9e <_Thread_Change_priority+0x10a> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10bd97: c6 05 38 48 12 00 01 movb $0x1,0x124838 _ISR_Enable( level ); 10bd9e: 56 push %esi 10bd9f: 9d popf } 10bda0: 8d 65 f4 lea -0xc(%ebp),%esp 10bda3: 5b pop %ebx 10bda4: 5e pop %esi 10bda5: 5f pop %edi 10bda6: c9 leave 10bda7: c3 ret =============================================================================== 0010bf68 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10bf68: 55 push %ebp 10bf69: 89 e5 mov %esp,%ebp 10bf6b: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10bf6e: 8d 45 f4 lea -0xc(%ebp),%eax 10bf71: 50 push %eax 10bf72: ff 75 08 pushl 0x8(%ebp) 10bf75: e8 82 01 00 00 call 10c0fc <_Thread_Get> switch ( location ) { 10bf7a: 83 c4 10 add $0x10,%esp 10bf7d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10bf81: 75 1b jne 10bf9e <_Thread_Delay_ended+0x36><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10bf83: 52 push %edx 10bf84: 52 push %edx 10bf85: 68 18 00 00 10 push $0x10000018 10bf8a: 50 push %eax 10bf8b: e8 18 fe ff ff call 10bda8 <_Thread_Clear_state> 10bf90: a1 e0 42 12 00 mov 0x1242e0,%eax 10bf95: 48 dec %eax 10bf96: a3 e0 42 12 00 mov %eax,0x1242e0 10bf9b: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10bf9e: c9 leave 10bf9f: c3 ret =============================================================================== 0010bfa0 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10bfa0: 55 push %ebp 10bfa1: 89 e5 mov %esp,%ebp 10bfa3: 57 push %edi 10bfa4: 56 push %esi 10bfa5: 53 push %ebx 10bfa6: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10bfa9: 8b 1d 2c 48 12 00 mov 0x12482c,%ebx _ISR_Disable( level ); 10bfaf: 9c pushf 10bfb0: fa cli 10bfb1: 58 pop %eax #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); _Timestamp_Subtract( 10bfb2: 8d 7d d8 lea -0x28(%ebp),%edi Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10bfb5: e9 f9 00 00 00 jmp 10c0b3 <_Thread_Dispatch+0x113> heir = _Thread_Heir; 10bfba: 8b 35 30 48 12 00 mov 0x124830,%esi _Thread_Dispatch_disable_level = 1; 10bfc0: c7 05 e0 42 12 00 01 movl $0x1,0x1242e0 10bfc7: 00 00 00 _Thread_Dispatch_necessary = false; 10bfca: c6 05 38 48 12 00 00 movb $0x0,0x124838 _Thread_Executing = heir; 10bfd1: 89 35 2c 48 12 00 mov %esi,0x12482c /* * When the heir and executing are the same, then we are being * requested to do the post switch dispatching. This is normally * done to dispatch signals. */ if ( heir == executing ) 10bfd7: 39 de cmp %ebx,%esi 10bfd9: 0f 84 e2 00 00 00 je 10c0c1 <_Thread_Dispatch+0x121> */ #if __RTEMS_ADA__ executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 10bfdf: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10bfe3: 75 09 jne 10bfee <_Thread_Dispatch+0x4e> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10bfe5: 8b 15 b0 42 12 00 mov 0x1242b0,%edx 10bfeb: 89 56 78 mov %edx,0x78(%esi) _ISR_Enable( level ); 10bfee: 50 push %eax 10bfef: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10bff0: 83 ec 0c sub $0xc,%esp 10bff3: 8d 45 e0 lea -0x20(%ebp),%eax 10bff6: 50 push %eax 10bff7: e8 dc 34 00 00 call 10f4d8 <_TOD_Get_uptime> _Timestamp_Subtract( 10bffc: 83 c4 0c add $0xc,%esp 10bfff: 57 push %edi 10c000: 8d 45 e0 lea -0x20(%ebp),%eax 10c003: 50 push %eax 10c004: 68 b0 43 12 00 push $0x1243b0 10c009: e8 06 0b 00 00 call 10cb14 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10c00e: 58 pop %eax 10c00f: 5a pop %edx 10c010: 57 push %edi 10c011: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10c017: 50 push %eax 10c018: e8 c7 0a 00 00 call 10cae4 <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10c01d: 8b 45 e0 mov -0x20(%ebp),%eax 10c020: 8b 55 e4 mov -0x1c(%ebp),%edx 10c023: a3 b0 43 12 00 mov %eax,0x1243b0 10c028: 89 15 b4 43 12 00 mov %edx,0x1243b4 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10c02e: a1 88 43 12 00 mov 0x124388,%eax 10c033: 83 c4 10 add $0x10,%esp 10c036: 85 c0 test %eax,%eax 10c038: 74 10 je 10c04a <_Thread_Dispatch+0xaa> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10c03a: 8b 10 mov (%eax),%edx 10c03c: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx) *_Thread_libc_reent = heir->libc_reent; 10c042: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx 10c048: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10c04a: 51 push %ecx 10c04b: 51 push %ecx 10c04c: 56 push %esi 10c04d: 53 push %ebx 10c04e: e8 f9 0c 00 00 call 10cd4c <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10c053: 58 pop %eax 10c054: 5a pop %edx 10c055: 81 c6 c8 00 00 00 add $0xc8,%esi 10c05b: 56 push %esi 10c05c: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10c062: 50 push %eax 10c063: e8 a8 0f 00 00 call 10d010 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10c068: 83 c4 10 add $0x10,%esp 10c06b: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx) 10c072: 74 36 je 10c0aa <_Thread_Dispatch+0x10a> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 10c074: a1 64 43 12 00 mov 0x124364,%eax 10c079: 39 c3 cmp %eax,%ebx 10c07b: 74 2d je 10c0aa <_Thread_Dispatch+0x10a> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10c07d: 85 c0 test %eax,%eax 10c07f: 74 11 je 10c092 <_Thread_Dispatch+0xf2> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10c081: 83 ec 0c sub $0xc,%esp 10c084: 05 e0 00 00 00 add $0xe0,%eax 10c089: 50 push %eax 10c08a: e8 b5 0f 00 00 call 10d044 <_CPU_Context_save_fp> 10c08f: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10c092: 83 ec 0c sub $0xc,%esp 10c095: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax 10c09b: 50 push %eax 10c09c: e8 ad 0f 00 00 call 10d04e <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10c0a1: 89 1d 64 43 12 00 mov %ebx,0x124364 10c0a7: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10c0aa: 8b 1d 2c 48 12 00 mov 0x12482c,%ebx _ISR_Disable( level ); 10c0b0: 9c pushf 10c0b1: fa cli 10c0b2: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10c0b3: 8a 15 38 48 12 00 mov 0x124838,%dl 10c0b9: 84 d2 test %dl,%dl 10c0bb: 0f 85 f9 fe ff ff jne 10bfba <_Thread_Dispatch+0x1a> _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10c0c1: c7 05 e0 42 12 00 00 movl $0x0,0x1242e0 10c0c8: 00 00 00 _ISR_Enable( level ); 10c0cb: 50 push %eax 10c0cc: 9d popf _API_extensions_Run_postswitch(); 10c0cd: e8 0d e8 ff ff call 10a8df <_API_extensions_Run_postswitch> } 10c0d2: 8d 65 f4 lea -0xc(%ebp),%esp 10c0d5: 5b pop %ebx 10c0d6: 5e pop %esi 10c0d7: 5f pop %edi 10c0d8: c9 leave 10c0d9: c3 ret =============================================================================== 00110fa4 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 110fa4: 55 push %ebp 110fa5: 89 e5 mov %esp,%ebp 110fa7: 53 push %ebx 110fa8: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 110fab: 8b 1d 2c 48 12 00 mov 0x12482c,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110fb1: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax _ISR_Set_level(level); 110fb7: 85 c0 test %eax,%eax 110fb9: 74 03 je 110fbe <_Thread_Handler+0x1a> 110fbb: fa cli 110fbc: eb 01 jmp 110fbf <_Thread_Handler+0x1b> 110fbe: fb sti #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 110fbf: a0 a0 3f 12 00 mov 0x123fa0,%al 110fc4: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 110fc7: c6 05 a0 3f 12 00 01 movb $0x1,0x123fa0 #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 110fce: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx) 110fd5: 74 24 je 110ffb <_Thread_Handler+0x57> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 110fd7: a1 64 43 12 00 mov 0x124364,%eax 110fdc: 39 c3 cmp %eax,%ebx 110fde: 74 1b je 110ffb <_Thread_Handler+0x57> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 110fe0: 85 c0 test %eax,%eax 110fe2: 74 11 je 110ff5 <_Thread_Handler+0x51> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110fe4: 83 ec 0c sub $0xc,%esp 110fe7: 05 e0 00 00 00 add $0xe0,%eax 110fec: 50 push %eax 110fed: e8 52 c0 ff ff call 10d044 <_CPU_Context_save_fp> 110ff2: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 110ff5: 89 1d 64 43 12 00 mov %ebx,0x124364 /* * Take care that 'begin' extensions get to complete before * 'switch' extensions can run. This means must keep dispatch * disabled until all 'begin' extensions complete. */ _User_extensions_Thread_begin( executing ); 110ffb: 83 ec 0c sub $0xc,%esp 110ffe: 53 push %ebx 110fff: e8 f8 bb ff ff call 10cbfc <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 111004: e8 d1 b0 ff ff call 10c0da <_Thread_Enable_dispatch> /* * _init could be a weak symbol and we SHOULD test it but it isn't * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (!doneCons) /* && (volatile void *)_init) */ { 111009: 83 c4 10 add $0x10,%esp 11100c: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 111010: 75 05 jne 111017 <_Thread_Handler+0x73> INIT_NAME (); 111012: e8 69 be 00 00 call 11ce80 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 111017: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 11101d: 85 c0 test %eax,%eax 11101f: 75 0b jne 11102c <_Thread_Handler+0x88> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 111021: 83 ec 0c sub $0xc,%esp 111024: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 11102a: eb 0c jmp 111038 <_Thread_Handler+0x94> executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 11102c: 48 dec %eax 11102d: 75 15 jne 111044 <_Thread_Handler+0xa0> <== NEVER TAKEN executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 11102f: 83 ec 0c sub $0xc,%esp 111032: ff b3 98 00 00 00 pushl 0x98(%ebx) 111038: ff 93 90 00 00 00 call *0x90(%ebx) executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = 11103e: 89 43 28 mov %eax,0x28(%ebx) 111041: 83 c4 10 add $0x10,%esp * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 111044: 83 ec 0c sub $0xc,%esp 111047: 53 push %ebx 111048: e8 e0 bb ff ff call 10cc2d <_User_extensions_Thread_exitted> _Internal_error_Occurred( 11104d: 83 c4 0c add $0xc,%esp 111050: 6a 05 push $0x5 111052: 6a 01 push $0x1 111054: 6a 00 push $0x0 111056: e8 e1 a1 ff ff call 10b23c <_Internal_error_Occurred> =============================================================================== 0010c16c <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10c16c: 55 push %ebp 10c16d: 89 e5 mov %esp,%ebp 10c16f: 57 push %edi 10c170: 56 push %esi 10c171: 53 push %ebx 10c172: 83 ec 1c sub $0x1c,%esp 10c175: 8b 5d 0c mov 0xc(%ebp),%ebx 10c178: 8b 4d 10 mov 0x10(%ebp),%ecx 10c17b: 8b 75 14 mov 0x14(%ebp),%esi 10c17e: 8a 55 18 mov 0x18(%ebp),%dl 10c181: 8a 45 20 mov 0x20(%ebp),%al 10c184: 88 45 e3 mov %al,-0x1d(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10c187: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10c18e: 00 00 00 10c191: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx) 10c198: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10c19b: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10c1a2: 00 00 00 if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ stack = the_thread->Start.stack; #else if ( !stack_area ) { 10c1a5: 85 c9 test %ecx,%ecx 10c1a7: 75 31 jne 10c1da <_Thread_Initialize+0x6e> actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10c1a9: 51 push %ecx 10c1aa: 51 push %ecx 10c1ab: 56 push %esi 10c1ac: 53 push %ebx 10c1ad: 88 55 dc mov %dl,-0x24(%ebp) 10c1b0: e8 87 07 00 00 call 10c93c <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10c1b5: 83 c4 10 add $0x10,%esp 10c1b8: 39 f0 cmp %esi,%eax 10c1ba: 8a 55 dc mov -0x24(%ebp),%dl 10c1bd: 0f 82 f9 01 00 00 jb 10c3bc <_Thread_Initialize+0x250> 10c1c3: 85 c0 test %eax,%eax 10c1c5: 0f 84 f1 01 00 00 je 10c3bc <_Thread_Initialize+0x250><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10c1cb: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10c1d1: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx) 10c1d8: eb 09 jmp 10c1e3 <_Thread_Initialize+0x77> } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 10c1da: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx) 10c1e1: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10c1e3: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx) the_stack->size = size; 10c1e9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) extensions_area = NULL; the_thread->libc_reent = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) fp_area = NULL; 10c1ef: 31 ff xor %edi,%edi /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10c1f1: 84 d2 test %dl,%dl 10c1f3: 74 17 je 10c20c <_Thread_Initialize+0xa0> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10c1f5: 83 ec 0c sub $0xc,%esp 10c1f8: 6a 6c push $0x6c 10c1fa: e8 b3 0d 00 00 call 10cfb2 <_Workspace_Allocate> 10c1ff: 89 c7 mov %eax,%edi if ( !fp_area ) 10c201: 83 c4 10 add $0x10,%esp 10c204: 85 c0 test %eax,%eax 10c206: 0f 84 25 01 00 00 je 10c331 <_Thread_Initialize+0x1c5> goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10c20c: 89 bb e0 00 00 00 mov %edi,0xe0(%ebx) the_thread->Start.fp_context = fp_area; 10c212: 89 bb c0 00 00 00 mov %edi,0xc0(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c218: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10c21f: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10c226: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10c22d: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c234: a1 94 43 12 00 mov 0x124394,%eax * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c239: 31 f6 xor %esi,%esi #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c23b: 85 c0 test %eax,%eax 10c23d: 74 1d je 10c25c <_Thread_Initialize+0xf0> extensions_area = _Workspace_Allocate( 10c23f: 83 ec 0c sub $0xc,%esp 10c242: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10c249: 50 push %eax 10c24a: e8 63 0d 00 00 call 10cfb2 <_Workspace_Allocate> 10c24f: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10c251: 83 c4 10 add $0x10,%esp 10c254: 85 c0 test %eax,%eax 10c256: 0f 84 d7 00 00 00 je 10c333 <_Thread_Initialize+0x1c7> goto failed; } the_thread->extensions = (void **) extensions_area; 10c25c: 89 b3 f0 00 00 00 mov %esi,0xf0(%ebx) * 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 ) { 10c262: 85 f6 test %esi,%esi 10c264: 74 16 je 10c27c <_Thread_Initialize+0x110> for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10c266: 8b 15 94 43 12 00 mov 0x124394,%edx 10c26c: 31 c0 xor %eax,%eax 10c26e: eb 08 jmp 10c278 <_Thread_Initialize+0x10c> the_thread->extensions[i] = NULL; 10c270: c7 04 86 00 00 00 00 movl $0x0,(%esi,%eax,4) * 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++ ) 10c277: 40 inc %eax 10c278: 39 d0 cmp %edx,%eax 10c27a: 76 f4 jbe 10c270 <_Thread_Initialize+0x104> /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c27c: 8a 45 e3 mov -0x1d(%ebp),%al 10c27f: 88 83 a0 00 00 00 mov %al,0xa0(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10c285: 8b 45 24 mov 0x24(%ebp),%eax 10c288: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.budget_callout = budget_callout; 10c28e: 8b 45 28 mov 0x28(%ebp),%eax 10c291: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) switch ( budget_algorithm ) { 10c297: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10c29b: 75 08 jne 10c2a5 <_Thread_Initialize+0x139> case THREAD_CPU_BUDGET_ALGORITHM_NONE: case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: break; #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c29d: a1 b0 42 12 00 mov 0x1242b0,%eax 10c2a2: 89 43 78 mov %eax,0x78(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10c2a5: 8b 45 2c mov 0x2c(%ebp),%eax 10c2a8: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) the_thread->current_state = STATES_DORMANT; 10c2ae: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10c2b5: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10c2bc: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10c2c3: 8b 45 1c mov 0x1c(%ebp),%eax 10c2c6: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10c2c9: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) RTEMS_INLINE_ROUTINE void* _Scheduler_Thread_scheduler_allocate( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { return 10c2cf: 52 push %edx 10c2d0: 52 push %edx 10c2d1: 53 push %ebx 10c2d2: 68 68 43 12 00 push $0x124368 10c2d7: ff 15 7c 43 12 00 call *0x12437c 10c2dd: 89 45 e4 mov %eax,-0x1c(%ebp) sched =_Scheduler_Thread_scheduler_allocate( &_Scheduler, the_thread ); if ( !sched ) 10c2e0: 83 c4 10 add $0x10,%esp 10c2e3: 85 c0 test %eax,%eax 10c2e5: 74 53 je 10c33a <_Thread_Initialize+0x1ce> goto failed; _Thread_Set_priority( the_thread, priority ); 10c2e7: 50 push %eax 10c2e8: 50 push %eax 10c2e9: ff 75 1c pushl 0x1c(%ebp) 10c2ec: 53 push %ebx 10c2ed: e8 7a 05 00 00 call 10c86c <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10c2f2: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10c2f9: 00 00 00 10c2fc: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10c303: 00 00 00 _Thread_Stack_Free( the_thread ); return false; } 10c306: 8b 45 08 mov 0x8(%ebp),%eax 10c309: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c30c: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c310: 89 1c 90 mov %ebx,(%eax,%edx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c313: 8b 45 30 mov 0x30(%ebp),%eax 10c316: 89 43 0c mov %eax,0xc(%ebx) * 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 ); 10c319: 89 1c 24 mov %ebx,(%esp) 10c31c: e8 7b 09 00 00 call 10cc9c <_User_extensions_Thread_create> 10c321: 88 c2 mov %al,%dl if ( extension_status ) 10c323: 83 c4 10 add $0x10,%esp return true; 10c326: b0 01 mov $0x1,%al * 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 ); if ( extension_status ) 10c328: 84 d2 test %dl,%dl 10c32a: 74 0e je 10c33a <_Thread_Initialize+0x1ce> 10c32c: e9 8d 00 00 00 jmp 10c3be <_Thread_Initialize+0x252> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c331: 31 f6 xor %esi,%esi size_t actual_stack_size = 0; void *stack = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) void *fp_area; #endif void *sched = NULL; 10c333: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; failed: if ( the_thread->libc_reent ) 10c33a: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax 10c340: 85 c0 test %eax,%eax 10c342: 74 0c je 10c350 <_Thread_Initialize+0x1e4> _Workspace_Free( the_thread->libc_reent ); 10c344: 83 ec 0c sub $0xc,%esp 10c347: 50 push %eax 10c348: e8 7e 0c 00 00 call 10cfcb <_Workspace_Free> 10c34d: 83 c4 10 add $0x10,%esp for ( i=0 ; i <= THREAD_API_LAST ; i++ ) if ( the_thread->API_Extensions[i] ) 10c350: 8b 83 e8 00 00 00 mov 0xe8(%ebx),%eax 10c356: 85 c0 test %eax,%eax 10c358: 74 0c je 10c366 <_Thread_Initialize+0x1fa> _Workspace_Free( the_thread->API_Extensions[i] ); 10c35a: 83 ec 0c sub $0xc,%esp 10c35d: 50 push %eax 10c35e: e8 68 0c 00 00 call 10cfcb <_Workspace_Free> 10c363: 83 c4 10 add $0x10,%esp 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] ) 10c366: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 10c36c: 85 c0 test %eax,%eax 10c36e: 74 0c je 10c37c <_Thread_Initialize+0x210> _Workspace_Free( the_thread->API_Extensions[i] ); 10c370: 83 ec 0c sub $0xc,%esp 10c373: 50 push %eax 10c374: e8 52 0c 00 00 call 10cfcb <_Workspace_Free> 10c379: 83 c4 10 add $0x10,%esp if ( extensions_area ) 10c37c: 85 f6 test %esi,%esi 10c37e: 74 0c je 10c38c <_Thread_Initialize+0x220> (void) _Workspace_Free( extensions_area ); 10c380: 83 ec 0c sub $0xc,%esp 10c383: 56 push %esi 10c384: e8 42 0c 00 00 call 10cfcb <_Workspace_Free> 10c389: 83 c4 10 add $0x10,%esp #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10c38c: 85 ff test %edi,%edi 10c38e: 74 0c je 10c39c <_Thread_Initialize+0x230> (void) _Workspace_Free( fp_area ); 10c390: 83 ec 0c sub $0xc,%esp 10c393: 57 push %edi 10c394: e8 32 0c 00 00 call 10cfcb <_Workspace_Free> 10c399: 83 c4 10 add $0x10,%esp #endif if ( sched ) 10c39c: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10c3a0: 74 0e je 10c3b0 <_Thread_Initialize+0x244> (void) _Workspace_Free( sched ); 10c3a2: 83 ec 0c sub $0xc,%esp 10c3a5: ff 75 e4 pushl -0x1c(%ebp) 10c3a8: e8 1e 0c 00 00 call 10cfcb <_Workspace_Free> 10c3ad: 83 c4 10 add $0x10,%esp _Thread_Stack_Free( the_thread ); 10c3b0: 83 ec 0c sub $0xc,%esp 10c3b3: 53 push %ebx 10c3b4: e8 d3 05 00 00 call 10c98c <_Thread_Stack_Free> return false; 10c3b9: 83 c4 10 add $0x10,%esp stack = the_thread->Start.stack; #else if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ 10c3bc: 31 c0 xor %eax,%eax _Thread_Stack_Free( the_thread ); return false; } 10c3be: 8d 65 f4 lea -0xc(%ebp),%esp 10c3c1: 5b pop %ebx 10c3c2: 5e pop %esi 10c3c3: 5f pop %edi 10c3c4: c9 leave 10c3c5: c3 ret =============================================================================== 0010f5fc <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10f5fc: 55 push %ebp 10f5fd: 89 e5 mov %esp,%ebp 10f5ff: 53 push %ebx 10f600: 83 ec 04 sub $0x4,%esp 10f603: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10f606: 9c pushf 10f607: fa cli 10f608: 5b pop %ebx current_state = the_thread->current_state; 10f609: 8b 50 10 mov 0x10(%eax),%edx if ( current_state & STATES_SUSPENDED ) { 10f60c: f6 c2 02 test $0x2,%dl 10f60f: 74 1b je 10f62c <_Thread_Resume+0x30> <== NEVER TAKEN 10f611: 83 e2 fd and $0xfffffffd,%edx current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); 10f614: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 10f617: 85 d2 test %edx,%edx 10f619: 75 11 jne 10f62c <_Thread_Resume+0x30> RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { the_scheduler->Operations.unblock( the_scheduler, the_thread ); 10f61b: 52 push %edx 10f61c: 52 push %edx 10f61d: 50 push %eax 10f61e: 68 30 74 12 00 push $0x127430 10f623: ff 15 40 74 12 00 call *0x127440 10f629: 83 c4 10 add $0x10,%esp _Scheduler_Unblock( &_Scheduler, the_thread ); } } _ISR_Enable( level ); 10f62c: 53 push %ebx 10f62d: 9d popf } 10f62e: 8b 5d fc mov -0x4(%ebp),%ebx 10f631: c9 leave 10f632: c3 ret =============================================================================== 0010ca74 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10ca74: 55 push %ebp 10ca75: 89 e5 mov %esp,%ebp 10ca77: 53 push %ebx 10ca78: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10ca7b: 8b 1d 2c 48 12 00 mov 0x12482c,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10ca81: 80 7b 74 00 cmpb $0x0,0x74(%ebx) 10ca85: 74 55 je 10cadc <_Thread_Tickle_timeslice+0x68> return; if ( !_States_Is_ready( executing->current_state ) ) 10ca87: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10ca8b: 75 4f jne 10cadc <_Thread_Tickle_timeslice+0x68> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10ca8d: 8b 43 7c mov 0x7c(%ebx),%eax 10ca90: 83 f8 01 cmp $0x1,%eax 10ca93: 72 47 jb 10cadc <_Thread_Tickle_timeslice+0x68> 10ca95: 83 f8 02 cmp $0x2,%eax 10ca98: 76 07 jbe 10caa1 <_Thread_Tickle_timeslice+0x2d> 10ca9a: 83 f8 03 cmp $0x3,%eax 10ca9d: 75 3d jne 10cadc <_Thread_Tickle_timeslice+0x68><== NEVER TAKEN 10ca9f: eb 23 jmp 10cac4 <_Thread_Tickle_timeslice+0x50> case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: #endif if ( (int)(--executing->cpu_time_budget) <= 0 ) { 10caa1: 8b 43 78 mov 0x78(%ebx),%eax 10caa4: 48 dec %eax 10caa5: 89 43 78 mov %eax,0x78(%ebx) 10caa8: 85 c0 test %eax,%eax 10caaa: 7f 30 jg 10cadc <_Thread_Tickle_timeslice+0x68> * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield( &_Scheduler ); 10caac: 83 ec 0c sub $0xc,%esp 10caaf: 68 68 43 12 00 push $0x124368 10cab4: ff 15 70 43 12 00 call *0x124370 * executing thread's timeslice is reset. Otherwise, the * currently executing thread is placed at the rear of the * FIFO for this priority and a new heir is selected. */ _Scheduler_Yield( ); executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10caba: a1 b0 42 12 00 mov 0x1242b0,%eax 10cabf: 89 43 78 mov %eax,0x78(%ebx) 10cac2: eb 15 jmp 10cad9 <_Thread_Tickle_timeslice+0x65> } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10cac4: 8b 43 78 mov 0x78(%ebx),%eax 10cac7: 48 dec %eax 10cac8: 89 43 78 mov %eax,0x78(%ebx) 10cacb: 85 c0 test %eax,%eax 10cacd: 75 0d jne 10cadc <_Thread_Tickle_timeslice+0x68> (*executing->budget_callout)( executing ); 10cacf: 83 ec 0c sub $0xc,%esp 10cad2: 53 push %ebx 10cad3: ff 93 80 00 00 00 call *0x80(%ebx) 10cad9: 83 c4 10 add $0x10,%esp break; #endif } } 10cadc: 8b 5d fc mov -0x4(%ebp),%ebx 10cadf: c9 leave 10cae0: c3 ret =============================================================================== 0010c7e4 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10c7e4: 55 push %ebp 10c7e5: 89 e5 mov %esp,%ebp 10c7e7: 57 push %edi 10c7e8: 56 push %esi 10c7e9: 53 push %ebx 10c7ea: 83 ec 1c sub $0x1c,%esp 10c7ed: 8b 75 08 mov 0x8(%ebp),%esi 10c7f0: 8b 7d 0c mov 0xc(%ebp),%edi /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10c7f3: 85 f6 test %esi,%esi 10c7f5: 74 36 je 10c82d <_Thread_queue_Requeue+0x49><== NEVER TAKEN /* * If queueing by FIFO, there is nothing to do. This only applies to * priority blocking discipline. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10c7f7: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10c7fb: 75 30 jne 10c82d <_Thread_queue_Requeue+0x49><== NEVER TAKEN Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10c7fd: 9c pushf 10c7fe: fa cli 10c7ff: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10c800: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10c807: 74 22 je 10c82b <_Thread_queue_Requeue+0x47><== NEVER TAKEN RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c809: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); 10c810: 50 push %eax 10c811: 6a 01 push $0x1 10c813: 57 push %edi 10c814: 56 push %esi 10c815: e8 0e 32 00 00 call 10fa28 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10c81a: 83 c4 0c add $0xc,%esp 10c81d: 8d 45 e4 lea -0x1c(%ebp),%eax 10c820: 50 push %eax 10c821: 57 push %edi 10c822: 56 push %esi 10c823: e8 c0 fd ff ff call 10c5e8 <_Thread_queue_Enqueue_priority> 10c828: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10c82b: 53 push %ebx 10c82c: 9d popf } } 10c82d: 8d 65 f4 lea -0xc(%ebp),%esp 10c830: 5b pop %ebx 10c831: 5e pop %esi 10c832: 5f pop %edi 10c833: c9 leave 10c834: c3 ret =============================================================================== 0010c838 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c838: 55 push %ebp 10c839: 89 e5 mov %esp,%ebp 10c83b: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c83e: 8d 45 f4 lea -0xc(%ebp),%eax 10c841: 50 push %eax 10c842: ff 75 08 pushl 0x8(%ebp) 10c845: e8 b2 f8 ff ff call 10c0fc <_Thread_Get> switch ( location ) { 10c84a: 83 c4 10 add $0x10,%esp 10c84d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c851: 75 17 jne 10c86a <_Thread_queue_Timeout+0x32><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10c853: 83 ec 0c sub $0xc,%esp 10c856: 50 push %eax 10c857: e8 84 32 00 00 call 10fae0 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10c85c: a1 e0 42 12 00 mov 0x1242e0,%eax 10c861: 48 dec %eax 10c862: a3 e0 42 12 00 mov %eax,0x1242e0 10c867: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10c86a: c9 leave 10c86b: c3 ret =============================================================================== 00116974 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 116974: 55 push %ebp 116975: 89 e5 mov %esp,%ebp 116977: 57 push %edi 116978: 56 push %esi 116979: 53 push %ebx 11697a: 83 ec 4c sub $0x4c,%esp 11697d: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116980: 8d 55 dc lea -0x24(%ebp),%edx 116983: 8d 45 e0 lea -0x20(%ebp),%eax 116986: 89 45 dc mov %eax,-0x24(%ebp) head->previous = NULL; 116989: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 116990: 89 55 e4 mov %edx,-0x1c(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116993: 8d 7d d0 lea -0x30(%ebp),%edi 116996: 8d 4d d4 lea -0x2c(%ebp),%ecx 116999: 89 4d d0 mov %ecx,-0x30(%ebp) head->previous = NULL; 11699c: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 1169a3: 89 7d d8 mov %edi,-0x28(%ebp) */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169a6: 8d 53 30 lea 0x30(%ebx),%edx 1169a9: 89 55 c0 mov %edx,-0x40(%ebp) /* * 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 ); 1169ac: 8d 73 68 lea 0x68(%ebx),%esi */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail( const Chain_Control *the_chain ) { return &the_chain->Tail.Node; 1169af: 89 45 b4 mov %eax,-0x4c(%ebp) Chain_Control *tmp; /* * 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; 1169b2: 8d 4d dc lea -0x24(%ebp),%ecx 1169b5: 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; 1169b8: a1 08 d8 13 00 mov 0x13d808,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 1169bd: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 1169c0: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169c3: 51 push %ecx 1169c4: 57 push %edi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 1169c5: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169c7: 50 push %eax 1169c8: ff 75 c0 pushl -0x40(%ebp) 1169cb: e8 98 39 00 00 call 11a368 <_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(); 1169d0: a1 80 d7 13 00 mov 0x13d780,%eax 1169d5: 89 45 c4 mov %eax,-0x3c(%ebp) Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 1169d8: 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 ) { 1169db: 83 c4 10 add $0x10,%esp 1169de: 39 45 c4 cmp %eax,-0x3c(%ebp) 1169e1: 76 10 jbe 1169f3 <_Timer_server_Body+0x7f> /* * 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 ); 1169e3: 52 push %edx 1169e4: 57 push %edi if ( snapshot > last_snapshot ) { /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; 1169e5: 8b 55 c4 mov -0x3c(%ebp),%edx 1169e8: 29 c2 sub %eax,%edx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169ea: 52 push %edx 1169eb: 56 push %esi 1169ec: e8 77 39 00 00 call 11a368 <_Watchdog_Adjust_to_chain> 1169f1: eb 0f jmp 116a02 <_Timer_server_Body+0x8e> } else if ( snapshot < last_snapshot ) { 1169f3: 73 10 jae 116a05 <_Timer_server_Body+0x91> /* * 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 ); 1169f5: 51 push %ecx } else if ( snapshot < last_snapshot ) { /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; 1169f6: 2b 45 c4 sub -0x3c(%ebp),%eax _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 1169f9: 50 push %eax 1169fa: 6a 01 push $0x1 1169fc: 56 push %esi 1169fd: e8 fa 38 00 00 call 11a2fc <_Watchdog_Adjust> 116a02: 83 c4 10 add $0x10,%esp } watchdogs->last_snapshot = snapshot; 116a05: 8b 4d c4 mov -0x3c(%ebp),%ecx 116a08: 89 4b 74 mov %ecx,0x74(%ebx) } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 116a0b: 8b 43 78 mov 0x78(%ebx),%eax 116a0e: 83 ec 0c sub $0xc,%esp 116a11: 50 push %eax 116a12: e8 f5 08 00 00 call 11730c <_Chain_Get> if ( timer == NULL ) { 116a17: 83 c4 10 add $0x10,%esp 116a1a: 85 c0 test %eax,%eax 116a1c: 74 29 je 116a47 <_Timer_server_Body+0xd3><== ALWAYS TAKEN static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116a1e: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 116a21: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 116a24: 75 0b jne 116a31 <_Timer_server_Body+0xbd><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116a26: 52 push %edx <== NOT EXECUTED 116a27: 52 push %edx <== NOT EXECUTED 116a28: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 116a2b: 50 push %eax <== NOT EXECUTED 116a2c: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 116a2f: eb 0c jmp 116a3d <_Timer_server_Body+0xc9><== NOT EXECUTED } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116a31: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 116a34: 75 d5 jne 116a0b <_Timer_server_Body+0x97><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116a36: 51 push %ecx <== NOT EXECUTED 116a37: 51 push %ecx <== NOT EXECUTED 116a38: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 116a3b: 50 push %eax <== NOT EXECUTED 116a3c: 56 push %esi <== NOT EXECUTED 116a3d: e8 ae 39 00 00 call 11a3f0 <_Watchdog_Insert> <== NOT EXECUTED 116a42: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116a45: eb c4 jmp 116a0b <_Timer_server_Body+0x97><== 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 ); 116a47: 9c pushf 116a48: fa cli 116a49: 5a pop %edx tmp = ts->insert_chain; 116a4a: 8b 43 78 mov 0x78(%ebx),%eax if ( _Chain_Is_empty( insert_chain ) ) { 116a4d: b0 01 mov $0x1,%al 116a4f: 8b 4d b4 mov -0x4c(%ebp),%ecx 116a52: 39 4d dc cmp %ecx,-0x24(%ebp) 116a55: 75 09 jne 116a60 <_Timer_server_Body+0xec><== NEVER TAKEN ts->insert_chain = NULL; 116a57: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) do_loop = false; 116a5e: 31 c0 xor %eax,%eax } _ISR_Enable( level ); 116a60: 52 push %edx 116a61: 9d popf * 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; while ( do_loop ) { 116a62: 84 c0 test %al,%al 116a64: 0f 85 4e ff ff ff jne 1169b8 <_Timer_server_Body+0x44><== NEVER TAKEN 116a6a: 8d 45 d4 lea -0x2c(%ebp),%eax _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 ) ) { 116a6d: 39 45 d0 cmp %eax,-0x30(%ebp) 116a70: 74 3a je 116aac <_Timer_server_Body+0x138> 116a72: 89 45 b0 mov %eax,-0x50(%ebp) /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 116a75: 9c pushf 116a76: fa cli 116a77: 59 pop %ecx initialized = false; } #endif return status; } 116a78: 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)) 116a7b: 3b 45 b0 cmp -0x50(%ebp),%eax 116a7e: 74 25 je 116aa5 <_Timer_server_Body+0x131> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 116a80: 8b 10 mov (%eax),%edx head->next = new_first; 116a82: 89 55 d0 mov %edx,-0x30(%ebp) new_first->previous = head; 116a85: 89 7a 04 mov %edi,0x4(%edx) * 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 ) { 116a88: 85 c0 test %eax,%eax 116a8a: 74 19 je 116aa5 <_Timer_server_Body+0x131><== NEVER TAKEN watchdog->state = WATCHDOG_INACTIVE; 116a8c: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 116a93: 51 push %ecx 116a94: 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 ); 116a95: 52 push %edx 116a96: 52 push %edx 116a97: ff 70 24 pushl 0x24(%eax) 116a9a: ff 70 20 pushl 0x20(%eax) 116a9d: ff 50 1c call *0x1c(%eax) } 116aa0: 83 c4 10 add $0x10,%esp 116aa3: eb d0 jmp 116a75 <_Timer_server_Body+0x101> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 116aa5: 51 push %ecx 116aa6: 9d popf 116aa7: e9 06 ff ff ff jmp 1169b2 <_Timer_server_Body+0x3e> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 116aac: c6 43 7c 00 movb $0x0,0x7c(%ebx) /* * Block until there is something to do. */ _Thread_Disable_dispatch(); 116ab0: e8 23 fe ff ff call 1168d8 <_Thread_Disable_dispatch> _Thread_Set_state( ts->thread, STATES_DELAYING ); 116ab5: 51 push %ecx 116ab6: 51 push %ecx 116ab7: 6a 08 push $0x8 116ab9: ff 33 pushl (%ebx) 116abb: e8 8c 32 00 00 call 119d4c <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 116ac0: 89 d8 mov %ebx,%eax 116ac2: e8 21 fe ff ff call 1168e8 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 116ac7: 89 d8 mov %ebx,%eax 116ac9: e8 60 fe ff ff call 11692e <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 116ace: e8 07 2a 00 00 call 1194da <_Thread_Enable_dispatch> ts->active = true; 116ad3: 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 ); 116ad7: 8d 43 08 lea 0x8(%ebx),%eax 116ada: 89 04 24 mov %eax,(%esp) 116add: e8 26 3a 00 00 call 11a508 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 116ae2: 8d 43 40 lea 0x40(%ebx),%eax 116ae5: 89 04 24 mov %eax,(%esp) 116ae8: e8 1b 3a 00 00 call 11a508 <_Watchdog_Remove> 116aed: 83 c4 10 add $0x10,%esp 116af0: e9 bd fe ff ff jmp 1169b2 <_Timer_server_Body+0x3e> =============================================================================== 00116af5 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 116af5: 55 push %ebp 116af6: 89 e5 mov %esp,%ebp 116af8: 57 push %edi 116af9: 56 push %esi 116afa: 53 push %ebx 116afb: 83 ec 2c sub $0x2c,%esp 116afe: 8b 5d 08 mov 0x8(%ebp),%ebx 116b01: 8b 75 0c mov 0xc(%ebp),%esi if ( ts->insert_chain == NULL ) { 116b04: 8b 43 78 mov 0x78(%ebx),%eax 116b07: 85 c0 test %eax,%eax 116b09: 0f 85 de 00 00 00 jne 116bed <_Timer_server_Schedule_operation_method+0xf8><== NEVER TAKEN * is the reference point for the delta chain. Thus if we do not update the * reference point we have to add DT to the initial delta of the watchdog * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); 116b0f: e8 c4 fd ff ff call 1168d8 <_Thread_Disable_dispatch> if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116b14: 8b 46 38 mov 0x38(%esi),%eax 116b17: 83 f8 01 cmp $0x1,%eax 116b1a: 75 5a jne 116b76 <_Timer_server_Schedule_operation_method+0x81> /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 116b1c: 9c pushf 116b1d: fa cli 116b1e: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116b21: 8b 15 08 d8 13 00 mov 0x13d808,%edx last_snapshot = ts->Interval_watchdogs.last_snapshot; 116b27: 8b 4b 3c mov 0x3c(%ebx),%ecx initialized = false; } #endif return status; } 116b2a: 8b 43 30 mov 0x30(%ebx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 116b2d: 8d 7b 34 lea 0x34(%ebx),%edi * the watchdog chain accordingly. */ _ISR_Disable( level ); snapshot = _Watchdog_Ticks_since_boot; last_snapshot = ts->Interval_watchdogs.last_snapshot; if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 116b30: 39 f8 cmp %edi,%eax 116b32: 74 19 je 116b4d <_Timer_server_Schedule_operation_method+0x58> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116b34: 89 d7 mov %edx,%edi 116b36: 29 cf sub %ecx,%edi 116b38: 89 7d e4 mov %edi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 116b3b: 8b 78 10 mov 0x10(%eax),%edi if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116b3e: 31 c9 xor %ecx,%ecx * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { 116b40: 3b 7d e4 cmp -0x1c(%ebp),%edi 116b43: 76 05 jbe 116b4a <_Timer_server_Schedule_operation_method+0x55> delta_interval -= delta; 116b45: 89 f9 mov %edi,%ecx 116b47: 2b 4d e4 sub -0x1c(%ebp),%ecx } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 116b4a: 89 48 10 mov %ecx,0x10(%eax) } ts->Interval_watchdogs.last_snapshot = snapshot; 116b4d: 89 53 3c mov %edx,0x3c(%ebx) _ISR_Enable( level ); 116b50: ff 75 e0 pushl -0x20(%ebp) 116b53: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116b54: 50 push %eax 116b55: 50 push %eax 116b56: 83 c6 10 add $0x10,%esi 116b59: 56 push %esi 116b5a: 8d 43 30 lea 0x30(%ebx),%eax 116b5d: 50 push %eax 116b5e: e8 8d 38 00 00 call 11a3f0 <_Watchdog_Insert> if ( !ts->active ) { 116b63: 8a 43 7c mov 0x7c(%ebx),%al 116b66: 83 c4 10 add $0x10,%esp 116b69: 84 c0 test %al,%al 116b6b: 75 74 jne 116be1 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_interval_system_watchdog( ts ); 116b6d: 89 d8 mov %ebx,%eax 116b6f: e8 74 fd ff ff call 1168e8 <_Timer_server_Reset_interval_system_watchdog> 116b74: eb 6b jmp 116be1 <_Timer_server_Schedule_operation_method+0xec> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116b76: 83 f8 03 cmp $0x3,%eax 116b79: 75 66 jne 116be1 <_Timer_server_Schedule_operation_method+0xec> /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 116b7b: 9c pushf 116b7c: fa cli 116b7d: 8f 45 e0 popl -0x20(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 116b80: 8b 15 80 d7 13 00 mov 0x13d780,%edx last_snapshot = ts->TOD_watchdogs.last_snapshot; 116b86: 8b 43 74 mov 0x74(%ebx),%eax initialized = false; } #endif return status; } 116b89: 8b 4b 68 mov 0x68(%ebx),%ecx 116b8c: 8d 7b 6c lea 0x6c(%ebx),%edi * the watchdog chain accordingly. */ _ISR_Disable( level ); snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); last_snapshot = ts->TOD_watchdogs.last_snapshot; if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 116b8f: 39 f9 cmp %edi,%ecx 116b91: 74 27 je 116bba <_Timer_server_Schedule_operation_method+0xc5> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 116b93: 8b 79 10 mov 0x10(%ecx),%edi 116b96: 89 7d d4 mov %edi,-0x2c(%ebp) if ( snapshot > last_snapshot ) { 116b99: 39 c2 cmp %eax,%edx 116b9b: 76 15 jbe 116bb2 <_Timer_server_Schedule_operation_method+0xbd> /* * We advanced in time. */ delta = snapshot - last_snapshot; 116b9d: 89 d7 mov %edx,%edi 116b9f: 29 c7 sub %eax,%edi 116ba1: 89 7d e4 mov %edi,-0x1c(%ebp) if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116ba4: 31 c0 xor %eax,%eax if ( snapshot > last_snapshot ) { /* * We advanced in time. */ delta = snapshot - last_snapshot; if (delta_interval > delta) { 116ba6: 39 7d d4 cmp %edi,-0x2c(%ebp) 116ba9: 76 0c jbe 116bb7 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN delta_interval -= delta; 116bab: 8b 45 d4 mov -0x2c(%ebp),%eax 116bae: 29 f8 sub %edi,%eax 116bb0: eb 05 jmp 116bb7 <_Timer_server_Schedule_operation_method+0xc2> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 116bb2: 03 45 d4 add -0x2c(%ebp),%eax delta_interval += delta; 116bb5: 29 d0 sub %edx,%eax } first_watchdog->delta_interval = delta_interval; 116bb7: 89 41 10 mov %eax,0x10(%ecx) } ts->TOD_watchdogs.last_snapshot = snapshot; 116bba: 89 53 74 mov %edx,0x74(%ebx) _ISR_Enable( level ); 116bbd: ff 75 e0 pushl -0x20(%ebp) 116bc0: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116bc1: 57 push %edi 116bc2: 57 push %edi 116bc3: 83 c6 10 add $0x10,%esi 116bc6: 56 push %esi 116bc7: 8d 43 68 lea 0x68(%ebx),%eax 116bca: 50 push %eax 116bcb: e8 20 38 00 00 call 11a3f0 <_Watchdog_Insert> if ( !ts->active ) { 116bd0: 8a 43 7c mov 0x7c(%ebx),%al 116bd3: 83 c4 10 add $0x10,%esp 116bd6: 84 c0 test %al,%al 116bd8: 75 07 jne 116be1 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_tod_system_watchdog( ts ); 116bda: 89 d8 mov %ebx,%eax 116bdc: e8 4d fd ff ff call 11692e <_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 ); } } 116be1: 8d 65 f4 lea -0xc(%ebp),%esp 116be4: 5b pop %ebx 116be5: 5e pop %esi 116be6: 5f pop %edi 116be7: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 116be8: e9 ed 28 00 00 jmp 1194da <_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 ); 116bed: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 116bf0: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 116bf3: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } 116bf6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116bf9: 5b pop %ebx <== NOT EXECUTED 116bfa: 5e pop %esi <== NOT EXECUTED 116bfb: 5f pop %edi <== NOT EXECUTED 116bfc: 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 ); 116bfd: e9 ce 06 00 00 jmp 1172d0 <_Chain_Append> <== NOT EXECUTED =============================================================================== 0010cc5f <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10cc5f: 55 push %ebp 10cc60: 89 e5 mov %esp,%ebp 10cc62: 57 push %edi 10cc63: 56 push %esi 10cc64: 53 push %ebx 10cc65: 83 ec 0c sub $0xc,%esp 10cc68: 8b 7d 10 mov 0x10(%ebp),%edi the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10cc6b: 8b 1d d8 44 12 00 mov 0x1244d8,%ebx the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10cc71: 0f b6 75 0c movzbl 0xc(%ebp),%esi ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10cc75: eb 15 jmp 10cc8c <_User_extensions_Fatal+0x2d> !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 10cc77: 8b 43 30 mov 0x30(%ebx),%eax 10cc7a: 85 c0 test %eax,%eax 10cc7c: 74 0b je 10cc89 <_User_extensions_Fatal+0x2a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10cc7e: 52 push %edx 10cc7f: 57 push %edi 10cc80: 56 push %esi 10cc81: ff 75 08 pushl 0x8(%ebp) 10cc84: ff d0 call *%eax 10cc86: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10cc89: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10cc8c: 81 fb d0 44 12 00 cmp $0x1244d0,%ebx 10cc92: 75 e3 jne 10cc77 <_User_extensions_Fatal+0x18><== ALWAYS TAKEN the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10cc94: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cc97: 5b pop %ebx <== NOT EXECUTED 10cc98: 5e pop %esi <== NOT EXECUTED 10cc99: 5f pop %edi <== NOT EXECUTED 10cc9a: c9 leave <== NOT EXECUTED 10cc9b: c3 ret <== NOT EXECUTED =============================================================================== 0010cb48 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10cb48: 55 push %ebp 10cb49: 89 e5 mov %esp,%ebp 10cb4b: 57 push %edi 10cb4c: 56 push %esi 10cb4d: 53 push %ebx 10cb4e: 83 ec 1c sub $0x1c,%esp User_extensions_Control *extension; uint32_t i; uint32_t number_of_extensions; User_extensions_Table *initial_extensions; number_of_extensions = Configuration.number_of_initial_extensions; 10cb51: a1 34 02 12 00 mov 0x120234,%eax 10cb56: 89 45 e4 mov %eax,-0x1c(%ebp) initial_extensions = Configuration.User_extension_table; 10cb59: 8b 35 38 02 12 00 mov 0x120238,%esi ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10cb5f: c7 05 d0 44 12 00 d4 movl $0x1244d4,0x1244d0 10cb66: 44 12 00 head->previous = NULL; 10cb69: c7 05 d4 44 12 00 00 movl $0x0,0x1244d4 10cb70: 00 00 00 tail->previous = head; 10cb73: c7 05 d8 44 12 00 d0 movl $0x1244d0,0x1244d8 10cb7a: 44 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10cb7d: c7 05 e4 42 12 00 e8 movl $0x1242e8,0x1242e4 10cb84: 42 12 00 head->previous = NULL; 10cb87: c7 05 e8 42 12 00 00 movl $0x0,0x1242e8 10cb8e: 00 00 00 tail->previous = head; 10cb91: c7 05 ec 42 12 00 e4 movl $0x1242e4,0x1242ec 10cb98: 42 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10cb9b: 85 f6 test %esi,%esi 10cb9d: 74 53 je 10cbf2 <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10cb9f: 6b c8 34 imul $0x34,%eax,%ecx 10cba2: 83 ec 0c sub $0xc,%esp 10cba5: 51 push %ecx 10cba6: 89 4d e0 mov %ecx,-0x20(%ebp) 10cba9: e8 32 04 00 00 call 10cfe0 <_Workspace_Allocate_or_fatal_error> 10cbae: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10cbb0: 31 c0 xor %eax,%eax 10cbb2: 8b 4d e0 mov -0x20(%ebp),%ecx 10cbb5: 89 df mov %ebx,%edi 10cbb7: f3 aa rep stos %al,%es:(%edi) 10cbb9: 89 f0 mov %esi,%eax extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cbbb: 83 c4 10 add $0x10,%esp 10cbbe: 31 d2 xor %edx,%edx 10cbc0: eb 2b jmp 10cbed <_User_extensions_Handler_initialization+0xa5> RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table( User_extensions_Control *extension, const User_extensions_Table *extension_table ) { extension->Callouts = *extension_table; 10cbc2: 8d 7b 14 lea 0x14(%ebx),%edi 10cbc5: 89 c6 mov %eax,%esi 10cbc7: b9 08 00 00 00 mov $0x8,%ecx 10cbcc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10cbce: 83 ec 0c sub $0xc,%esp 10cbd1: 53 push %ebx 10cbd2: 89 45 dc mov %eax,-0x24(%ebp) 10cbd5: 89 55 e0 mov %edx,-0x20(%ebp) 10cbd8: e8 f3 2f 00 00 call 10fbd0 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10cbdd: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cbe0: 8b 55 e0 mov -0x20(%ebp),%edx 10cbe3: 42 inc %edx 10cbe4: 8b 45 dc mov -0x24(%ebp),%eax 10cbe7: 83 c0 20 add $0x20,%eax 10cbea: 83 c4 10 add $0x10,%esp 10cbed: 3b 55 e4 cmp -0x1c(%ebp),%edx 10cbf0: 72 d0 jb 10cbc2 <_User_extensions_Handler_initialization+0x7a> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10cbf2: 8d 65 f4 lea -0xc(%ebp),%esp 10cbf5: 5b pop %ebx 10cbf6: 5e pop %esi 10cbf7: 5f pop %edi 10cbf8: c9 leave 10cbf9: c3 ret =============================================================================== 0010e4ac <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10e4ac: 55 push %ebp 10e4ad: 89 e5 mov %esp,%ebp 10e4af: 57 push %edi 10e4b0: 56 push %esi 10e4b1: 53 push %ebx 10e4b2: 83 ec 1c sub $0x1c,%esp 10e4b5: 8b 75 08 mov 0x8(%ebp),%esi 10e4b8: 8b 7d 0c mov 0xc(%ebp),%edi 10e4bb: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10e4be: 9c pushf 10e4bf: fa cli 10e4c0: 58 pop %eax } } _ISR_Enable( level ); } 10e4c1: 8b 16 mov (%esi),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10e4c3: 8d 4e 04 lea 0x4(%esi),%ecx * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 10e4c6: 39 ca cmp %ecx,%edx 10e4c8: 74 44 je 10e50e <_Watchdog_Adjust+0x62> switch ( direction ) { 10e4ca: 85 ff test %edi,%edi 10e4cc: 74 3c je 10e50a <_Watchdog_Adjust+0x5e> 10e4ce: 4f dec %edi 10e4cf: 75 3d jne 10e50e <_Watchdog_Adjust+0x62> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10e4d1: 01 5a 10 add %ebx,0x10(%edx) break; 10e4d4: eb 38 jmp 10e50e <_Watchdog_Adjust+0x62> RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 10e4d6: 8b 16 mov (%esi),%edx case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10e4d8: 8b 7a 10 mov 0x10(%edx),%edi 10e4db: 39 fb cmp %edi,%ebx 10e4dd: 73 07 jae 10e4e6 <_Watchdog_Adjust+0x3a> _Watchdog_First( header )->delta_interval -= units; 10e4df: 29 df sub %ebx,%edi 10e4e1: 89 7a 10 mov %edi,0x10(%edx) break; 10e4e4: eb 28 jmp 10e50e <_Watchdog_Adjust+0x62> } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10e4e6: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 10e4ed: 50 push %eax 10e4ee: 9d popf _Watchdog_Tickle( header ); 10e4ef: 83 ec 0c sub $0xc,%esp 10e4f2: 56 push %esi 10e4f3: 89 4d e4 mov %ecx,-0x1c(%ebp) 10e4f6: e8 9d 01 00 00 call 10e698 <_Watchdog_Tickle> _ISR_Disable( level ); 10e4fb: 9c pushf 10e4fc: fa cli 10e4fd: 58 pop %eax if ( _Chain_Is_empty( header ) ) 10e4fe: 83 c4 10 add $0x10,%esp 10e501: 8b 4d e4 mov -0x1c(%ebp),%ecx 10e504: 39 0e cmp %ecx,(%esi) 10e506: 74 06 je 10e50e <_Watchdog_Adjust+0x62> while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; 10e508: 29 fb sub %edi,%ebx switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e50a: 85 db test %ebx,%ebx 10e50c: 75 c8 jne 10e4d6 <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN } break; } } _ISR_Enable( level ); 10e50e: 50 push %eax 10e50f: 9d popf } 10e510: 8d 65 f4 lea -0xc(%ebp),%esp 10e513: 5b pop %ebx 10e514: 5e pop %esi 10e515: 5f pop %edi 10e516: c9 leave 10e517: c3 ret =============================================================================== 0010ce98 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10ce98: 55 push %ebp 10ce99: 89 e5 mov %esp,%ebp 10ce9b: 56 push %esi 10ce9c: 53 push %ebx 10ce9d: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10cea0: 9c pushf 10cea1: fa cli 10cea2: 5e pop %esi previous_state = the_watchdog->state; 10cea3: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10cea6: 83 f8 01 cmp $0x1,%eax 10cea9: 74 09 je 10ceb4 <_Watchdog_Remove+0x1c> 10ceab: 72 42 jb 10ceef <_Watchdog_Remove+0x57> 10cead: 83 f8 03 cmp $0x3,%eax 10ceb0: 77 3d ja 10ceef <_Watchdog_Remove+0x57> <== NEVER TAKEN 10ceb2: eb 09 jmp 10cebd <_Watchdog_Remove+0x25> /* * It is not actually on the chain so just change the state and * the Insert operation we interrupted will be aborted. */ the_watchdog->state = WATCHDOG_INACTIVE; 10ceb4: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10cebb: eb 32 jmp 10ceef <_Watchdog_Remove+0x57> case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10cebd: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; _ISR_Enable( level ); return( previous_state ); } 10cec4: 8b 0a mov (%edx),%ecx case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10cec6: 83 39 00 cmpl $0x0,(%ecx) 10cec9: 74 06 je 10ced1 <_Watchdog_Remove+0x39> next_watchdog->delta_interval += the_watchdog->delta_interval; 10cecb: 8b 5a 10 mov 0x10(%edx),%ebx 10cece: 01 59 10 add %ebx,0x10(%ecx) if ( _Watchdog_Sync_count ) 10ced1: 8b 1d 10 44 12 00 mov 0x124410,%ebx 10ced7: 85 db test %ebx,%ebx 10ced9: 74 0c je 10cee7 <_Watchdog_Remove+0x4f> _Watchdog_Sync_level = _ISR_Nest_level; 10cedb: 8b 1d 28 48 12 00 mov 0x124828,%ebx 10cee1: 89 1d a8 43 12 00 mov %ebx,0x1243a8 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10cee7: 8b 5a 04 mov 0x4(%edx),%ebx next->previous = previous; 10ceea: 89 59 04 mov %ebx,0x4(%ecx) previous->next = next; 10ceed: 89 0b mov %ecx,(%ebx) _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10ceef: 8b 0d 14 44 12 00 mov 0x124414,%ecx 10cef5: 89 4a 18 mov %ecx,0x18(%edx) _ISR_Enable( level ); 10cef8: 56 push %esi 10cef9: 9d popf return( previous_state ); } 10cefa: 5b pop %ebx 10cefb: 5e pop %esi 10cefc: c9 leave 10cefd: c3 ret =============================================================================== 0010e03c <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10e03c: 55 push %ebp 10e03d: 89 e5 mov %esp,%ebp 10e03f: 57 push %edi 10e040: 56 push %esi 10e041: 53 push %ebx 10e042: 83 ec 20 sub $0x20,%esp 10e045: 8b 7d 08 mov 0x8(%ebp),%edi 10e048: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10e04b: 9c pushf 10e04c: fa cli 10e04d: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10e050: 56 push %esi 10e051: 57 push %edi 10e052: 68 c8 0f 12 00 push $0x120fc8 10e057: e8 8c aa ff ff call 108ae8 printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); } 10e05c: 8b 1e mov (%esi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10e05e: 83 c6 04 add $0x4,%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { 10e061: 83 c4 10 add $0x10,%esp 10e064: 39 f3 cmp %esi,%ebx 10e066: 74 1d je 10e085 <_Watchdog_Report_chain+0x49> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10e068: 52 push %edx 10e069: 52 push %edx 10e06a: 53 push %ebx 10e06b: 6a 00 push $0x0 10e06d: e8 32 00 00 00 call 10e0a4 <_Watchdog_Report> _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; node != _Chain_Tail(header) ; node = node->next ) 10e072: 8b 1b mov (%ebx),%ebx Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; 10e074: 83 c4 10 add $0x10,%esp 10e077: 39 f3 cmp %esi,%ebx 10e079: 75 ed jne 10e068 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10e07b: 50 push %eax 10e07c: 50 push %eax 10e07d: 57 push %edi 10e07e: 68 df 0f 12 00 push $0x120fdf 10e083: eb 08 jmp 10e08d <_Watchdog_Report_chain+0x51> } else { printk( "Chain is empty\n" ); 10e085: 83 ec 0c sub $0xc,%esp 10e088: 68 ee 0f 12 00 push $0x120fee 10e08d: e8 56 aa ff ff call 108ae8 10e092: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10e095: ff 75 e4 pushl -0x1c(%ebp) 10e098: 9d popf } 10e099: 8d 65 f4 lea -0xc(%ebp),%esp 10e09c: 5b pop %ebx 10e09d: 5e pop %esi 10e09e: 5f pop %edi 10e09f: c9 leave 10e0a0: c3 ret =============================================================================== 0010cf00 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10cf00: 55 push %ebp 10cf01: 89 e5 mov %esp,%ebp 10cf03: 57 push %edi 10cf04: 56 push %esi 10cf05: 53 push %ebx 10cf06: 83 ec 1c sub $0x1c,%esp 10cf09: 8b 7d 08 mov 0x8(%ebp),%edi * See the comment in watchdoginsert.c and watchdogadjust.c * about why it's safe not to declare header a pointer to * volatile data - till, 2003/7 */ _ISR_Disable( level ); 10cf0c: 9c pushf 10cf0d: fa cli 10cf0e: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10cf0f: 8b 1f mov (%edi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10cf11: 8d 47 04 lea 0x4(%edi),%eax 10cf14: 89 45 e4 mov %eax,-0x1c(%ebp) * volatile data - till, 2003/7 */ _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 10cf17: 39 c3 cmp %eax,%ebx 10cf19: 74 40 je 10cf5b <_Watchdog_Tickle+0x5b> * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 10cf1b: 8b 43 10 mov 0x10(%ebx),%eax 10cf1e: 85 c0 test %eax,%eax 10cf20: 74 08 je 10cf2a <_Watchdog_Tickle+0x2a> the_watchdog->delta_interval--; 10cf22: 48 dec %eax 10cf23: 89 43 10 mov %eax,0x10(%ebx) if ( the_watchdog->delta_interval != 0 ) 10cf26: 85 c0 test %eax,%eax 10cf28: 75 31 jne 10cf5b <_Watchdog_Tickle+0x5b> goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10cf2a: 83 ec 0c sub $0xc,%esp 10cf2d: 53 push %ebx 10cf2e: e8 65 ff ff ff call 10ce98 <_Watchdog_Remove> _ISR_Enable( level ); 10cf33: 56 push %esi 10cf34: 9d popf switch( watchdog_state ) { 10cf35: 83 c4 10 add $0x10,%esp 10cf38: 83 f8 02 cmp $0x2,%eax 10cf3b: 75 0e jne 10cf4b <_Watchdog_Tickle+0x4b> <== NEVER TAKEN case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10cf3d: 50 push %eax 10cf3e: 50 push %eax 10cf3f: ff 73 24 pushl 0x24(%ebx) 10cf42: ff 73 20 pushl 0x20(%ebx) 10cf45: ff 53 1c call *0x1c(%ebx) the_watchdog->id, the_watchdog->user_data ); break; 10cf48: 83 c4 10 add $0x10,%esp case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10cf4b: 9c pushf 10cf4c: fa cli 10cf4d: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10cf4e: 8b 1f mov (%edi),%ebx _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10cf50: 3b 5d e4 cmp -0x1c(%ebp),%ebx 10cf53: 74 06 je 10cf5b <_Watchdog_Tickle+0x5b> } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 10cf55: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10cf59: eb cd jmp 10cf28 <_Watchdog_Tickle+0x28> (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10cf5b: 56 push %esi 10cf5c: 9d popf } 10cf5d: 8d 65 f4 lea -0xc(%ebp),%esp 10cf60: 5b pop %ebx 10cf61: 5e pop %esi 10cf62: 5f pop %edi 10cf63: c9 leave 10cf64: c3 ret =============================================================================== 0010a7c0 : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 10a7c0: 55 push %ebp 10a7c1: 89 e5 mov %esp,%ebp 10a7c3: 57 push %edi 10a7c4: 56 push %esi 10a7c5: 53 push %ebx 10a7c6: 83 ec 18 sub $0x18,%esp 10a7c9: 8b 75 08 mov 0x8(%ebp),%esi 10a7cc: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 10a7cf: 68 78 72 12 00 push $0x127278 10a7d4: e8 0b 10 00 00 call 10b7e4 if (aiocbp == NULL) 10a7d9: 83 c4 10 add $0x10,%esp 10a7dc: 85 db test %ebx,%ebx 10a7de: 0f 85 05 01 00 00 jne 10a8e9 { if (fcntl (fildes, F_GETFL) < 0) { 10a7e4: 53 push %ebx 10a7e5: 53 push %ebx 10a7e6: 6a 03 push $0x3 10a7e8: 56 push %esi 10a7e9: e8 7e 60 00 00 call 11086c 10a7ee: 83 c4 10 add $0x10,%esp 10a7f1: 85 c0 test %eax,%eax 10a7f3: 79 1d jns 10a812 <== NEVER TAKEN pthread_mutex_unlock(&aio_request_queue.mutex); 10a7f5: 83 ec 0c sub $0xc,%esp 10a7f8: 68 78 72 12 00 push $0x127278 10a7fd: e8 62 10 00 00 call 10b864 rtems_set_errno_and_return_minus_one (EBADF); 10a802: e8 c9 8e 00 00 call 1136d0 <__errno> 10a807: c7 00 09 00 00 00 movl $0x9,(%eax) 10a80d: e9 f5 00 00 00 jmp 10a907 } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10a812: 51 push %ecx <== NOT EXECUTED 10a813: 6a 00 push $0x0 <== NOT EXECUTED 10a815: 56 push %esi <== NOT EXECUTED 10a816: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10a81b: e8 20 03 00 00 call 10ab40 <== NOT EXECUTED 10a820: 89 c3 mov %eax,%ebx <== NOT EXECUTED fildes, 0); if (r_chain == NULL) 10a822: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a825: 85 c0 test %eax,%eax <== NOT EXECUTED 10a827: 0f 85 82 00 00 00 jne 10a8af <== NOT EXECUTED { if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) 10a82d: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED 10a834: 72 12 00 10a837: 74 5c je 10a895 <== NOT EXECUTED { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, 10a839: 52 push %edx <== NOT EXECUTED 10a83a: 6a 00 push $0x0 <== NOT EXECUTED 10a83c: 56 push %esi <== NOT EXECUTED 10a83d: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED 10a842: e8 f9 02 00 00 call 10ab40 <== NOT EXECUTED 10a847: 89 c3 mov %eax,%ebx <== NOT EXECUTED fildes, 0); if (r_chain == NULL) { 10a849: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a84c: 85 c0 test %eax,%eax <== NOT EXECUTED 10a84e: 75 17 jne 10a867 <== NOT EXECUTED pthread_mutex_unlock(&aio_request_queue.mutex); 10a850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a853: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10a858: e8 07 10 00 00 call 10b864 <== NOT EXECUTED return AIO_ALLDONE; 10a85d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a860: b3 02 mov $0x2,%bl <== NOT EXECUTED 10a862: e9 1b 01 00 00 jmp 10a982 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10a867: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a86a: 50 push %eax <== NOT EXECUTED 10a86b: e8 dc 26 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED } rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a870: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a873: e8 07 06 00 00 call 10ae7f <== NOT EXECUTED pthread_mutex_destroy (&r_chain->mutex); 10a878: 8d 73 1c lea 0x1c(%ebx),%esi <== NOT EXECUTED 10a87b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a87e: e8 41 0d 00 00 call 10b5c4 <== NOT EXECUTED pthread_cond_destroy (&r_chain->mutex); 10a883: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a886: e8 45 0a 00 00 call 10b2d0 <== NOT EXECUTED free (r_chain); 10a88b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a88e: e8 ad d4 ff ff call 107d40 <== NOT EXECUTED 10a893: eb 3e jmp 10a8d3 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); return AIO_CANCELED; } pthread_mutex_unlock (&aio_request_queue.mutex); 10a895: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a898: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10a89d: e8 c2 0f 00 00 call 10b864 <== NOT EXECUTED return AIO_ALLDONE; 10a8a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8a5: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10a8aa: e9 d3 00 00 00 jmp 10a982 <== NOT EXECUTED } pthread_mutex_lock (&r_chain->mutex); 10a8af: 8d 70 1c lea 0x1c(%eax),%esi <== NOT EXECUTED 10a8b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a8b5: 56 push %esi <== NOT EXECUTED 10a8b6: e8 29 0f 00 00 call 10b7e4 <== NOT EXECUTED 10a8bb: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a8be: e8 89 26 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a8c3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a8c6: e8 b4 05 00 00 call 10ae7f <== NOT EXECUTED pthread_mutex_unlock (&r_chain->mutex); 10a8cb: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a8ce: e8 91 0f 00 00 call 10b864 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10a8d3: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED 10a8da: e8 85 0f 00 00 call 10b864 <== NOT EXECUTED return AIO_CANCELED; 10a8df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8e2: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a8e4: e9 99 00 00 00 jmp 10a982 <== NOT EXECUTED } else { if (aiocbp->aio_fildes != fildes) { 10a8e9: 8b 3b mov (%ebx),%edi 10a8eb: 39 f7 cmp %esi,%edi 10a8ed: 74 20 je 10a90f <== NEVER TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10a8ef: 83 ec 0c sub $0xc,%esp 10a8f2: 68 78 72 12 00 push $0x127278 10a8f7: e8 68 0f 00 00 call 10b864 rtems_set_errno_and_return_minus_one (EINVAL); 10a8fc: e8 cf 8d 00 00 call 1136d0 <__errno> 10a901: c7 00 16 00 00 00 movl $0x16,(%eax) 10a907: 83 c4 10 add $0x10,%esp 10a90a: 83 cb ff or $0xffffffff,%ebx 10a90d: eb 73 jmp 10a982 } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10a90f: 50 push %eax <== NOT EXECUTED 10a910: 6a 00 push $0x0 <== NOT EXECUTED 10a912: 57 push %edi <== NOT EXECUTED 10a913: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10a918: e8 23 02 00 00 call 10ab40 <== NOT EXECUTED 10a91d: 89 c6 mov %eax,%esi <== NOT EXECUTED fildes, 0); if (r_chain == NULL) 10a91f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a922: 85 c0 test %eax,%eax <== NOT EXECUTED 10a924: 75 2e jne 10a954 <== NOT EXECUTED if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) 10a926: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED 10a92d: 72 12 00 10a930: 74 22 je 10a954 <== NOT EXECUTED { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, 10a932: 56 push %esi <== NOT EXECUTED 10a933: 6a 00 push $0x0 <== NOT EXECUTED 10a935: 57 push %edi <== NOT EXECUTED 10a936: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED 10a93b: e8 00 02 00 00 call 10ab40 <== NOT EXECUTED fildes, 0); if (r_chain == NULL) 10a940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a943: 85 c0 test %eax,%eax <== NOT EXECUTED 10a945: 74 a8 je 10a8ef <== NOT EXECUTED { pthread_mutex_unlock (&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EINVAL); } result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp); 10a947: 51 push %ecx <== NOT EXECUTED 10a948: 51 push %ecx <== NOT EXECUTED 10a949: 53 push %ebx <== NOT EXECUTED 10a94a: 50 push %eax <== NOT EXECUTED 10a94b: e8 6f 05 00 00 call 10aebf <== NOT EXECUTED 10a950: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a952: eb 1f jmp 10a973 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); return result; } pthread_mutex_lock (&r_chain->mutex); 10a954: 8d 7e 1c lea 0x1c(%esi),%edi <== NOT EXECUTED 10a957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a95a: 57 push %edi <== NOT EXECUTED 10a95b: e8 84 0e 00 00 call 10b7e4 <== NOT EXECUTED result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp); 10a960: 58 pop %eax <== NOT EXECUTED 10a961: 5a pop %edx <== NOT EXECUTED 10a962: 53 push %ebx <== NOT EXECUTED 10a963: 56 push %esi <== NOT EXECUTED 10a964: e8 56 05 00 00 call 10aebf <== NOT EXECUTED 10a969: 89 c3 mov %eax,%ebx <== NOT EXECUTED pthread_mutex_unlock (&r_chain->mutex); 10a96b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10a96e: e8 f1 0e 00 00 call 10b864 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10a973: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED 10a97a: e8 e5 0e 00 00 call 10b864 <== NOT EXECUTED return result; 10a97f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return AIO_ALLDONE; } 10a982: 89 d8 mov %ebx,%eax 10a984: 8d 65 f4 lea -0xc(%ebp),%esp 10a987: 5b pop %ebx 10a988: 5e pop %esi 10a989: 5f pop %edi 10a98a: c9 leave 10a98b: c3 ret =============================================================================== 0010a998 : int aio_fsync( int op, struct aiocb *aiocbp ) { 10a998: 55 push %ebp 10a999: 89 e5 mov %esp,%ebp 10a99b: 53 push %ebx 10a99c: 83 ec 04 sub $0x4,%esp 10a99f: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 10a9a2: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 10a9a9: 74 1b je 10a9c6 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10a9ab: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10a9b2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a9b9: e8 12 8d 00 00 call 1136d0 <__errno> 10a9be: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9c4: eb 74 jmp 10aa3a mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a9c6: 50 push %eax 10a9c7: 50 push %eax 10a9c8: 6a 03 push $0x3 10a9ca: ff 33 pushl (%ebx) 10a9cc: e8 9b 5e 00 00 call 11086c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10a9d1: 83 e0 03 and $0x3,%eax 10a9d4: 48 dec %eax 10a9d5: 83 c4 10 add $0x10,%esp 10a9d8: 83 f8 01 cmp $0x1,%eax 10a9db: 76 1b jbe 10a9f8 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10a9dd: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10a9e4: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a9eb: e8 e0 8c 00 00 call 1136d0 <__errno> 10a9f0: c7 00 09 00 00 00 movl $0x9,(%eax) 10a9f6: eb 42 jmp 10aa3a req = malloc (sizeof (rtems_aio_request)); 10a9f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a9fb: 6a 18 push $0x18 <== NOT EXECUTED 10a9fd: e8 c2 d7 ff ff call 1081c4 <== NOT EXECUTED if (req == NULL) 10aa02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa05: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa07: 75 1b jne 10aa24 <== NOT EXECUTED rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10aa09: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10aa10: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10aa17: e8 b4 8c 00 00 call 1136d0 <__errno> <== NOT EXECUTED 10aa1c: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10aa22: eb 16 jmp 10aa3a <== NOT EXECUTED req->aiocbp = aiocbp; 10aa24: 89 58 14 mov %ebx,0x14(%eax) <== NOT EXECUTED req->aiocbp->aio_lio_opcode = LIO_SYNC; 10aa27: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) <== NOT EXECUTED return rtems_aio_enqueue (req); 10aa2e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10aa31: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa34: c9 leave <== NOT EXECUTED rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); 10aa35: e9 d7 04 00 00 jmp 10af11 <== NOT EXECUTED } 10aa3a: 83 c8 ff or $0xffffffff,%eax 10aa3d: 8b 5d fc mov -0x4(%ebp),%ebx 10aa40: c9 leave 10aa41: c3 ret =============================================================================== 0010b10c : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10b10c: 55 push %ebp 10b10d: 89 e5 mov %esp,%ebp 10b10f: 53 push %ebx 10b110: 83 ec 0c sub $0xc,%esp 10b113: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b116: 6a 03 push $0x3 10b118: ff 33 pushl (%ebx) 10b11a: e8 4d 57 00 00 call 11086c if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b11f: 83 e0 03 and $0x3,%eax 10b122: 83 c4 10 add $0x10,%esp 10b125: 83 f8 02 cmp $0x2,%eax 10b128: 74 1f je 10b149 10b12a: 85 c0 test %eax,%eax 10b12c: 74 1b je 10b149 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b12e: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b135: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b13c: e8 8f 85 00 00 call 1136d0 <__errno> 10b141: c7 00 09 00 00 00 movl $0x9,(%eax) 10b147: eb 69 jmp 10b1b2 if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b149: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b14d: 75 06 jne 10b155 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b14f: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b153: 79 1b jns 10b170 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b155: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b15c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b163: e8 68 85 00 00 call 1136d0 <__errno> 10b168: c7 00 16 00 00 00 movl $0x16,(%eax) 10b16e: eb 42 jmp 10b1b2 req = malloc (sizeof (rtems_aio_request)); 10b170: 83 ec 0c sub $0xc,%esp 10b173: 6a 18 push $0x18 10b175: e8 4a d0 ff ff call 1081c4 if (req == NULL) 10b17a: 83 c4 10 add $0x10,%esp 10b17d: 85 c0 test %eax,%eax 10b17f: 75 1b jne 10b19c <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b181: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b188: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b18f: e8 3c 85 00 00 call 1136d0 <__errno> <== NOT EXECUTED 10b194: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b19a: eb 16 jmp 10b1b2 <== NOT EXECUTED req->aiocbp = aiocbp; 10b19c: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10b19f: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10b1a6: 89 45 08 mov %eax,0x8(%ebp) } 10b1a9: 8b 5d fc mov -0x4(%ebp),%ebx 10b1ac: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_READ; return rtems_aio_enqueue (req); 10b1ad: e9 5f fd ff ff jmp 10af11 } 10b1b2: 83 c8 ff or $0xffffffff,%eax 10b1b5: 8b 5d fc mov -0x4(%ebp),%ebx 10b1b8: c9 leave 10b1b9: c3 ret =============================================================================== 0010b1c8 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10b1c8: 55 push %ebp 10b1c9: 89 e5 mov %esp,%ebp 10b1cb: 53 push %ebx 10b1cc: 83 ec 0c sub $0xc,%esp 10b1cf: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b1d2: 6a 03 push $0x3 10b1d4: ff 33 pushl (%ebx) 10b1d6: e8 91 56 00 00 call 11086c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b1db: 83 e0 03 and $0x3,%eax 10b1de: 48 dec %eax 10b1df: 83 c4 10 add $0x10,%esp 10b1e2: 83 f8 01 cmp $0x1,%eax 10b1e5: 76 1b jbe 10b202 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b1e7: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b1ee: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b1f5: e8 d6 84 00 00 call 1136d0 <__errno> 10b1fa: c7 00 09 00 00 00 movl $0x9,(%eax) 10b200: eb 69 jmp 10b26b if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b202: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b206: 75 06 jne 10b20e rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b208: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b20c: 79 1b jns 10b229 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b20e: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b215: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b21c: e8 af 84 00 00 call 1136d0 <__errno> 10b221: c7 00 16 00 00 00 movl $0x16,(%eax) 10b227: eb 42 jmp 10b26b req = malloc (sizeof (rtems_aio_request)); 10b229: 83 ec 0c sub $0xc,%esp 10b22c: 6a 18 push $0x18 10b22e: e8 91 cf ff ff call 1081c4 if (req == NULL) 10b233: 83 c4 10 add $0x10,%esp 10b236: 85 c0 test %eax,%eax 10b238: 75 1b jne 10b255 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b23a: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b241: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b248: e8 83 84 00 00 call 1136d0 <__errno> <== NOT EXECUTED 10b24d: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b253: eb 16 jmp 10b26b <== NOT EXECUTED req->aiocbp = aiocbp; 10b255: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10b258: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10b25f: 89 45 08 mov %eax,0x8(%ebp) } 10b262: 8b 5d fc mov -0x4(%ebp),%ebx 10b265: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_WRITE; return rtems_aio_enqueue (req); 10b266: e9 a6 fc ff ff jmp 10af11 } 10b26b: 83 c8 ff or $0xffffffff,%eax 10b26e: 8b 5d fc mov -0x4(%ebp),%ebx 10b271: c9 leave 10b272: c3 ret =============================================================================== 00109f94 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 109f94: 55 push %ebp 109f95: 89 e5 mov %esp,%ebp 109f97: 83 ec 08 sub $0x8,%esp 109f9a: 8b 45 08 mov 0x8(%ebp),%eax 109f9d: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109fa0: 85 d2 test %edx,%edx 109fa2: 74 3c je 109fe0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 109fa4: 83 f8 01 cmp $0x1,%eax 109fa7: 75 0b jne 109fb4 _TOD_Get(tp); 109fa9: 83 ec 0c sub $0xc,%esp 109fac: 52 push %edx 109fad: e8 b6 1b 00 00 call 10bb68 <_TOD_Get> 109fb2: eb 13 jmp 109fc7 return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 109fb4: 83 f8 04 cmp $0x4,%eax 109fb7: 74 05 je 109fbe <== NEVER TAKEN return 0; } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { 109fb9: 83 f8 02 cmp $0x2,%eax 109fbc: 75 10 jne 109fce _TOD_Get_uptime_as_timespec( tp ); 109fbe: 83 ec 0c sub $0xc,%esp 109fc1: 52 push %edx 109fc2: e8 fd 1b 00 00 call 10bbc4 <_TOD_Get_uptime_as_timespec> return 0; 109fc7: 83 c4 10 add $0x10,%esp 109fca: 31 c0 xor %eax,%eax 109fcc: eb 20 jmp 109fee } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) 109fce: 83 f8 03 cmp $0x3,%eax 109fd1: 75 0d jne 109fe0 rtems_set_errno_and_return_minus_one( ENOSYS ); 109fd3: e8 0c 80 00 00 call 111fe4 <__errno> 109fd8: c7 00 58 00 00 00 movl $0x58,(%eax) 109fde: eb 0b jmp 109feb #endif rtems_set_errno_and_return_minus_one( EINVAL ); 109fe0: e8 ff 7f 00 00 call 111fe4 <__errno> 109fe5: c7 00 16 00 00 00 movl $0x16,(%eax) 109feb: 83 c8 ff or $0xffffffff,%eax return 0; } 109fee: c9 leave 109fef: c3 ret =============================================================================== 00109ff0 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 109ff0: 55 push %ebp 109ff1: 89 e5 mov %esp,%ebp 109ff3: 83 ec 08 sub $0x8,%esp 109ff6: 8b 45 08 mov 0x8(%ebp),%eax 109ff9: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109ffc: 85 d2 test %edx,%edx 109ffe: 74 44 je 10a044 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10a000: 83 f8 01 cmp $0x1,%eax 10a003: 75 28 jne 10a02d if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 10a005: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) 10a00b: 76 37 jbe 10a044 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a00d: a1 20 63 12 00 mov 0x126320,%eax 10a012: 40 inc %eax 10a013: a3 20 63 12 00 mov %eax,0x126320 rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 10a018: 83 ec 0c sub $0xc,%esp 10a01b: 52 push %edx 10a01c: e8 fb 1b 00 00 call 10bc1c <_TOD_Set> _Thread_Enable_dispatch(); 10a021: e8 80 2e 00 00 call 10cea6 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 10a026: 83 c4 10 add $0x10,%esp 10a029: 31 c0 xor %eax,%eax 10a02b: eb 25 jmp 10a052 _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10a02d: 83 f8 02 cmp $0x2,%eax 10a030: 74 05 je 10a037 rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10a032: 83 f8 03 cmp $0x3,%eax 10a035: 75 0d jne 10a044 rtems_set_errno_and_return_minus_one( ENOSYS ); 10a037: e8 a8 7f 00 00 call 111fe4 <__errno> 10a03c: c7 00 58 00 00 00 movl $0x58,(%eax) 10a042: eb 0b jmp 10a04f #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10a044: e8 9b 7f 00 00 call 111fe4 <__errno> 10a049: c7 00 16 00 00 00 movl $0x16,(%eax) 10a04f: 83 c8 ff or $0xffffffff,%eax return 0; } 10a052: c9 leave 10a053: c3 ret =============================================================================== 001216a0 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 1216a0: 55 push %ebp 1216a1: 89 e5 mov %esp,%ebp 1216a3: 57 push %edi 1216a4: 56 push %esi 1216a5: 53 push %ebx 1216a6: 83 ec 4c sub $0x4c,%esp 1216a9: 8b 5d 0c mov 0xc(%ebp),%ebx 1216ac: 8b 7d 10 mov 0x10(%ebp),%edi POSIX_signals_Siginfo_node *psiginfo; /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 1216af: e8 64 fd ff ff call 121418 1216b4: 39 45 08 cmp %eax,0x8(%ebp) 1216b7: 74 0d je 1216c6 rtems_set_errno_and_return_minus_one( ESRCH ); 1216b9: e8 1a 43 ff ff call 1159d8 <__errno> 1216be: c7 00 03 00 00 00 movl $0x3,(%eax) 1216c4: eb 0f jmp 1216d5 /* * Validate the signal passed. */ if ( !sig ) 1216c6: 85 db test %ebx,%ebx 1216c8: 75 13 jne 1216dd rtems_set_errno_and_return_minus_one( EINVAL ); 1216ca: e8 09 43 ff ff call 1159d8 <__errno> 1216cf: c7 00 16 00 00 00 movl $0x16,(%eax) 1216d5: 83 c8 ff or $0xffffffff,%eax 1216d8: e9 ef 01 00 00 jmp 1218cc static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 1216dd: 8d 4b ff lea -0x1(%ebx),%ecx if ( !is_valid_signo(sig) ) 1216e0: 83 f9 1f cmp $0x1f,%ecx 1216e3: 77 e5 ja 1216ca 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 ) 1216e5: 6b d3 0c imul $0xc,%ebx,%edx return 0; 1216e8: 31 c0 xor %eax,%eax 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 ) 1216ea: 83 ba dc a9 12 00 01 cmpl $0x1,0x12a9dc(%edx) 1216f1: 0f 84 d5 01 00 00 je 1218cc /* * 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 ) ) 1216f7: 83 fb 04 cmp $0x4,%ebx 1216fa: 74 0a je 121706 1216fc: 83 fb 08 cmp $0x8,%ebx 1216ff: 74 05 je 121706 121701: 83 fb 0b cmp $0xb,%ebx 121704: 75 16 jne 12171c return pthread_kill( pthread_self(), sig ); 121706: e8 89 03 00 00 call 121a94 12170b: 56 push %esi 12170c: 56 push %esi 12170d: 53 push %ebx 12170e: 50 push %eax 12170f: e8 d8 02 00 00 call 1219ec 121714: 83 c4 10 add $0x10,%esp 121717: e9 b0 01 00 00 jmp 1218cc static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 12171c: be 01 00 00 00 mov $0x1,%esi 121721: d3 e6 shl %cl,%esi /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 121723: 89 5d dc mov %ebx,-0x24(%ebp) siginfo->si_code = SI_USER; 121726: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 12172d: 85 ff test %edi,%edi 12172f: 75 09 jne 12173a siginfo->si_value.sival_int = 0; 121731: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 121738: eb 05 jmp 12173f } else { siginfo->si_value = *value; 12173a: 8b 07 mov (%edi),%eax 12173c: 89 45 e4 mov %eax,-0x1c(%ebp) 12173f: a1 54 a4 12 00 mov 0x12a454,%eax 121744: 40 inc %eax 121745: a3 54 a4 12 00 mov %eax,0x12a454 /* * 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; 12174a: a1 a0 a9 12 00 mov 0x12a9a0,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 12174f: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx 121755: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 12175b: f7 d2 not %edx 12175d: 85 d6 test %edx,%esi 12175f: 0f 85 ed 00 00 00 jne 121852 } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 121765: 8b 15 60 ab 12 00 mov 0x12ab60,%edx /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 12176b: eb 23 jmp 121790 !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 12176d: 89 d0 mov %edx,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 12176f: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx #endif /* * Is this thread is actually blocked waiting for the signal? */ if (the_thread->Wait.option & mask) 121775: 85 72 30 test %esi,0x30(%edx) 121778: 0f 85 d4 00 00 00 jne 121852 /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 12177e: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 121784: f7 d1 not %ecx 121786: 85 ce test %ecx,%esi 121788: 0f 85 c4 00 00 00 jne 121852 the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 12178e: 8b 12 mov (%edx),%edx /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 121790: 81 fa 64 ab 12 00 cmp $0x12ab64,%edx 121796: 75 d5 jne 12176d * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 121798: 0f b6 0d f4 61 12 00 movzbl 0x1261f4,%ecx 12179f: 41 inc %ecx * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 1217a0: 31 c0 xor %eax,%eax interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 1217a2: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp) /* * This can occur when no one is interested and an API is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 1217a9: 8b 7d cc mov -0x34(%ebp),%edi 1217ac: 8b 14 bd 2c a4 12 00 mov 0x12a42c(,%edi,4),%edx 1217b3: 85 d2 test %edx,%edx 1217b5: 0f 84 86 00 00 00 je 121841 <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 1217bb: 8b 52 04 mov 0x4(%edx),%edx */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 1217be: 0f b7 7a 10 movzwl 0x10(%edx),%edi 1217c2: 89 7d c4 mov %edi,-0x3c(%ebp) object_table = the_info->local_table; 1217c5: 8b 52 1c mov 0x1c(%edx),%edx 1217c8: 89 55 c0 mov %edx,-0x40(%ebp) for ( index = 1 ; index <= maximum ; index++ ) { 1217cb: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) 1217d2: 89 5d b4 mov %ebx,-0x4c(%ebp) 1217d5: eb 5f jmp 121836 the_thread = (Thread_Control *) object_table[ index ]; 1217d7: 8b 5d d0 mov -0x30(%ebp),%ebx 1217da: 8b 7d c0 mov -0x40(%ebp),%edi 1217dd: 8b 14 9f mov (%edi,%ebx,4),%edx if ( !the_thread ) 1217e0: 85 d2 test %edx,%edx 1217e2: 74 4f je 121833 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 1217e4: 8b 5a 14 mov 0x14(%edx),%ebx 1217e7: 89 5d d4 mov %ebx,-0x2c(%ebp) 1217ea: 39 cb cmp %ecx,%ebx 1217ec: 77 45 ja 121833 #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 1217ee: 8b ba ec 00 00 00 mov 0xec(%edx),%edi 1217f4: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi 1217fa: f7 d7 not %edi 1217fc: 85 fe test %edi,%esi 1217fe: 74 33 je 121833 * * 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 ) { 121800: 39 cb cmp %ecx,%ebx 121802: 72 2a jb 12182e * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 121804: 85 c0 test %eax,%eax 121806: 74 2b je 121833 <== NEVER TAKEN 121808: 8b 78 10 mov 0x10(%eax),%edi 12180b: 89 7d c8 mov %edi,-0x38(%ebp) 12180e: 85 ff test %edi,%edi 121810: 74 21 je 121833 <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 121812: 8b 7a 10 mov 0x10(%edx),%edi 121815: 85 ff test %edi,%edi 121817: 74 15 je 12182e continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 121819: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp) 121820: 75 11 jne 121833 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 121822: 81 e7 00 00 00 10 and $0x10000000,%edi 121828: 74 09 je 121833 12182a: 89 d9 mov %ebx,%ecx 12182c: eb 03 jmp 121831 */ if ( interested && !_States_Is_ready( interested->current_state ) ) { /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 12182e: 8b 4d d4 mov -0x2c(%ebp),%ecx 121831: 89 d0 mov %edx,%eax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 121833: ff 45 d0 incl -0x30(%ebp) 121836: 8b 55 c4 mov -0x3c(%ebp),%edx 121839: 39 55 d0 cmp %edx,-0x30(%ebp) 12183c: 76 99 jbe 1217d7 12183e: 8b 5d b4 mov -0x4c(%ebp),%ebx * + 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++) { 121841: ff 45 cc incl -0x34(%ebp) 121844: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 121848: 0f 85 5b ff ff ff jne 1217a9 } } } } if ( interested ) { 12184e: 85 c0 test %eax,%eax 121850: 74 13 je 121865 /* * 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 ) ) { 121852: 51 push %ecx mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 121853: 8d 55 dc lea -0x24(%ebp),%edx /* * 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 ) ) { 121856: 52 push %edx 121857: 53 push %ebx 121858: 50 push %eax 121859: e8 8a 00 00 00 call 1218e8 <_POSIX_signals_Unblock_thread> 12185e: 83 c4 10 add $0x10,%esp 121861: 84 c0 test %al,%al 121863: 75 60 jne 1218c5 /* * 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 ); 121865: 83 ec 0c sub $0xc,%esp 121868: 56 push %esi 121869: e8 66 00 00 00 call 1218d4 <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 12186e: 6b db 0c imul $0xc,%ebx,%ebx 121871: 83 c4 10 add $0x10,%esp 121874: 83 bb d4 a9 12 00 02 cmpl $0x2,0x12a9d4(%ebx) 12187b: 75 48 jne 1218c5 psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); 12187d: 83 ec 0c sub $0xc,%esp 121880: 68 54 ab 12 00 push $0x12ab54 121885: e8 a6 d8 fe ff call 10f130 <_Chain_Get> if ( !psiginfo ) { 12188a: 83 c4 10 add $0x10,%esp 12188d: 85 c0 test %eax,%eax 12188f: 75 15 jne 1218a6 _Thread_Enable_dispatch(); 121891: e8 fc ef fe ff call 110892 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 121896: e8 3d 41 ff ff call 1159d8 <__errno> 12189b: c7 00 0b 00 00 00 movl $0xb,(%eax) 1218a1: e9 2f fe ff ff jmp 1216d5 } psiginfo->Info = *siginfo; 1218a6: 8d 78 08 lea 0x8(%eax),%edi 1218a9: 8d 75 dc lea -0x24(%ebp),%esi 1218ac: b9 03 00 00 00 mov $0x3,%ecx 1218b1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 1218b3: 52 push %edx 1218b4: 52 push %edx 1218b5: 50 push %eax 1218b6: 81 c3 cc ab 12 00 add $0x12abcc,%ebx 1218bc: 53 push %ebx 1218bd: e8 32 d8 fe ff call 10f0f4 <_Chain_Append> 1218c2: 83 c4 10 add $0x10,%esp } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 1218c5: e8 c8 ef fe ff call 110892 <_Thread_Enable_dispatch> return 0; 1218ca: 31 c0 xor %eax,%eax } 1218cc: 8d 65 f4 lea -0xc(%ebp),%esp 1218cf: 5b pop %ebx 1218d0: 5e pop %esi 1218d1: 5f pop %edi 1218d2: c9 leave 1218d3: c3 ret =============================================================================== 0010dff0 : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 10dff0: 55 push %ebp 10dff1: 89 e5 mov %esp,%ebp 10dff3: 53 push %ebx 10dff4: 83 ec 14 sub $0x14,%esp 10dff7: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; CORE_message_queue_Attributes *the_mq_attr; if ( !mqstat ) 10dffa: 85 db test %ebx,%ebx 10dffc: 75 0d jne 10e00b <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10dffe: e8 65 8e 00 00 call 116e68 <__errno> 10e003: c7 00 16 00 00 00 movl $0x16,(%eax) 10e009: eb 49 jmp 10e054 RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( mqd_t id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) _Objects_Get( 10e00b: 50 push %eax the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); 10e00c: 8d 45 f4 lea -0xc(%ebp),%eax 10e00f: 50 push %eax 10e010: ff 75 08 pushl 0x8(%ebp) 10e013: 68 f4 cc 12 00 push $0x12ccf4 10e018: e8 bb 2d 00 00 call 110dd8 <_Objects_Get> switch ( location ) { 10e01d: 83 c4 10 add $0x10,%esp 10e020: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10e024: 75 23 jne 10e049 case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; 10e026: 8b 50 10 mov 0x10(%eax),%edx * Return the old values. */ the_mq_attr = &the_mq->Message_queue.Attributes; mqstat->mq_flags = the_mq_fd->oflag; 10e029: 8b 40 14 mov 0x14(%eax),%eax 10e02c: 89 03 mov %eax,(%ebx) mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 10e02e: 8b 42 68 mov 0x68(%edx),%eax 10e031: 89 43 08 mov %eax,0x8(%ebx) mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 10e034: 8b 42 60 mov 0x60(%edx),%eax 10e037: 89 43 04 mov %eax,0x4(%ebx) mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 10e03a: 8b 42 64 mov 0x64(%edx),%eax 10e03d: 89 43 0c mov %eax,0xc(%ebx) _Thread_Enable_dispatch(); 10e040: e8 e5 37 00 00 call 11182a <_Thread_Enable_dispatch> return 0; 10e045: 31 c0 xor %eax,%eax 10e047: eb 0e jmp 10e057 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e049: e8 1a 8e 00 00 call 116e68 <__errno> 10e04e: c7 00 09 00 00 00 movl $0x9,(%eax) 10e054: 83 c8 ff or $0xffffffff,%eax } 10e057: 8b 5d fc mov -0x4(%ebp),%ebx 10e05a: c9 leave 10e05b: c3 ret =============================================================================== 0010efd8 : int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { 10efd8: 55 push %ebp 10efd9: 89 e5 mov %esp,%ebp 10efdb: 8b 55 08 mov 0x8(%ebp),%edx 10efde: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; 10efe1: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { if ( !attr || !attr->is_initialized || !inheritsched ) 10efe6: 85 d2 test %edx,%edx 10efe8: 74 17 je 10f001 <== NEVER TAKEN 10efea: 85 c9 test %ecx,%ecx 10efec: 74 0e je 10effc 10efee: 83 3a 00 cmpl $0x0,(%edx) 10eff1: 74 09 je 10effc return EINVAL; *inheritsched = attr->inheritsched; 10eff3: 8b 42 10 mov 0x10(%edx),%eax 10eff6: 89 01 mov %eax,(%ecx) return 0; 10eff8: 31 c0 xor %eax,%eax 10effa: eb 05 jmp 10f001 const pthread_attr_t *attr, int *inheritsched ) { if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; 10effc: b8 16 00 00 00 mov $0x16,%eax *inheritsched = attr->inheritsched; return 0; } 10f001: c9 leave 10f002: c3 ret =============================================================================== 0010f1f4 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10f1f4: 55 push %ebp 10f1f5: 89 e5 mov %esp,%ebp 10f1f7: 8b 55 08 mov 0x8(%ebp),%edx 10f1fa: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10f1fd: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { if ( !attr || !attr->is_initialized ) 10f202: 85 d2 test %edx,%edx 10f204: 74 1e je 10f224 10f206: 83 3a 00 cmpl $0x0,(%edx) 10f209: 74 19 je 10f224 return EINVAL; switch ( policy ) { 10f20b: 83 f9 04 cmp $0x4,%ecx 10f20e: 77 0f ja 10f21f 10f210: b0 01 mov $0x1,%al 10f212: d3 e0 shl %cl,%eax 10f214: a8 17 test $0x17,%al 10f216: 74 07 je 10f21f <== NEVER TAKEN case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10f218: 89 4a 14 mov %ecx,0x14(%edx) return 0; 10f21b: 31 c0 xor %eax,%eax 10f21d: eb 05 jmp 10f224 default: return ENOTSUP; 10f21f: b8 86 00 00 00 mov $0x86,%eax } } 10f224: c9 leave 10f225: c3 ret =============================================================================== 0010a514 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10a514: 55 push %ebp 10a515: 89 e5 mov %esp,%ebp 10a517: 57 push %edi 10a518: 56 push %esi 10a519: 53 push %ebx 10a51a: 83 ec 1c sub $0x1c,%esp 10a51d: 8b 5d 08 mov 0x8(%ebp),%ebx 10a520: 8b 75 10 mov 0x10(%ebp),%esi /* * Error check parameters */ if ( !barrier ) return EINVAL; 10a523: b8 16 00 00 00 mov $0x16,%eax const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10a528: 85 db test %ebx,%ebx 10a52a: 0f 84 96 00 00 00 je 10a5c6 return EINVAL; if ( count == 0 ) 10a530: 85 f6 test %esi,%esi 10a532: 0f 84 8e 00 00 00 je 10a5c6 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10a538: 8b 7d 0c mov 0xc(%ebp),%edi 10a53b: 85 ff test %edi,%edi 10a53d: 75 0f jne 10a54e the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10a53f: 83 ec 0c sub $0xc,%esp 10a542: 8d 7d d8 lea -0x28(%ebp),%edi 10a545: 57 push %edi 10a546: e8 19 ff ff ff call 10a464 10a54b: 83 c4 10 add $0x10,%esp /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) return EINVAL; 10a54e: b8 16 00 00 00 mov $0x16,%eax } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10a553: 83 3f 00 cmpl $0x0,(%edi) 10a556: 74 6e je 10a5c6 return EINVAL; switch ( the_attr->process_shared ) { 10a558: 83 7f 04 00 cmpl $0x0,0x4(%edi) 10a55c: 75 68 jne 10a5c6 <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a55e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_attributes.maximum_count = count; 10a565: 89 75 e4 mov %esi,-0x1c(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a568: a1 90 64 12 00 mov 0x126490,%eax 10a56d: 40 inc %eax 10a56e: a3 90 64 12 00 mov %eax,0x126490 * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void ) { return (POSIX_Barrier_Control *) _Objects_Allocate( &_POSIX_Barrier_Information ); 10a573: 83 ec 0c sub $0xc,%esp 10a576: 68 58 68 12 00 push $0x126858 10a57b: e8 14 1e 00 00 call 10c394 <_Objects_Allocate> 10a580: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10a582: 83 c4 10 add $0x10,%esp 10a585: 85 c0 test %eax,%eax 10a587: 75 0c jne 10a595 _Thread_Enable_dispatch(); 10a589: e8 14 2c 00 00 call 10d1a2 <_Thread_Enable_dispatch> return EAGAIN; 10a58e: b8 0b 00 00 00 mov $0xb,%eax 10a593: eb 31 jmp 10a5c6 } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a595: 50 push %eax 10a596: 50 push %eax 10a597: 8d 45 e0 lea -0x20(%ebp),%eax 10a59a: 50 push %eax 10a59b: 8d 46 10 lea 0x10(%esi),%eax 10a59e: 50 push %eax 10a59f: e8 a8 14 00 00 call 10ba4c <_CORE_barrier_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a5a4: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a5a7: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a5aa: 8b 15 74 68 12 00 mov 0x126874,%edx 10a5b0: 89 34 8a mov %esi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10a5b3: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 10a5ba: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10a5bc: e8 e1 2b 00 00 call 10d1a2 <_Thread_Enable_dispatch> return 0; 10a5c1: 83 c4 10 add $0x10,%esp 10a5c4: 31 c0 xor %eax,%eax } 10a5c6: 8d 65 f4 lea -0xc(%ebp),%esp 10a5c9: 5b pop %ebx 10a5ca: 5e pop %esi 10a5cb: 5f pop %edi 10a5cc: c9 leave 10a5cd: c3 ret =============================================================================== 00109ecc : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 109ecc: 55 push %ebp 109ecd: 89 e5 mov %esp,%ebp 109ecf: 56 push %esi 109ed0: 53 push %ebx 109ed1: 8b 5d 08 mov 0x8(%ebp),%ebx 109ed4: 8b 75 0c mov 0xc(%ebp),%esi /* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine ) 109ed7: 85 db test %ebx,%ebx 109ed9: 74 4b je 109f26 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 109edb: a1 c8 62 12 00 mov 0x1262c8,%eax 109ee0: 40 inc %eax 109ee1: a3 c8 62 12 00 mov %eax,0x1262c8 return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 109ee6: 83 ec 0c sub $0xc,%esp 109ee9: 6a 10 push $0x10 109eeb: e8 02 3c 00 00 call 10daf2 <_Workspace_Allocate> if ( handler ) { 109ef0: 83 c4 10 add $0x10,%esp 109ef3: 85 c0 test %eax,%eax 109ef5: 74 24 je 109f1b <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109ef7: 8b 15 14 68 12 00 mov 0x126814,%edx handler_stack = &thread_support->Cancellation_Handlers; 109efd: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx 109f03: 81 c2 e4 00 00 00 add $0xe4,%edx handler->routine = routine; 109f09: 89 58 08 mov %ebx,0x8(%eax) handler->arg = arg; 109f0c: 89 70 0c mov %esi,0xc(%eax) _Chain_Append( handler_stack, &handler->Node ); 109f0f: 51 push %ecx 109f10: 51 push %ecx 109f11: 50 push %eax 109f12: 52 push %edx 109f13: e8 88 15 00 00 call 10b4a0 <_Chain_Append> 109f18: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 109f1b: 8d 65 f8 lea -0x8(%ebp),%esp 109f1e: 5b pop %ebx 109f1f: 5e pop %esi 109f20: c9 leave handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 109f21: e9 78 2c 00 00 jmp 10cb9e <_Thread_Enable_dispatch> } 109f26: 8d 65 f8 lea -0x8(%ebp),%esp 109f29: 5b pop %ebx 109f2a: 5e pop %esi 109f2b: c9 leave 109f2c: c3 ret =============================================================================== 0010ac3c : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10ac3c: 55 push %ebp 10ac3d: 89 e5 mov %esp,%ebp 10ac3f: 56 push %esi 10ac40: 53 push %ebx POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10ac41: 8b 5d 0c mov 0xc(%ebp),%ebx 10ac44: 85 db test %ebx,%ebx 10ac46: 75 05 jne 10ac4d else the_attr = &_POSIX_Condition_variables_Default_attributes; 10ac48: bb d0 0c 12 00 mov $0x120cd0,%ebx /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return EINVAL; 10ac4d: b8 16 00 00 00 mov $0x16,%eax else the_attr = &_POSIX_Condition_variables_Default_attributes; /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 10ac52: 83 7b 04 01 cmpl $0x1,0x4(%ebx) 10ac56: 74 76 je 10acce <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 10ac58: 83 3b 00 cmpl $0x0,(%ebx) 10ac5b: 74 71 je 10acce rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10ac5d: a1 60 73 12 00 mov 0x127360,%eax 10ac62: 40 inc %eax 10ac63: a3 60 73 12 00 mov %eax,0x127360 RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) _Objects_Allocate( &_POSIX_Condition_variables_Information ); 10ac68: 83 ec 0c sub $0xc,%esp 10ac6b: 68 c0 77 12 00 push $0x1277c0 10ac70: e8 ff 22 00 00 call 10cf74 <_Objects_Allocate> 10ac75: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10ac77: 83 c4 10 add $0x10,%esp 10ac7a: 85 c0 test %eax,%eax 10ac7c: 75 0c jne 10ac8a _Thread_Enable_dispatch(); 10ac7e: e8 ff 30 00 00 call 10dd82 <_Thread_Enable_dispatch> return ENOMEM; 10ac83: b8 0c 00 00 00 mov $0xc,%eax 10ac88: eb 44 jmp 10acce } the_cond->process_shared = the_attr->process_shared; 10ac8a: 8b 43 04 mov 0x4(%ebx),%eax 10ac8d: 89 46 10 mov %eax,0x10(%esi) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10ac90: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) _Thread_queue_Initialize( 10ac97: 6a 74 push $0x74 10ac99: 68 00 08 00 10 push $0x10000800 10ac9e: 6a 00 push $0x0 10aca0: 8d 46 18 lea 0x18(%esi),%eax 10aca3: 50 push %eax 10aca4: e8 cf 37 00 00 call 10e478 <_Thread_queue_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10aca9: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10acac: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10acaf: 8b 15 dc 77 12 00 mov 0x1277dc,%edx 10acb5: 89 34 8a mov %esi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10acb8: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10acbf: 8b 55 08 mov 0x8(%ebp),%edx 10acc2: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 10acc4: e8 b9 30 00 00 call 10dd82 <_Thread_Enable_dispatch> return 0; 10acc9: 83 c4 10 add $0x10,%esp 10accc: 31 c0 xor %eax,%eax } 10acce: 8d 65 f8 lea -0x8(%ebp),%esp 10acd1: 5b pop %ebx 10acd2: 5e pop %esi 10acd3: c9 leave 10acd4: c3 ret =============================================================================== 0010aaf0 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10aaf0: 55 push %ebp 10aaf1: 89 e5 mov %esp,%ebp 10aaf3: 8b 55 08 mov 0x8(%ebp),%edx if ( !attr || attr->is_initialized == false ) return EINVAL; 10aaf6: b8 16 00 00 00 mov $0x16,%eax int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == false ) 10aafb: 85 d2 test %edx,%edx 10aafd: 74 0d je 10ab0c 10aaff: 83 3a 00 cmpl $0x0,(%edx) 10ab02: 74 08 je 10ab0c <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 10ab04: c7 02 00 00 00 00 movl $0x0,(%edx) return 0; 10ab0a: 30 c0 xor %al,%al } 10ab0c: c9 leave 10ab0d: c3 ret =============================================================================== 0010a224 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10a224: 55 push %ebp 10a225: 89 e5 mov %esp,%ebp 10a227: 57 push %edi 10a228: 56 push %esi 10a229: 53 push %ebx 10a22a: 83 ec 5c sub $0x5c,%esp struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) return EFAULT; 10a22d: c7 45 b4 0e 00 00 00 movl $0xe,-0x4c(%ebp) int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) 10a234: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a238: 0f 84 0f 02 00 00 je 10a44d return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10a23e: 8b 5d 0c mov 0xc(%ebp),%ebx 10a241: 85 db test %ebx,%ebx 10a243: 75 05 jne 10a24a 10a245: bb 3c f9 11 00 mov $0x11f93c,%ebx if ( !the_attr->is_initialized ) return EINVAL; 10a24a: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) if ( !start_routine ) return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; if ( !the_attr->is_initialized ) 10a251: 83 3b 00 cmpl $0x0,(%ebx) 10a254: 0f 84 f3 01 00 00 je 10a44d * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) ) 10a25a: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a25e: 74 0e je 10a26e 10a260: a1 14 12 12 00 mov 0x121214,%eax 10a265: 39 43 08 cmp %eax,0x8(%ebx) 10a268: 0f 82 df 01 00 00 jb 10a44d * If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread * inherits scheduling attributes from the creating thread. If it is * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { 10a26e: 8b 43 10 mov 0x10(%ebx),%eax 10a271: 83 f8 01 cmp $0x1,%eax 10a274: 74 0b je 10a281 10a276: 83 f8 02 cmp $0x2,%eax 10a279: 0f 85 c7 01 00 00 jne 10a446 10a27f: eb 1f jmp 10a2a0 case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a281: a1 1c 58 12 00 mov 0x12581c,%eax 10a286: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi schedpolicy = api->schedpolicy; 10a28c: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10a292: 89 45 ac mov %eax,-0x54(%ebp) schedparam = api->schedparam; 10a295: 8d 7d c4 lea -0x3c(%ebp),%edi 10a298: 81 c6 88 00 00 00 add $0x88,%esi 10a29e: eb 0c jmp 10a2ac break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10a2a0: 8b 43 14 mov 0x14(%ebx),%eax 10a2a3: 89 45 ac mov %eax,-0x54(%ebp) schedparam = the_attr->schedparam; 10a2a6: 8d 7d c4 lea -0x3c(%ebp),%edi 10a2a9: 8d 73 18 lea 0x18(%ebx),%esi 10a2ac: b9 07 00 00 00 mov $0x7,%ecx 10a2b1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) return ENOTSUP; 10a2b3: c7 45 b4 86 00 00 00 movl $0x86,-0x4c(%ebp) /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 10a2ba: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10a2be: 0f 85 89 01 00 00 jne 10a44d return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10a2c4: 83 ec 0c sub $0xc,%esp 10a2c7: ff 75 c4 pushl -0x3c(%ebp) 10a2ca: e8 e5 58 00 00 call 10fbb4 <_POSIX_Priority_Is_valid> 10a2cf: 83 c4 10 add $0x10,%esp return EINVAL; 10a2d2: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10a2d9: 84 c0 test %al,%al 10a2db: 0f 84 6c 01 00 00 je 10a44d <== NEVER TAKEN return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 10a2e1: 8b 45 c4 mov -0x3c(%ebp),%eax 10a2e4: 89 45 a8 mov %eax,-0x58(%ebp) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10a2e7: 0f b6 3d 18 12 12 00 movzbl 0x121218,%edi /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 10a2ee: 8d 45 e0 lea -0x20(%ebp),%eax 10a2f1: 50 push %eax 10a2f2: 8d 45 e4 lea -0x1c(%ebp),%eax 10a2f5: 50 push %eax 10a2f6: 8d 45 c4 lea -0x3c(%ebp),%eax 10a2f9: 50 push %eax 10a2fa: ff 75 ac pushl -0x54(%ebp) 10a2fd: e8 d2 58 00 00 call 10fbd4 <_POSIX_Thread_Translate_sched_param> 10a302: 89 45 b4 mov %eax,-0x4c(%ebp) schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 10a305: 83 c4 10 add $0x10,%esp 10a308: 85 c0 test %eax,%eax 10a30a: 0f 85 3d 01 00 00 jne 10a44d #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10a310: 83 ec 0c sub $0xc,%esp 10a313: ff 35 94 53 12 00 pushl 0x125394 10a319: e8 56 15 00 00 call 10b874 <_API_Mutex_Lock> * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 10a31e: c7 04 24 18 55 12 00 movl $0x125518,(%esp) 10a325: e8 b2 1e 00 00 call 10c1dc <_Objects_Allocate> 10a32a: 89 45 b0 mov %eax,-0x50(%ebp) * Allocate the thread control block. * * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 10a32d: 83 c4 10 add $0x10,%esp 10a330: 85 c0 test %eax,%eax 10a332: 75 05 jne 10a339 _RTEMS_Unlock_allocator(); 10a334: 83 ec 0c sub $0xc,%esp 10a337: eb 53 jmp 10a38c /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10a339: 8b 4d e0 mov -0x20(%ebp),%ecx 10a33c: 8b 75 e4 mov -0x1c(%ebp),%esi 10a33f: 8b 53 08 mov 0x8(%ebx),%edx 10a342: a1 14 12 12 00 mov 0x121214,%eax 10a347: d1 e0 shl %eax 10a349: 39 d0 cmp %edx,%eax 10a34b: 73 02 jae 10a34f 10a34d: 89 d0 mov %edx,%eax 10a34f: 52 push %edx 10a350: 6a 00 push $0x0 10a352: 6a 00 push $0x0 10a354: 51 push %ecx 10a355: 56 push %esi 10a356: 6a 01 push $0x1 10a358: 81 e7 ff 00 00 00 and $0xff,%edi 10a35e: 2b 7d a8 sub -0x58(%ebp),%edi 10a361: 57 push %edi 10a362: 6a 01 push $0x1 10a364: 50 push %eax 10a365: ff 73 04 pushl 0x4(%ebx) 10a368: ff 75 b0 pushl -0x50(%ebp) 10a36b: 68 18 55 12 00 push $0x125518 10a370: e8 07 2d 00 00 call 10d07c <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10a375: 83 c4 30 add $0x30,%esp 10a378: 84 c0 test %al,%al 10a37a: 75 2a jne 10a3a6 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 10a37c: 56 push %esi 10a37d: 56 push %esi 10a37e: ff 75 b0 pushl -0x50(%ebp) 10a381: 68 18 55 12 00 push $0x125518 10a386: e8 49 21 00 00 call 10c4d4 <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a38b: 5b pop %ebx 10a38c: ff 35 94 53 12 00 pushl 0x125394 10a392: e8 25 15 00 00 call 10b8bc <_API_Mutex_Unlock> return EAGAIN; 10a397: 83 c4 10 add $0x10,%esp 10a39a: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp) 10a3a1: e9 a7 00 00 00 jmp 10a44d } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10a3a6: 8b 45 b0 mov -0x50(%ebp),%eax 10a3a9: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx api->Attributes = *the_attr; 10a3af: b9 10 00 00 00 mov $0x10,%ecx 10a3b4: 89 d7 mov %edx,%edi 10a3b6: 89 de mov %ebx,%esi 10a3b8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 10a3ba: 8b 43 3c mov 0x3c(%ebx),%eax 10a3bd: 89 42 40 mov %eax,0x40(%edx) api->schedpolicy = schedpolicy; 10a3c0: 8b 45 ac mov -0x54(%ebp),%eax 10a3c3: 89 82 84 00 00 00 mov %eax,0x84(%edx) api->schedparam = schedparam; 10a3c9: 8d ba 88 00 00 00 lea 0x88(%edx),%edi 10a3cf: 8d 75 c4 lea -0x3c(%ebp),%esi 10a3d2: b1 07 mov $0x7,%cl 10a3d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10a3d6: 83 ec 0c sub $0xc,%esp 10a3d9: 6a 00 push $0x0 10a3db: ff 75 14 pushl 0x14(%ebp) 10a3de: ff 75 10 pushl 0x10(%ebp) 10a3e1: 6a 01 push $0x1 10a3e3: ff 75 b0 pushl -0x50(%ebp) 10a3e6: 89 55 a4 mov %edx,-0x5c(%ebp) 10a3e9: e8 3a 35 00 00 call 10d928 <_Thread_Start> _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 10a3ee: 83 c4 20 add $0x20,%esp 10a3f1: 83 7d ac 04 cmpl $0x4,-0x54(%ebp) 10a3f5: 8b 55 a4 mov -0x5c(%ebp),%edx 10a3f8: 75 2e jne 10a428 _Watchdog_Insert_ticks( 10a3fa: 83 ec 0c sub $0xc,%esp &api->Sporadic_timer, _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ) 10a3fd: 8d 82 90 00 00 00 lea 0x90(%edx),%eax return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10a403: 50 push %eax 10a404: e8 77 36 00 00 call 10da80 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a409: 8b 55 a4 mov -0x5c(%ebp),%edx 10a40c: 89 82 b4 00 00 00 mov %eax,0xb4(%edx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a412: 58 pop %eax 10a413: 59 pop %ecx 10a414: 81 c2 a8 00 00 00 add $0xa8,%edx 10a41a: 52 push %edx 10a41b: 68 b4 53 12 00 push $0x1253b4 10a420: e8 0f 39 00 00 call 10dd34 <_Watchdog_Insert> 10a425: 83 c4 10 add $0x10,%esp } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10a428: 8b 45 b0 mov -0x50(%ebp),%eax 10a42b: 8b 50 08 mov 0x8(%eax),%edx 10a42e: 8b 45 08 mov 0x8(%ebp),%eax 10a431: 89 10 mov %edx,(%eax) _RTEMS_Unlock_allocator(); 10a433: 83 ec 0c sub $0xc,%esp 10a436: ff 35 94 53 12 00 pushl 0x125394 10a43c: e8 7b 14 00 00 call 10b8bc <_API_Mutex_Unlock> return 0; 10a441: 83 c4 10 add $0x10,%esp 10a444: eb 07 jmp 10a44d schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; break; default: return EINVAL; 10a446: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10a44d: 8b 45 b4 mov -0x4c(%ebp),%eax 10a450: 8d 65 f4 lea -0xc(%ebp),%esp 10a453: 5b pop %ebx 10a454: 5e pop %esi 10a455: 5f pop %edi 10a456: c9 leave 10a457: c3 ret =============================================================================== 00110d54 : } void pthread_exit( void *value_ptr ) { 110d54: 55 push %ebp 110d55: 89 e5 mov %esp,%ebp 110d57: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 110d5a: ff 75 08 pushl 0x8(%ebp) 110d5d: ff 35 2c 48 12 00 pushl 0x12482c 110d63: e8 88 ff ff ff call 110cf0 <_POSIX_Thread_Exit> 110d68: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110d6b: c9 leave <== NOT EXECUTED 110d6c: c3 ret <== NOT EXECUTED =============================================================================== 0010bf30 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10bf30: 55 push %ebp 10bf31: 89 e5 mov %esp,%ebp 10bf33: 53 push %ebx 10bf34: 83 ec 2c sub $0x2c,%esp * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10bf37: 8d 45 f4 lea -0xc(%ebp),%eax 10bf3a: 50 push %eax 10bf3b: ff 75 0c pushl 0xc(%ebp) 10bf3e: e8 b9 00 00 00 call 10bffc <_POSIX_Absolute_timeout_to_ticks> 10bf43: 89 c3 mov %eax,%ebx int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex)); int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex)); #if defined(_POSIX_TIMEOUTS) int _EXFUN(pthread_mutex_timedlock, 10bf45: 83 c4 0c add $0xc,%esp 10bf48: 83 f8 03 cmp $0x3,%eax 10bf4b: 0f 94 c2 sete %dl if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 10bf4e: ff 75 f4 pushl -0xc(%ebp) 10bf51: 0f b6 c2 movzbl %dl,%eax 10bf54: 50 push %eax 10bf55: ff 75 08 pushl 0x8(%ebp) 10bf58: 88 55 e4 mov %dl,-0x1c(%ebp) 10bf5b: e8 e8 fe ff ff call 10be48 <_POSIX_Mutex_Lock_support> * This service only gives us the option to block. We used a polling * attempt to lock if the abstime was not in the future. If we did * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { 10bf60: 83 c4 10 add $0x10,%esp 10bf63: 8a 55 e4 mov -0x1c(%ebp),%dl 10bf66: 84 d2 test %dl,%dl 10bf68: 75 1d jne 10bf87 10bf6a: 83 f8 10 cmp $0x10,%eax 10bf6d: 75 18 jne 10bf87 <== NEVER TAKEN if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10bf6f: 85 db test %ebx,%ebx 10bf71: 74 08 je 10bf7b <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10bf73: 4b dec %ebx 10bf74: 83 fb 01 cmp $0x1,%ebx 10bf77: 77 0e ja 10bf87 <== NEVER TAKEN 10bf79: eb 07 jmp 10bf82 * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; 10bf7b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10bf80: eb 05 jmp 10bf87 <== NOT EXECUTED if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10bf82: b8 74 00 00 00 mov $0x74,%eax } return lock_status; } 10bf87: 8b 5d fc mov -0x4(%ebp),%ebx 10bf8a: c9 leave 10bf8b: c3 ret =============================================================================== 0010bba8 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10bba8: 55 push %ebp 10bba9: 89 e5 mov %esp,%ebp 10bbab: 8b 55 08 mov 0x8(%ebp),%edx 10bbae: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10bbb1: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { if ( !attr || !attr->is_initialized ) 10bbb6: 85 d2 test %edx,%edx 10bbb8: 74 0f je 10bbc9 10bbba: 83 3a 00 cmpl $0x0,(%edx) 10bbbd: 74 0a je 10bbc9 return EINVAL; switch ( pshared ) { 10bbbf: 83 f9 01 cmp $0x1,%ecx 10bbc2: 77 05 ja 10bbc9 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bbc4: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10bbc7: 30 c0 xor %al,%al default: return EINVAL; } } 10bbc9: c9 leave 10bbca: c3 ret =============================================================================== 00109dc0 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 109dc0: 55 push %ebp 109dc1: 89 e5 mov %esp,%ebp 109dc3: 8b 55 08 mov 0x8(%ebp),%edx 109dc6: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 109dc9: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { if ( !attr || !attr->is_initialized ) 109dce: 85 d2 test %edx,%edx 109dd0: 74 0f je 109de1 109dd2: 83 3a 00 cmpl $0x0,(%edx) 109dd5: 74 0a je 109de1 <== NEVER TAKEN return EINVAL; switch ( type ) { 109dd7: 83 f9 03 cmp $0x3,%ecx 109dda: 77 05 ja 109de1 case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 109ddc: 89 4a 10 mov %ecx,0x10(%edx) return 0; 109ddf: 30 c0 xor %al,%al default: return EINVAL; } } 109de1: c9 leave 109de2: c3 ret =============================================================================== 0010a870 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10a870: 55 push %ebp 10a871: 89 e5 mov %esp,%ebp 10a873: 56 push %esi 10a874: 53 push %ebx 10a875: 83 ec 10 sub $0x10,%esp 10a878: 8b 5d 08 mov 0x8(%ebp),%ebx 10a87b: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10a87e: 85 f6 test %esi,%esi 10a880: 74 51 je 10a8d3 10a882: 85 db test %ebx,%ebx 10a884: 74 4d je 10a8d3 once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; 10a886: 31 c0 xor %eax,%eax ) { if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { 10a888: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a88c: 75 4a jne 10a8d8 rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10a88e: 52 push %edx 10a88f: 8d 45 f4 lea -0xc(%ebp),%eax 10a892: 50 push %eax 10a893: 68 00 01 00 00 push $0x100 10a898: 68 00 01 00 00 push $0x100 10a89d: e8 a6 0a 00 00 call 10b348 if ( !once_control->init_executed ) { 10a8a2: 83 c4 10 add $0x10,%esp 10a8a5: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a8a9: 75 0f jne 10a8ba <== NEVER TAKEN once_control->is_initialized = true; 10a8ab: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = true; 10a8b1: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10a8b8: ff d6 call *%esi } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10a8ba: 50 push %eax 10a8bb: 8d 45 f4 lea -0xc(%ebp),%eax 10a8be: 50 push %eax 10a8bf: 68 00 01 00 00 push $0x100 10a8c4: ff 75 f4 pushl -0xc(%ebp) 10a8c7: e8 7c 0a 00 00 call 10b348 10a8cc: 83 c4 10 add $0x10,%esp } return 0; 10a8cf: 31 c0 xor %eax,%eax 10a8d1: eb 05 jmp 10a8d8 pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) return EINVAL; 10a8d3: b8 16 00 00 00 mov $0x16,%eax (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10a8d8: 8d 65 f8 lea -0x8(%ebp),%esp 10a8db: 5b pop %ebx 10a8dc: 5e pop %esi 10a8dd: c9 leave 10a8de: c3 ret =============================================================================== 0010b09c : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10b09c: 55 push %ebp 10b09d: 89 e5 mov %esp,%ebp 10b09f: 56 push %esi 10b0a0: 53 push %ebx 10b0a1: 83 ec 10 sub $0x10,%esp 10b0a4: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Error check parameters */ if ( !rwlock ) return EINVAL; 10b0a7: b8 16 00 00 00 mov $0x16,%eax const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10b0ac: 85 db test %ebx,%ebx 10b0ae: 0f 84 8b 00 00 00 je 10b13f return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10b0b4: 8b 75 0c mov 0xc(%ebp),%esi 10b0b7: 85 f6 test %esi,%esi 10b0b9: 75 0f jne 10b0ca the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10b0bb: 83 ec 0c sub $0xc,%esp 10b0be: 8d 75 ec lea -0x14(%ebp),%esi 10b0c1: 56 push %esi 10b0c2: e8 5d 09 00 00 call 10ba24 10b0c7: 83 c4 10 add $0x10,%esp /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) return EINVAL; 10b0ca: b8 16 00 00 00 mov $0x16,%eax } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10b0cf: 83 3e 00 cmpl $0x0,(%esi) 10b0d2: 74 6b je 10b13f <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 10b0d4: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b0d8: 75 65 jne 10b13f <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 10b0da: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b0e1: a1 f0 82 12 00 mov 0x1282f0,%eax 10b0e6: 40 inc %eax 10b0e7: a3 f0 82 12 00 mov %eax,0x1282f0 * the inactive chain of free RWLock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void ) { return (POSIX_RWLock_Control *) _Objects_Allocate( &_POSIX_RWLock_Information ); 10b0ec: 83 ec 0c sub $0xc,%esp 10b0ef: 68 f8 84 12 00 push $0x1284f8 10b0f4: e8 3b 23 00 00 call 10d434 <_Objects_Allocate> 10b0f9: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10b0fb: 83 c4 10 add $0x10,%esp 10b0fe: 85 c0 test %eax,%eax 10b100: 75 0c jne 10b10e _Thread_Enable_dispatch(); 10b102: e8 3b 31 00 00 call 10e242 <_Thread_Enable_dispatch> return EAGAIN; 10b107: b8 0b 00 00 00 mov $0xb,%eax 10b10c: eb 31 jmp 10b13f } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10b10e: 50 push %eax 10b10f: 50 push %eax 10b110: 8d 45 f4 lea -0xc(%ebp),%eax 10b113: 50 push %eax 10b114: 8d 46 10 lea 0x10(%esi),%eax 10b117: 50 push %eax 10b118: e8 7b 1b 00 00 call 10cc98 <_CORE_RWLock_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b11d: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b120: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b123: 8b 15 14 85 12 00 mov 0x128514,%edx 10b129: 89 34 8a mov %esi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10b12c: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10b133: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10b135: e8 08 31 00 00 call 10e242 <_Thread_Enable_dispatch> return 0; 10b13a: 83 c4 10 add $0x10,%esp 10b13d: 31 c0 xor %eax,%eax } 10b13f: 8d 65 f8 lea -0x8(%ebp),%esp 10b142: 5b pop %ebx 10b143: 5e pop %esi 10b144: c9 leave 10b145: c3 ret =============================================================================== 0010b1b0 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b1b0: 55 push %ebp 10b1b1: 89 e5 mov %esp,%ebp 10b1b3: 57 push %edi 10b1b4: 56 push %esi 10b1b5: 53 push %ebx 10b1b6: 83 ec 2c sub $0x2c,%esp 10b1b9: 8b 7d 08 mov 0x8(%ebp),%edi Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) return EINVAL; 10b1bc: bb 16 00 00 00 mov $0x16,%ebx Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10b1c1: 85 ff test %edi,%edi 10b1c3: 0f 84 87 00 00 00 je 10b250 * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10b1c9: 50 push %eax 10b1ca: 50 push %eax 10b1cb: 8d 45 e0 lea -0x20(%ebp),%eax 10b1ce: 50 push %eax 10b1cf: ff 75 0c pushl 0xc(%ebp) 10b1d2: e8 2d 59 00 00 call 110b04 <_POSIX_Absolute_timeout_to_ticks> 10b1d7: 89 c6 mov %eax,%esi 10b1d9: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b1dc: 8d 45 e4 lea -0x1c(%ebp),%eax 10b1df: 50 push %eax 10b1e0: ff 37 pushl (%edi) 10b1e2: 68 f8 84 12 00 push $0x1284f8 10b1e7: e8 78 26 00 00 call 10d864 <_Objects_Get> switch ( location ) { 10b1ec: 83 c4 10 add $0x10,%esp 10b1ef: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b1f3: 75 5b jne 10b250 int _EXFUN(pthread_rwlock_init, (pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr)); int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedrdlock, 10b1f5: 83 fe 03 cmp $0x3,%esi 10b1f8: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10b1fb: 83 ec 0c sub $0xc,%esp 10b1fe: 6a 00 push $0x0 10b200: ff 75 e0 pushl -0x20(%ebp) 10b203: 0f b6 ca movzbl %dl,%ecx 10b206: 51 push %ecx 10b207: ff 37 pushl (%edi) 10b209: 83 c0 10 add $0x10,%eax 10b20c: 50 push %eax 10b20d: 88 55 d4 mov %dl,-0x2c(%ebp) 10b210: e8 b7 1a 00 00 call 10cccc <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b215: 83 c4 20 add $0x20,%esp 10b218: e8 25 30 00 00 call 10e242 <_Thread_Enable_dispatch> if ( !do_wait ) { 10b21d: 8a 55 d4 mov -0x2c(%ebp),%dl 10b220: 84 d2 test %dl,%dl 10b222: 75 17 jne 10b23b if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 10b224: a1 3c 88 12 00 mov 0x12883c,%eax 10b229: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b22d: 75 0c jne 10b23b if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b22f: 85 f6 test %esi,%esi 10b231: 74 1d je 10b250 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b233: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b234: b3 74 mov $0x74,%bl _Thread_Enable_dispatch(); if ( !do_wait ) { if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b236: 83 fe 01 cmp $0x1,%esi 10b239: 76 15 jbe 10b250 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b23b: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b23e: a1 3c 88 12 00 mov 0x12883c,%eax status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b243: ff 70 34 pushl 0x34(%eax) 10b246: e8 bd 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b24b: 89 c3 mov %eax,%ebx 10b24d: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b250: 89 d8 mov %ebx,%eax 10b252: 8d 65 f4 lea -0xc(%ebp),%esp 10b255: 5b pop %ebx 10b256: 5e pop %esi 10b257: 5f pop %edi 10b258: c9 leave 10b259: c3 ret =============================================================================== 0010b25c : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b25c: 55 push %ebp 10b25d: 89 e5 mov %esp,%ebp 10b25f: 57 push %edi 10b260: 56 push %esi 10b261: 53 push %ebx 10b262: 83 ec 2c sub $0x2c,%esp 10b265: 8b 7d 08 mov 0x8(%ebp),%edi Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) return EINVAL; 10b268: bb 16 00 00 00 mov $0x16,%ebx Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10b26d: 85 ff test %edi,%edi 10b26f: 0f 84 87 00 00 00 je 10b2fc * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10b275: 50 push %eax 10b276: 50 push %eax 10b277: 8d 45 e0 lea -0x20(%ebp),%eax 10b27a: 50 push %eax 10b27b: ff 75 0c pushl 0xc(%ebp) 10b27e: e8 81 58 00 00 call 110b04 <_POSIX_Absolute_timeout_to_ticks> 10b283: 89 c6 mov %eax,%esi 10b285: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b288: 8d 45 e4 lea -0x1c(%ebp),%eax 10b28b: 50 push %eax 10b28c: ff 37 pushl (%edi) 10b28e: 68 f8 84 12 00 push $0x1284f8 10b293: e8 cc 25 00 00 call 10d864 <_Objects_Get> switch ( location ) { 10b298: 83 c4 10 add $0x10,%esp 10b29b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b29f: 75 5b jne 10b2fc (pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime)); int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedwrlock, 10b2a1: 83 fe 03 cmp $0x3,%esi 10b2a4: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10b2a7: 83 ec 0c sub $0xc,%esp 10b2aa: 6a 00 push $0x0 10b2ac: ff 75 e0 pushl -0x20(%ebp) 10b2af: 0f b6 ca movzbl %dl,%ecx 10b2b2: 51 push %ecx 10b2b3: ff 37 pushl (%edi) 10b2b5: 83 c0 10 add $0x10,%eax 10b2b8: 50 push %eax 10b2b9: 88 55 d4 mov %dl,-0x2c(%ebp) 10b2bc: e8 c3 1a 00 00 call 10cd84 <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b2c1: 83 c4 20 add $0x20,%esp 10b2c4: e8 79 2f 00 00 call 10e242 <_Thread_Enable_dispatch> if ( !do_wait && 10b2c9: 8a 55 d4 mov -0x2c(%ebp),%dl 10b2cc: 84 d2 test %dl,%dl 10b2ce: 75 17 jne 10b2e7 (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 10b2d0: a1 3c 88 12 00 mov 0x12883c,%eax ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10b2d5: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b2d9: 75 0c jne 10b2e7 (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b2db: 85 f6 test %esi,%esi 10b2dd: 74 1d je 10b2fc <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b2df: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b2e0: b3 74 mov $0x74,%bl _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b2e2: 83 fe 01 cmp $0x1,%esi 10b2e5: 76 15 jbe 10b2fc <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b2e7: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b2ea: a1 3c 88 12 00 mov 0x12883c,%eax if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b2ef: ff 70 34 pushl 0x34(%eax) 10b2f2: e8 11 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b2f7: 89 c3 mov %eax,%ebx 10b2f9: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b2fc: 89 d8 mov %ebx,%eax 10b2fe: 8d 65 f4 lea -0xc(%ebp),%esp 10b301: 5b pop %ebx 10b302: 5e pop %esi 10b303: 5f pop %edi 10b304: c9 leave 10b305: c3 ret =============================================================================== 0010ba44 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10ba44: 55 push %ebp 10ba45: 89 e5 mov %esp,%ebp 10ba47: 8b 55 08 mov 0x8(%ebp),%edx 10ba4a: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr ) return EINVAL; 10ba4d: b8 16 00 00 00 mov $0x16,%eax int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { if ( !attr ) 10ba52: 85 d2 test %edx,%edx 10ba54: 74 0f je 10ba65 return EINVAL; if ( !attr->is_initialized ) 10ba56: 83 3a 00 cmpl $0x0,(%edx) 10ba59: 74 0a je 10ba65 return EINVAL; switch ( pshared ) { 10ba5b: 83 f9 01 cmp $0x1,%ecx 10ba5e: 77 05 ja 10ba65 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10ba60: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10ba63: 30 c0 xor %al,%al default: return EINVAL; } } 10ba65: c9 leave 10ba66: c3 ret =============================================================================== 0010c754 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10c754: 55 push %ebp 10c755: 89 e5 mov %esp,%ebp 10c757: 57 push %edi 10c758: 56 push %esi 10c759: 53 push %ebx 10c75a: 83 ec 2c sub $0x2c,%esp 10c75d: 8b 75 10 mov 0x10(%ebp),%esi /* * Check all the parameters */ if ( !param ) return EINVAL; 10c760: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp) int rc; /* * Check all the parameters */ if ( !param ) 10c767: 85 f6 test %esi,%esi 10c769: 0f 84 00 01 00 00 je 10c86f return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 10c76f: 8d 45 e0 lea -0x20(%ebp),%eax 10c772: 50 push %eax 10c773: 8d 45 e4 lea -0x1c(%ebp),%eax 10c776: 50 push %eax 10c777: 56 push %esi 10c778: ff 75 0c pushl 0xc(%ebp) 10c77b: e8 e4 52 00 00 call 111a64 <_POSIX_Thread_Translate_sched_param> 10c780: 89 45 d4 mov %eax,-0x2c(%ebp) policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 10c783: 83 c4 10 add $0x10,%esp 10c786: 85 c0 test %eax,%eax 10c788: 0f 85 e1 00 00 00 jne 10c86f 10c78e: 53 push %ebx return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); 10c78f: 8d 45 dc lea -0x24(%ebp),%eax 10c792: 50 push %eax 10c793: ff 75 08 pushl 0x8(%ebp) 10c796: 68 78 95 12 00 push $0x129578 10c79b: e8 8c 1c 00 00 call 10e42c <_Objects_Get> 10c7a0: 89 c2 mov %eax,%edx switch ( location ) { 10c7a2: 83 c4 10 add $0x10,%esp 10c7a5: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) 10c7a9: 0f 85 b9 00 00 00 jne 10c868 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c7af: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx if ( api->schedpolicy == SCHED_SPORADIC ) 10c7b5: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx) 10c7bc: 75 18 jne 10c7d6 (void) _Watchdog_Remove( &api->Sporadic_timer ); 10c7be: 83 ec 0c sub $0xc,%esp 10c7c1: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax 10c7c7: 50 push %eax 10c7c8: 89 55 d0 mov %edx,-0x30(%ebp) 10c7cb: e8 28 35 00 00 call 10fcf8 <_Watchdog_Remove> 10c7d0: 83 c4 10 add $0x10,%esp 10c7d3: 8b 55 d0 mov -0x30(%ebp),%edx api->schedpolicy = policy; 10c7d6: 8b 45 0c mov 0xc(%ebp),%eax 10c7d9: 89 83 84 00 00 00 mov %eax,0x84(%ebx) api->schedparam = *param; 10c7df: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 10c7e5: b9 07 00 00 00 mov $0x7,%ecx 10c7ea: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10c7ec: 8b 45 e4 mov -0x1c(%ebp),%eax 10c7ef: 89 42 7c mov %eax,0x7c(%edx) the_thread->budget_callout = budget_callout; 10c7f2: 8b 45 e0 mov -0x20(%ebp),%eax 10c7f5: 89 82 80 00 00 00 mov %eax,0x80(%edx) switch ( api->schedpolicy ) { 10c7fb: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10c7ff: 78 60 js 10c861 <== NEVER TAKEN 10c801: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10c805: 7e 08 jle 10c80f 10c807: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10c80b: 75 54 jne 10c861 <== NEVER TAKEN 10c80d: eb 24 jmp 10c833 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c80f: a1 00 93 12 00 mov 0x129300,%eax 10c814: 89 42 78 mov %eax,0x78(%edx) 10c817: 0f b6 05 18 52 12 00 movzbl 0x125218,%eax 10c81e: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax the_thread->real_priority = 10c824: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10c827: 51 push %ecx 10c828: 6a 01 push $0x1 10c82a: 50 push %eax 10c82b: 52 push %edx 10c82c: e8 93 21 00 00 call 10e9c4 <_Thread_Change_priority> 10c831: eb 2b jmp 10c85e true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10c833: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10c839: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) _Watchdog_Remove( &api->Sporadic_timer ); 10c83f: 83 ec 0c sub $0xc,%esp 10c842: 81 c3 a8 00 00 00 add $0xa8,%ebx 10c848: 53 push %ebx 10c849: 89 55 d0 mov %edx,-0x30(%ebp) 10c84c: e8 a7 34 00 00 call 10fcf8 <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10c851: 58 pop %eax 10c852: 5a pop %edx 10c853: 8b 55 d0 mov -0x30(%ebp),%edx 10c856: 52 push %edx 10c857: 6a 00 push $0x0 10c859: e8 e1 fd ff ff call 10c63f <_POSIX_Threads_Sporadic_budget_TSR> break; 10c85e: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10c861: e8 a4 25 00 00 call 10ee0a <_Thread_Enable_dispatch> return 0; 10c866: eb 07 jmp 10c86f #endif case OBJECTS_ERROR: break; } return ESRCH; 10c868: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp) } 10c86f: 8b 45 d4 mov -0x2c(%ebp),%eax 10c872: 8d 65 f4 lea -0xc(%ebp),%esp 10c875: 5b pop %ebx 10c876: 5e pop %esi 10c877: 5f pop %edi 10c878: c9 leave 10c879: c3 ret =============================================================================== 0010a640 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a640: 55 push %ebp 10a641: 89 e5 mov %esp,%ebp 10a643: 53 push %ebx 10a644: 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() ) 10a647: 83 3d 10 68 12 00 00 cmpl $0x0,0x126810 10a64e: 75 48 jne 10a698 <== NEVER TAKEN return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a650: a1 14 68 12 00 mov 0x126814,%eax 10a655: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10a65b: 8b 15 c8 62 12 00 mov 0x1262c8,%edx 10a661: 42 inc %edx 10a662: 89 15 c8 62 12 00 mov %edx,0x1262c8 */ void pthread_testcancel( void ) { POSIX_API_Control *thread_support; bool cancel = false; 10a668: 31 db xor %ebx,%ebx return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a66a: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10a671: 75 0a jne 10a67d <== NEVER TAKEN /* 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)); 10a673: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10a67a: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a67d: e8 1c 25 00 00 call 10cb9e <_Thread_Enable_dispatch> if ( cancel ) 10a682: 84 db test %bl,%bl 10a684: 74 12 je 10a698 _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a686: 50 push %eax 10a687: 50 push %eax 10a688: 6a ff push $0xffffffff 10a68a: ff 35 14 68 12 00 pushl 0x126814 10a690: e8 7f 52 00 00 call 10f914 <_POSIX_Thread_Exit> 10a695: 83 c4 10 add $0x10,%esp } 10a698: 8b 5d fc mov -0x4(%ebp),%ebx 10a69b: c9 leave 10a69c: c3 ret =============================================================================== 0010af11 : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10af11: 55 push %ebp 10af12: 89 e5 mov %esp,%ebp 10af14: 57 push %edi 10af15: 56 push %esi 10af16: 53 push %ebx 10af17: 83 ec 58 sub $0x58,%esp 10af1a: 8b 5d 08 mov 0x8(%ebp),%ebx struct sched_param param; /* The queue should be initialized */ AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED); result = pthread_mutex_lock (&aio_request_queue.mutex); 10af1d: 68 78 72 12 00 push $0x127278 10af22: e8 bd 08 00 00 call 10b7e4 10af27: 89 45 b4 mov %eax,-0x4c(%ebp) if (result != 0) { 10af2a: 83 c4 10 add $0x10,%esp 10af2d: 85 c0 test %eax,%eax 10af2f: 74 0e je 10af3f <== ALWAYS TAKEN free (req); 10af31: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af34: 53 push %ebx <== NOT EXECUTED 10af35: e8 06 ce ff ff call 107d40 <== NOT EXECUTED 10af3a: e9 bf 01 00 00 jmp 10b0fe <== NOT EXECUTED return result; } /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined, we can use aio_reqprio to lower the priority of the request */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10af3f: e8 a0 10 00 00 call 10bfe4 10af44: 57 push %edi 10af45: 8d 55 c4 lea -0x3c(%ebp),%edx 10af48: 52 push %edx 10af49: 8d 55 e0 lea -0x20(%ebp),%edx 10af4c: 52 push %edx 10af4d: 50 push %eax 10af4e: e8 95 0c 00 00 call 10bbe8 req->caller_thread = pthread_self (); 10af53: e8 8c 10 00 00 call 10bfe4 10af58: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10af5b: 8b 43 14 mov 0x14(%ebx),%eax 10af5e: 8b 55 c4 mov -0x3c(%ebp),%edx 10af61: 2b 50 14 sub 0x14(%eax),%edx 10af64: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10af67: 8b 55 e0 mov -0x20(%ebp),%edx 10af6a: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10af6d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10af74: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10af7b: 83 c4 10 add $0x10,%esp 10af7e: 83 3d e0 72 12 00 00 cmpl $0x0,0x1272e0 10af85: 0f 85 b7 00 00 00 jne 10b042 10af8b: 83 3d dc 72 12 00 04 cmpl $0x4,0x1272dc 10af92: 0f 8f aa 00 00 00 jg 10b042 aio_request_queue.active_threads < AIO_MAX_THREADS) /* we still have empty places on the active_threads chain */ { chain = &aio_request_queue.work_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10af98: 56 push %esi 10af99: 6a 01 push $0x1 10af9b: ff 30 pushl (%eax) 10af9d: 68 c0 72 12 00 push $0x1272c0 10afa2: e8 99 fb ff ff call 10ab40 10afa7: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10afa9: 83 c4 10 add $0x10,%esp 10afac: 83 78 18 01 cmpl $0x1,0x18(%eax) 10afb0: 8d 50 08 lea 0x8(%eax),%edx 10afb3: 8d 78 1c lea 0x1c(%eax),%edi 10afb6: 8d 40 20 lea 0x20(%eax),%eax 10afb9: 89 45 b0 mov %eax,-0x50(%ebp) 10afbc: 75 66 jne 10b024 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10afbe: 51 push %ecx 10afbf: 51 push %ecx 10afc0: 53 push %ebx 10afc1: 52 push %edx 10afc2: e8 c1 1f 00 00 call 10cf88 <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10afc7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10afce: 5b pop %ebx 10afcf: 58 pop %eax 10afd0: 6a 00 push $0x0 10afd2: 57 push %edi 10afd3: e8 ec 06 00 00 call 10b6c4 pthread_cond_init (&r_chain->cond, NULL); 10afd8: 5a pop %edx 10afd9: 59 pop %ecx 10afda: 6a 00 push $0x0 10afdc: ff 75 b0 pushl -0x50(%ebp) 10afdf: e8 a0 03 00 00 call 10b384 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10afe4: 56 push %esi 10afe5: 68 eb ab 10 00 push $0x10abeb 10afea: 68 80 72 12 00 push $0x127280 10afef: 8d 45 e4 lea -0x1c(%ebp),%eax 10aff2: 50 push %eax 10aff3: e8 bc 09 00 00 call 10b9b4 10aff8: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10affa: 83 c4 20 add $0x20,%esp 10affd: 85 c0 test %eax,%eax 10afff: 74 18 je 10b019 <== ALWAYS TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10b001: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b004: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10b009: e8 56 08 00 00 call 10b864 <== NOT EXECUTED return result; 10b00e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b011: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED 10b014: e9 e8 00 00 00 jmp 10b101 <== NOT EXECUTED } ++aio_request_queue.active_threads; 10b019: ff 05 dc 72 12 00 incl 0x1272dc 10b01f: e9 cd 00 00 00 jmp 10b0f1 } else { /* put request in the fd chain it belongs to */ pthread_mutex_lock (&r_chain->mutex); 10b024: 83 ec 0c sub $0xc,%esp 10b027: 57 push %edi 10b028: 89 55 ac mov %edx,-0x54(%ebp) 10b02b: e8 b4 07 00 00 call 10b7e4 rtems_aio_insert_prio (&r_chain->perfd, req); 10b030: 5e pop %esi 10b031: 58 pop %eax 10b032: 53 push %ebx 10b033: 8b 55 ac mov -0x54(%ebp),%edx 10b036: 52 push %edx 10b037: e8 00 fe ff ff call 10ae3c pthread_cond_signal (&r_chain->cond); 10b03c: 5b pop %ebx 10b03d: ff 75 b0 pushl -0x50(%ebp) 10b040: eb 36 jmp 10b078 else { /* the maximum number of threads has been already created even though some of them might be idle. The request belongs to one of the active fd chain */ r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10b042: 51 push %ecx 10b043: 6a 00 push $0x0 10b045: ff 30 pushl (%eax) 10b047: 68 c0 72 12 00 push $0x1272c0 10b04c: e8 ef fa ff ff call 10ab40 10b051: 89 c6 mov %eax,%esi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10b053: 83 c4 10 add $0x10,%esp 10b056: 85 c0 test %eax,%eax 10b058: 74 2d je 10b087 <== ALWAYS TAKEN { pthread_mutex_lock (&r_chain->mutex); 10b05a: 8d 78 1c lea 0x1c(%eax),%edi <== NOT EXECUTED 10b05d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b060: 57 push %edi <== NOT EXECUTED 10b061: e8 7e 07 00 00 call 10b7e4 <== NOT EXECUTED rtems_aio_insert_prio (&r_chain->perfd, req); 10b066: 58 pop %eax <== NOT EXECUTED 10b067: 5a pop %edx <== NOT EXECUTED 10b068: 53 push %ebx <== NOT EXECUTED 10b069: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 10b06c: 50 push %eax <== NOT EXECUTED 10b06d: e8 ca fd ff ff call 10ae3c <== NOT EXECUTED pthread_cond_signal (&r_chain->cond); 10b072: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10b075: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10b078: e8 a3 03 00 00 call 10b420 pthread_mutex_unlock (&r_chain->mutex); 10b07d: 89 3c 24 mov %edi,(%esp) 10b080: e8 df 07 00 00 call 10b864 10b085: eb 67 jmp 10b0ee } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10b087: 56 push %esi 10b088: 6a 01 push $0x1 10b08a: 8b 43 14 mov 0x14(%ebx),%eax 10b08d: ff 30 pushl (%eax) 10b08f: 68 cc 72 12 00 push $0x1272cc 10b094: e8 a7 fa ff ff call 10ab40 10b099: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10b09b: 83 c4 10 add $0x10,%esp 10b09e: 83 78 18 01 cmpl $0x1,0x18(%eax) 10b0a2: 8d 40 08 lea 0x8(%eax),%eax 10b0a5: 75 3e jne 10b0e5 10b0a7: 51 push %ecx 10b0a8: 51 push %ecx 10b0a9: 53 push %ebx 10b0aa: 50 push %eax 10b0ab: e8 d8 1e 00 00 call 10cf88 <_Chain_Insert> /* If this is a new fd chain we signal the idle threads that might be waiting for requests */ AIO_printf (" New chain on waiting queue \n "); rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10b0b0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10b0b7: 58 pop %eax 10b0b8: 5a pop %edx 10b0b9: 6a 00 push $0x0 10b0bb: 8d 46 1c lea 0x1c(%esi),%eax 10b0be: 50 push %eax 10b0bf: e8 00 06 00 00 call 10b6c4 pthread_cond_init (&r_chain->cond, NULL); 10b0c4: 5b pop %ebx 10b0c5: 5f pop %edi 10b0c6: 6a 00 push $0x0 10b0c8: 83 c6 20 add $0x20,%esi 10b0cb: 56 push %esi 10b0cc: e8 b3 02 00 00 call 10b384 pthread_cond_signal (&aio_request_queue.new_req); 10b0d1: c7 04 24 7c 72 12 00 movl $0x12727c,(%esp) 10b0d8: e8 43 03 00 00 call 10b420 ++aio_request_queue.idle_threads; 10b0dd: ff 05 e0 72 12 00 incl 0x1272e0 10b0e3: eb 09 jmp 10b0ee } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10b0e5: 51 push %ecx 10b0e6: 51 push %ecx 10b0e7: 53 push %ebx 10b0e8: 50 push %eax 10b0e9: e8 4e fd ff ff call 10ae3c 10b0ee: 83 c4 10 add $0x10,%esp } } pthread_mutex_unlock (&aio_request_queue.mutex); 10b0f1: 83 ec 0c sub $0xc,%esp 10b0f4: 68 78 72 12 00 push $0x127278 10b0f9: e8 66 07 00 00 call 10b864 return 0; 10b0fe: 83 c4 10 add $0x10,%esp } 10b101: 8b 45 b4 mov -0x4c(%ebp),%eax 10b104: 8d 65 f4 lea -0xc(%ebp),%esp 10b107: 5b pop %ebx 10b108: 5e pop %esi 10b109: 5f pop %edi 10b10a: c9 leave 10b10b: c3 ret =============================================================================== 0010abeb : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10abeb: 55 push %ebp <== NOT EXECUTED 10abec: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abee: 57 push %edi <== NOT EXECUTED 10abef: 56 push %esi <== NOT EXECUTED 10abf0: 53 push %ebx <== NOT EXECUTED 10abf1: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED rtems_aio_request_chain *r_chain = arg; 10abf4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* acquire the mutex of the current fd chain. we don't need to lock the queue mutex since we can add requests to idle fd chains or even active ones if the working request has been extracted from the chain */ result = pthread_mutex_lock (&r_chain->mutex); 10abf7: 8d 7b 1c lea 0x1c(%ebx),%edi <== NOT EXECUTED 10abfa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10abfd: 57 push %edi <== NOT EXECUTED 10abfe: e8 e1 0b 00 00 call 10b7e4 <== NOT EXECUTED if (result != 0) 10ac03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac06: 85 c0 test %eax,%eax <== NOT EXECUTED 10ac08: 0f 85 24 02 00 00 jne 10ae32 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10ac0e: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10ac11: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED /* If the locked chain is not empty, take the first request extract it, unlock the chain and process the request, in this way the user can supply more requests to this fd chain */ if (!rtems_chain_is_empty (chain)) { 10ac14: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10ac16: 0f 84 cc 00 00 00 je 10ace8 <== NOT EXECUTED node = rtems_chain_first (chain); req = (rtems_aio_request *) node; /* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING discussion in rtems_aio_enqueue () */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10ac1c: e8 c3 13 00 00 call 10bfe4 <== NOT EXECUTED 10ac21: 52 push %edx <== NOT EXECUTED 10ac22: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED 10ac25: 52 push %edx <== NOT EXECUTED 10ac26: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED 10ac29: 51 push %ecx <== NOT EXECUTED 10ac2a: 50 push %eax <== NOT EXECUTED 10ac2b: e8 b8 0f 00 00 call 10bbe8 <== NOT EXECUTED param.sched_priority = req->priority; 10ac30: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 10ac33: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED pthread_setschedparam (pthread_self(), req->policy, ¶m); 10ac36: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED 10ac39: 89 55 b4 mov %edx,-0x4c(%ebp) <== NOT EXECUTED 10ac3c: e8 a3 13 00 00 call 10bfe4 <== NOT EXECUTED 10ac41: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ac44: 8d 4d c0 lea -0x40(%ebp),%ecx <== NOT EXECUTED 10ac47: 51 push %ecx <== NOT EXECUTED 10ac48: 8b 55 b4 mov -0x4c(%ebp),%edx <== NOT EXECUTED 10ac4b: 52 push %edx <== NOT EXECUTED 10ac4c: 50 push %eax <== NOT EXECUTED 10ac4d: e8 a2 13 00 00 call 10bff4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10ac52: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10ac55: e8 f2 22 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10ac5a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10ac5d: e8 02 0c 00 00 call 10b864 <== NOT EXECUTED switch (req->aiocbp->aio_lio_opcode) { 10ac62: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10ac65: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac68: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED 10ac6b: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10ac6e: 74 20 je 10ac90 <== NOT EXECUTED 10ac70: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10ac73: 74 36 je 10acab <== NOT EXECUTED 10ac75: 4a dec %edx <== NOT EXECUTED 10ac76: 75 45 jne 10acbd <== NOT EXECUTED case LIO_READ: result = pread (req->aiocbp->aio_fildes, 10ac78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac7b: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ac7e: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10ac81: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED 10ac84: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10ac87: ff 30 pushl (%eax) <== NOT EXECUTED 10ac89: e8 7e 94 00 00 call 11410c <== NOT EXECUTED 10ac8e: eb 16 jmp 10aca6 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: result = pwrite (req->aiocbp->aio_fildes, 10ac90: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac93: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ac96: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10ac99: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED 10ac9c: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10ac9f: ff 30 pushl (%eax) <== NOT EXECUTED 10aca1: e8 1e 95 00 00 call 1141c4 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10aca6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10aca9: eb 0d jmp 10acb8 <== NOT EXECUTED case LIO_SYNC: result = fsync (req->aiocbp->aio_fildes); 10acab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10acae: ff 30 pushl (%eax) <== NOT EXECUTED 10acb0: e8 07 5d 00 00 call 1109bc <== NOT EXECUTED break; 10acb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: result = -1; } if (result == -1) { 10acb8: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10acbb: 75 19 jne 10acd6 <== NOT EXECUTED req->aiocbp->return_value = -1; 10acbd: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10acc0: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10acc7: e8 04 8a 00 00 call 1136d0 <__errno> <== NOT EXECUTED 10accc: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10acce: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10acd1: e9 21 ff ff ff jmp 10abf7 <== NOT EXECUTED } else { req->aiocbp->return_value = result; 10acd6: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED 10acd9: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED req->aiocbp->error_code = 0; 10acdc: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED 10ace3: e9 0f ff ff ff jmp 10abf7 <== NOT EXECUTED wait for a signal on chain, this will unlock the queue. The fd chain is already unlocked */ struct timespec timeout; pthread_mutex_unlock (&r_chain->mutex); 10ace8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aceb: 57 push %edi <== NOT EXECUTED 10acec: e8 73 0b 00 00 call 10b864 <== NOT EXECUTED pthread_mutex_lock (&aio_request_queue.mutex); 10acf1: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED 10acf8: e8 e7 0a 00 00 call 10b7e4 <== NOT EXECUTED if (rtems_chain_is_empty (chain)) 10acfd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad00: 39 73 08 cmp %esi,0x8(%ebx) <== NOT EXECUTED 10ad03: 0f 85 ee fe ff ff jne 10abf7 <== NOT EXECUTED { clock_gettime (CLOCK_REALTIME, &timeout); 10ad09: 56 push %esi <== NOT EXECUTED 10ad0a: 56 push %esi <== NOT EXECUTED 10ad0b: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10ad0e: 50 push %eax <== NOT EXECUTED 10ad0f: 6a 01 push $0x1 <== NOT EXECUTED 10ad11: e8 5e 05 00 00 call 10b274 <== NOT EXECUTED timeout.tv_sec += 3; 10ad16: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10ad1a: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&r_chain->cond, 10ad21: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10ad24: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad27: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED 10ad2a: 52 push %edx <== NOT EXECUTED 10ad2b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ad30: 56 push %esi <== NOT EXECUTED 10ad31: e8 5a 07 00 00 call 10b490 <== NOT EXECUTED &aio_request_queue.mutex, &timeout); /* If no requests were added to the chain we delete the fd chain from the queue and start working with idle fd chains */ if (result == ETIMEDOUT) { 10ad36: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad39: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10ad3c: 0f 85 b5 fe ff ff jne 10abf7 <== NOT EXECUTED 10ad42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad45: 53 push %ebx <== NOT EXECUTED 10ad46: e8 01 22 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10ad4b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10ad4e: e8 71 08 00 00 call 10b5c4 <== NOT EXECUTED pthread_cond_destroy (&r_chain->cond); 10ad53: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10ad56: e8 75 05 00 00 call 10b2d0 <== NOT EXECUTED free (r_chain); 10ad5b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ad5e: e8 dd cf ff ff call 107d40 <== NOT EXECUTED /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10ad63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad66: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED 10ad6d: 72 12 00 10ad70: 0f 85 a7 00 00 00 jne 10ae1d <== NOT EXECUTED ++aio_request_queue.idle_threads; 10ad76: ff 05 e0 72 12 00 incl 0x1272e0 <== NOT EXECUTED clock_gettime (CLOCK_REALTIME, &timeout); 10ad7c: 53 push %ebx <== NOT EXECUTED 10ad7d: 53 push %ebx <== NOT EXECUTED 10ad7e: 8d 4d dc lea -0x24(%ebp),%ecx <== NOT EXECUTED 10ad81: 51 push %ecx <== NOT EXECUTED 10ad82: 6a 01 push $0x1 <== NOT EXECUTED 10ad84: e8 eb 04 00 00 call 10b274 <== NOT EXECUTED timeout.tv_sec += 3; 10ad89: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10ad8d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&aio_request_queue.new_req, 10ad94: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad97: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10ad9a: 50 push %eax <== NOT EXECUTED 10ad9b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ada0: 68 7c 72 12 00 push $0x12727c <== NOT EXECUTED 10ada5: e8 e6 06 00 00 call 10b490 <== NOT EXECUTED &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 10adaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adad: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10adb0: 75 12 jne 10adc4 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10adb2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adb5: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10adba: e8 a5 0a 00 00 call 10b864 <== NOT EXECUTED return NULL; 10adbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adc2: eb 6e jmp 10ae32 <== NOT EXECUTED } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; 10adc4: ff 0d e0 72 12 00 decl 0x1272e0 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10adca: 8b 35 cc 72 12 00 mov 0x1272cc,%esi <== NOT EXECUTED 10add0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10add3: 56 push %esi <== NOT EXECUTED 10add4: e8 73 21 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10add9: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10addc: 6a 01 push $0x1 <== NOT EXECUTED 10adde: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 10ade1: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10ade6: e8 55 fd ff ff call 10ab40 <== NOT EXECUTED 10adeb: 89 c3 mov %eax,%ebx <== NOT EXECUTED ((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; 10aded: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED pthread_mutex_init (&r_chain->mutex, NULL); 10adf4: 5a pop %edx <== NOT EXECUTED 10adf5: 59 pop %ecx <== NOT EXECUTED 10adf6: 6a 00 push $0x0 <== NOT EXECUTED 10adf8: 8d 40 1c lea 0x1c(%eax),%eax <== NOT EXECUTED 10adfb: 50 push %eax <== NOT EXECUTED 10adfc: e8 c3 08 00 00 call 10b6c4 <== NOT EXECUTED pthread_cond_init (&r_chain->cond, NULL); 10ae01: 5f pop %edi <== NOT EXECUTED 10ae02: 58 pop %eax <== NOT EXECUTED 10ae03: 6a 00 push $0x0 <== NOT EXECUTED 10ae05: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10ae08: 50 push %eax <== NOT EXECUTED 10ae09: e8 76 05 00 00 call 10b384 <== NOT EXECUTED r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; 10ae0e: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED 10ae11: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 10ae14: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10ae19: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10ae1b: eb 0d jmp 10ae2a <== NOT EXECUTED } else /* If there was a request added in the initial fd chain then release the mutex and process it */ pthread_mutex_unlock (&aio_request_queue.mutex); 10ae1d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae20: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ae25: e8 3a 0a 00 00 call 10b864 <== NOT EXECUTED 10ae2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae2d: e9 c5 fd ff ff jmp 10abf7 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10ae32: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ae34: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae37: 5b pop %ebx <== NOT EXECUTED 10ae38: 5e pop %esi <== NOT EXECUTED 10ae39: 5f pop %edi <== NOT EXECUTED 10ae3a: c9 leave <== NOT EXECUTED 10ae3b: c3 ret <== NOT EXECUTED =============================================================================== 0010aa44 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10aa44: 55 push %ebp 10aa45: 89 e5 mov %esp,%ebp 10aa47: 53 push %ebx 10aa48: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10aa4b: 68 80 72 12 00 push $0x127280 10aa50: e8 13 0f 00 00 call 10b968 10aa55: 89 c3 mov %eax,%ebx if (result != 0) 10aa57: 83 c4 10 add $0x10,%esp 10aa5a: 85 c0 test %eax,%eax 10aa5c: 0f 85 d7 00 00 00 jne 10ab39 <== NEVER TAKEN return result; result = 10aa62: 51 push %ecx 10aa63: 51 push %ecx 10aa64: 6a 00 push $0x0 10aa66: 68 80 72 12 00 push $0x127280 10aa6b: e8 20 0f 00 00 call 10b990 pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10aa70: 83 c4 10 add $0x10,%esp 10aa73: 85 c0 test %eax,%eax 10aa75: 74 10 je 10aa87 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aa77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa7a: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED 10aa7f: e8 c4 0e 00 00 call 10b948 <== NOT EXECUTED 10aa84: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10aa87: 52 push %edx 10aa88: 52 push %edx 10aa89: 6a 00 push $0x0 10aa8b: 68 78 72 12 00 push $0x127278 10aa90: e8 2f 0c 00 00 call 10b6c4 if (result != 0) 10aa95: 83 c4 10 add $0x10,%esp 10aa98: 85 c0 test %eax,%eax 10aa9a: 74 10 je 10aaac <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aa9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa9f: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED 10aaa4: e8 9f 0e 00 00 call 10b948 <== NOT EXECUTED 10aaa9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10aaac: 50 push %eax 10aaad: 50 push %eax 10aaae: 6a 00 push $0x0 10aab0: 68 7c 72 12 00 push $0x12727c 10aab5: e8 ca 08 00 00 call 10b384 10aaba: 89 c3 mov %eax,%ebx if (result != 0) { 10aabc: 83 c4 10 add $0x10,%esp 10aabf: 85 c0 test %eax,%eax 10aac1: 74 1c je 10aadf <== ALWAYS TAKEN pthread_mutex_destroy (&aio_request_queue.mutex); 10aac3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aac6: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10aacb: e8 f4 0a 00 00 call 10b5c4 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10aad0: c7 04 24 80 72 12 00 movl $0x127280,(%esp) <== NOT EXECUTED 10aad7: e8 6c 0e 00 00 call 10b948 <== NOT EXECUTED 10aadc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10aadf: c7 05 c0 72 12 00 c4 movl $0x1272c4,0x1272c0 10aae6: 72 12 00 head->previous = NULL; 10aae9: c7 05 c4 72 12 00 00 movl $0x0,0x1272c4 10aaf0: 00 00 00 tail->previous = head; 10aaf3: c7 05 c8 72 12 00 c0 movl $0x1272c0,0x1272c8 10aafa: 72 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10aafd: c7 05 cc 72 12 00 d0 movl $0x1272d0,0x1272cc 10ab04: 72 12 00 head->previous = NULL; 10ab07: c7 05 d0 72 12 00 00 movl $0x0,0x1272d0 10ab0e: 00 00 00 tail->previous = head; 10ab11: c7 05 d4 72 12 00 cc movl $0x1272cc,0x1272d4 10ab18: 72 12 00 } rtems_chain_initialize_empty (&aio_request_queue.work_req); rtems_chain_initialize_empty (&aio_request_queue.idle_req); aio_request_queue.active_threads = 0; 10ab1b: c7 05 dc 72 12 00 00 movl $0x0,0x1272dc 10ab22: 00 00 00 aio_request_queue.idle_threads = 0; 10ab25: c7 05 e0 72 12 00 00 movl $0x0,0x1272e0 10ab2c: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10ab2f: c7 05 d8 72 12 00 0b movl $0xb00b,0x1272d8 10ab36: b0 00 00 return result; } 10ab39: 89 d8 mov %ebx,%eax 10ab3b: 8b 5d fc mov -0x4(%ebp),%ebx 10ab3e: c9 leave 10ab3f: c3 ret =============================================================================== 0010ae3c : * NONE */ void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10ae3c: 55 push %ebp 10ae3d: 89 e5 mov %esp,%ebp 10ae3f: 56 push %esi 10ae40: 53 push %ebx 10ae41: 8b 4d 08 mov 0x8(%ebp),%ecx 10ae44: 8b 55 0c mov 0xc(%ebp),%edx } AIO_printf ("Thread finished\n"); return NULL; } 10ae47: 8b 01 mov (%ecx),%eax 10ae49: 8d 59 04 lea 0x4(%ecx),%ebx rtems_chain_node *node; AIO_printf ("FD exists \n"); node = rtems_chain_first (chain); if (rtems_chain_is_empty (chain)) { 10ae4c: 39 d8 cmp %ebx,%eax 10ae4e: 74 27 je 10ae77 <== NEVER TAKEN AIO_printf ("First in chain \n"); rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 10ae50: 8b 48 14 mov 0x14(%eax),%ecx 10ae53: 8b 49 14 mov 0x14(%ecx),%ecx while (req->aiocbp->aio_reqprio > prio && 10ae56: 8b 72 14 mov 0x14(%edx),%esi 10ae59: 8b 76 14 mov 0x14(%esi),%esi 10ae5c: eb 08 jmp 10ae66 } AIO_printf ("Thread finished\n"); return NULL; } 10ae5e: 8b 00 mov (%eax),%eax <== NOT EXECUTED int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && !rtems_chain_is_tail (chain, node)) { node = rtems_chain_next (node); prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 10ae60: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10ae63: 8b 49 14 mov 0x14(%ecx),%ecx <== NOT EXECUTED rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && 10ae66: 39 ce cmp %ecx,%esi 10ae68: 7e 04 jle 10ae6e <== ALWAYS TAKEN 10ae6a: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10ae6c: 75 f0 jne 10ae5e <== NOT EXECUTED RTEMS_INLINE_ROUTINE void rtems_chain_insert( rtems_chain_node *after_node, rtems_chain_node *the_node ) { _Chain_Insert( after_node, the_node ); 10ae6e: 89 55 0c mov %edx,0xc(%ebp) 10ae71: 8b 40 04 mov 0x4(%eax),%eax 10ae74: 89 45 08 mov %eax,0x8(%ebp) } rtems_chain_insert (node->previous, &req->next_prio); } } 10ae77: 5b pop %ebx 10ae78: 5e pop %esi 10ae79: c9 leave 10ae7a: e9 09 21 00 00 jmp 10cf88 <_Chain_Insert> =============================================================================== 0010ae7f : * Output parameters: * NONE */ void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain) { 10ae7f: 55 push %ebp <== NOT EXECUTED 10ae80: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae82: 56 push %esi <== NOT EXECUTED 10ae83: 53 push %ebx <== NOT EXECUTED 10ae84: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10ae87: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10ae8a: 8d 70 0c lea 0xc(%eax),%esi <== NOT EXECUTED rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 10ae8d: eb 25 jmp 10aeb4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10ae8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae92: 53 push %ebx <== NOT EXECUTED 10ae93: e8 b4 20 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED { rtems_chain_extract (node); rtems_aio_request *req = (rtems_aio_request *) node; req->aiocbp->error_code = ECANCELED; 10ae98: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 10ae9b: c7 42 30 8c 00 00 00 movl $0x8c,0x30(%edx) <== NOT EXECUTED req->aiocbp->return_value = -1; 10aea2: c7 42 34 ff ff ff ff movl $0xffffffff,0x34(%edx) <== NOT EXECUTED free (req); 10aea9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10aeac: e8 8f ce ff ff call 107d40 <== NOT EXECUTED 10aeb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 10aeb4: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 10aeb6: 75 d7 jne 10ae8f <== NOT EXECUTED rtems_aio_request *req = (rtems_aio_request *) node; req->aiocbp->error_code = ECANCELED; req->aiocbp->return_value = -1; free (req); } } 10aeb8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aebb: 5b pop %ebx <== NOT EXECUTED 10aebc: 5e pop %esi <== NOT EXECUTED 10aebd: c9 leave <== NOT EXECUTED 10aebe: c3 ret <== NOT EXECUTED =============================================================================== 0010aebf : * AIO_NOTCANCELED - if request was not canceled * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { 10aebf: 55 push %ebp <== NOT EXECUTED 10aec0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aec2: 53 push %ebx <== NOT EXECUTED 10aec3: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10aec6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aec9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10aecc: 8b 18 mov (%eax),%ebx <== NOT EXECUTED 10aece: 83 c0 04 add $0x4,%eax <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10aed1: eb 02 jmp 10aed5 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10aed3: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10aed5: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10aed7: 74 2e je 10af07 <== NOT EXECUTED 10aed9: 39 53 14 cmp %edx,0x14(%ebx) <== NOT EXECUTED 10aedc: 75 f5 jne 10aed3 <== NOT EXECUTED 10aede: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aee1: 53 push %ebx <== NOT EXECUTED 10aee2: e8 65 20 00 00 call 10cf4c <_Chain_Extract> <== NOT EXECUTED if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10aee7: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10aeea: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) <== NOT EXECUTED current->aiocbp->return_value = -1; 10aef1: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) <== NOT EXECUTED free (current); 10aef8: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10aefb: e8 40 ce ff ff call 107d40 <== NOT EXECUTED } return AIO_CANCELED; 10af00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af03: 31 c0 xor %eax,%eax <== NOT EXECUTED 10af05: eb 05 jmp 10af0c <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10af07: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10af0c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af0f: c9 leave <== NOT EXECUTED 10af10: c3 ret <== NOT EXECUTED =============================================================================== 0010ab40 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10ab40: 55 push %ebp 10ab41: 89 e5 mov %esp,%ebp 10ab43: 56 push %esi 10ab44: 53 push %ebx 10ab45: 8b 5d 10 mov 0x10(%ebp),%ebx 10ab48: 8b 75 14 mov 0x14(%ebp),%esi RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check( rtems_chain_control *chain, rtems_chain_node *node ) { return _Chain_Append_with_empty_check( chain, node ); 10ab4b: 50 push %eax 10ab4c: 50 push %eax 10ab4d: ff 75 0c pushl 0xc(%ebp) 10ab50: ff 75 08 pushl 0x8(%ebp) 10ab53: e8 8c 04 00 00 call 10afe4 <_Chain_Append_with_empty_check> rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { 10ab58: 83 c4 10 add $0x10,%esp 10ab5b: 84 c0 test %al,%al 10ab5d: 74 11 je 10ab70 <== NEVER TAKEN sc = rtems_event_send( task, events ); 10ab5f: 89 75 0c mov %esi,0xc(%ebp) 10ab62: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10ab65: 8d 65 f8 lea -0x8(%ebp),%esp 10ab68: 5b pop %ebx 10ab69: 5e pop %esi 10ab6a: c9 leave { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { sc = rtems_event_send( task, events ); 10ab6b: e9 cc f6 ff ff jmp 10a23c } return sc; } 10ab70: 31 c0 xor %eax,%eax 10ab72: 8d 65 f8 lea -0x8(%ebp),%esp 10ab75: 5b pop %ebx 10ab76: 5e pop %esi 10ab77: c9 leave 10ab78: c3 ret <== NOT EXECUTED =============================================================================== 0010abb8 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10abb8: 55 push %ebp 10abb9: 89 e5 mov %esp,%ebp 10abbb: 57 push %edi 10abbc: 56 push %esi 10abbd: 53 push %ebx 10abbe: 83 ec 1c sub $0x1c,%esp 10abc1: 8b 7d 0c mov 0xc(%ebp),%edi while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL ) { rtems_event_set out; sc = rtems_event_receive( 10abc4: 8d 75 e4 lea -0x1c(%ebp),%esi 10abc7: eb 13 jmp 10abdc 10abc9: 56 push %esi 10abca: ff 75 10 pushl 0x10(%ebp) 10abcd: 6a 00 push $0x0 10abcf: 57 push %edi 10abd0: e8 07 f5 ff ff call 10a0dc ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10abd5: 83 c4 10 add $0x10,%esp 10abd8: 85 c0 test %eax,%eax 10abda: 75 16 jne 10abf2 <== ALWAYS TAKEN */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10abdc: 83 ec 0c sub $0xc,%esp 10abdf: ff 75 08 pushl 0x8(%ebp) 10abe2: e8 9d 04 00 00 call 10b084 <_Chain_Get> 10abe7: 89 c3 mov %eax,%ebx sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10abe9: 83 c4 10 add $0x10,%esp 10abec: 85 c0 test %eax,%eax 10abee: 74 d9 je 10abc9 10abf0: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10abf2: 8b 55 14 mov 0x14(%ebp),%edx 10abf5: 89 1a mov %ebx,(%edx) return sc; } 10abf7: 8d 65 f4 lea -0xc(%ebp),%esp 10abfa: 5b pop %ebx 10abfb: 5e pop %esi 10abfc: 5f pop %edi 10abfd: c9 leave 10abfe: c3 ret =============================================================================== 0010ac00 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10ac00: 55 push %ebp 10ac01: 89 e5 mov %esp,%ebp 10ac03: 56 push %esi 10ac04: 53 push %ebx 10ac05: 8b 5d 10 mov 0x10(%ebp),%ebx 10ac08: 8b 75 14 mov 0x14(%ebp),%esi RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check( rtems_chain_control *chain, rtems_chain_node *node ) { return _Chain_Prepend_with_empty_check( chain, node ); 10ac0b: 50 push %eax 10ac0c: 50 push %eax 10ac0d: ff 75 0c pushl 0xc(%ebp) 10ac10: ff 75 08 pushl 0x8(%ebp) 10ac13: e8 b0 04 00 00 call 10b0c8 <_Chain_Prepend_with_empty_check> rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { 10ac18: 83 c4 10 add $0x10,%esp 10ac1b: 84 c0 test %al,%al 10ac1d: 74 11 je 10ac30 <== NEVER TAKEN sc = rtems_event_send( task, events ); 10ac1f: 89 75 0c mov %esi,0xc(%ebp) 10ac22: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10ac25: 8d 65 f8 lea -0x8(%ebp),%esp 10ac28: 5b pop %ebx 10ac29: 5e pop %esi 10ac2a: c9 leave { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { sc = rtems_event_send( task, events ); 10ac2b: e9 0c f6 ff ff jmp 10a23c } return sc; } 10ac30: 31 c0 xor %eax,%eax 10ac32: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ac35: 5b pop %ebx <== NOT EXECUTED 10ac36: 5e pop %esi <== NOT EXECUTED 10ac37: c9 leave <== NOT EXECUTED 10ac38: c3 ret <== NOT EXECUTED =============================================================================== 0010b724 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 10b724: 55 push %ebp 10b725: 89 e5 mov %esp,%ebp 10b727: 57 push %edi 10b728: 56 push %esi 10b729: 53 push %ebx 10b72a: 83 ec 0c sub $0xc,%esp 10b72d: 8b 5d 08 mov 0x8(%ebp),%ebx 10b730: 8b 75 0c mov 0xc(%ebp),%esi 10b733: 8b 45 10 mov 0x10(%ebp),%eax rtems_device_major_number major_limit = _IO_Number_of_drivers; 10b736: 8b 15 9c 8d 12 00 mov 0x128d9c,%edx if ( rtems_interrupt_is_in_progress() ) 10b73c: 83 3d 40 89 12 00 00 cmpl $0x0,0x128940 10b743: 0f 85 cc 00 00 00 jne 10b815 <== NEVER TAKEN return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 10b749: 85 c0 test %eax,%eax 10b74b: 0f 84 cb 00 00 00 je 10b81c return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 10b751: 89 10 mov %edx,(%eax) if ( driver_table == NULL ) 10b753: 85 f6 test %esi,%esi 10b755: 0f 84 c1 00 00 00 je 10b81c static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b75b: 83 3e 00 cmpl $0x0,(%esi) 10b75e: 0f 85 cc 00 00 00 jne 10b830 10b764: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b768: 0f 85 c2 00 00 00 jne 10b830 10b76e: e9 a9 00 00 00 jmp 10b81c rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b773: 8b 15 f8 83 12 00 mov 0x1283f8,%edx 10b779: 42 inc %edx 10b77a: 89 15 f8 83 12 00 mov %edx,0x1283f8 if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 10b780: 85 db test %ebx,%ebx 10b782: 75 32 jne 10b7b6 static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 10b784: 8b 0d 9c 8d 12 00 mov 0x128d9c,%ecx 10b78a: 8b 15 a0 8d 12 00 mov 0x128da0,%edx 10b790: eb 15 jmp 10b7a7 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b792: 83 3a 00 cmpl $0x0,(%edx) 10b795: 0f 85 9f 00 00 00 jne 10b83a 10b79b: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10b79f: 0f 85 95 00 00 00 jne 10b83a 10b7a5: eb 04 jmp 10b7ab rtems_device_major_number n = _IO_Number_of_drivers; rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10b7a7: 39 cb cmp %ecx,%ebx 10b7a9: 72 e7 jb 10b792 if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10b7ab: 89 18 mov %ebx,(%eax) if ( m != n ) 10b7ad: 39 cb cmp %ecx,%ebx 10b7af: 75 30 jne 10b7e1 10b7b1: e9 8d 00 00 00 jmp 10b843 _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 10b7b6: 6b d3 18 imul $0x18,%ebx,%edx 10b7b9: 03 15 a0 8d 12 00 add 0x128da0,%edx static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b7bf: 31 c9 xor %ecx,%ecx 10b7c1: 83 3a 00 cmpl $0x0,(%edx) 10b7c4: 75 09 jne 10b7cf 10b7c6: 31 c9 xor %ecx,%ecx 10b7c8: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10b7cc: 0f 94 c1 sete %cl } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; if ( !rtems_io_is_empty_table( table ) ) { 10b7cf: 85 c9 test %ecx,%ecx 10b7d1: 75 0c jne 10b7df _Thread_Enable_dispatch(); 10b7d3: e8 2a 1a 00 00 call 10d202 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10b7d8: b8 0c 00 00 00 mov $0xc,%eax 10b7dd: eb 49 jmp 10b828 } *registered_major = major; 10b7df: 89 18 mov %ebx,(%eax) } _IO_Driver_address_table [major] = *driver_table; 10b7e1: 6b c3 18 imul $0x18,%ebx,%eax 10b7e4: 03 05 a0 8d 12 00 add 0x128da0,%eax 10b7ea: b9 06 00 00 00 mov $0x6,%ecx 10b7ef: 89 c7 mov %eax,%edi 10b7f1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10b7f3: e8 0a 1a 00 00 call 10d202 <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 10b7f8: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10b7ff: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10b806: 89 5d 08 mov %ebx,0x8(%ebp) } 10b809: 83 c4 0c add $0xc,%esp 10b80c: 5b pop %ebx 10b80d: 5e pop %esi 10b80e: 5f pop %edi 10b80f: c9 leave _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 10b810: e9 67 71 00 00 jmp 11297c ) { rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; 10b815: b8 12 00 00 00 mov $0x12,%eax 10b81a: eb 0c jmp 10b828 if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 10b81c: b8 09 00 00 00 mov $0x9,%eax 10b821: eb 05 jmp 10b828 if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; 10b823: b8 0a 00 00 00 mov $0xa,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10b828: 83 c4 0c add $0xc,%esp 10b82b: 5b pop %ebx 10b82c: 5e pop %esi 10b82d: 5f pop %edi 10b82e: c9 leave 10b82f: c3 ret return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 10b830: 39 d3 cmp %edx,%ebx 10b832: 0f 82 3b ff ff ff jb 10b773 10b838: eb e9 jmp 10b823 rtems_device_major_number n = _IO_Number_of_drivers; rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10b83a: 43 inc %ebx 10b83b: 83 c2 18 add $0x18,%edx 10b83e: e9 64 ff ff ff jmp 10b7a7 if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 10b843: e8 ba 19 00 00 call 10d202 <_Thread_Enable_dispatch> *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 10b848: b8 05 00 00 00 mov $0x5,%eax if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); return sc; 10b84d: eb d9 jmp 10b828 =============================================================================== 0010c750 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c750: 55 push %ebp 10c751: 89 e5 mov %esp,%ebp 10c753: 57 push %edi 10c754: 56 push %esi 10c755: 53 push %ebx 10c756: 83 ec 0c sub $0xc,%esp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c759: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10c75d: 74 3d je 10c79c <== NEVER TAKEN 10c75f: bb 01 00 00 00 mov $0x1,%ebx #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10c764: 8b 04 9d 3c 01 13 00 mov 0x13013c(,%ebx,4),%eax 10c76b: 8b 78 04 mov 0x4(%eax),%edi if ( !information ) 10c76e: be 01 00 00 00 mov $0x1,%esi 10c773: 85 ff test %edi,%edi 10c775: 75 17 jne 10c78e 10c777: eb 1d jmp 10c796 continue; for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10c779: 8b 47 1c mov 0x1c(%edi),%eax 10c77c: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !the_thread ) 10c77f: 85 c0 test %eax,%eax 10c781: 74 0a je 10c78d <== NEVER TAKEN continue; (*routine)(the_thread); 10c783: 83 ec 0c sub $0xc,%esp 10c786: 50 push %eax 10c787: ff 55 08 call *0x8(%ebp) 10c78a: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10c78d: 46 inc %esi 10c78e: 0f b7 47 10 movzwl 0x10(%edi),%eax 10c792: 39 c6 cmp %eax,%esi 10c794: 76 e3 jbe 10c779 Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c796: 43 inc %ebx 10c797: 83 fb 04 cmp $0x4,%ebx 10c79a: 75 c8 jne 10c764 (*routine)(the_thread); } } } 10c79c: 8d 65 f4 lea -0xc(%ebp),%esp 10c79f: 5b pop %ebx 10c7a0: 5e pop %esi 10c7a1: 5f pop %edi 10c7a2: c9 leave 10c7a3: c3 ret =============================================================================== 001147e8 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 1147e8: 55 push %ebp 1147e9: 89 e5 mov %esp,%ebp 1147eb: 57 push %edi 1147ec: 56 push %esi 1147ed: 53 push %ebx 1147ee: 83 ec 1c sub $0x1c,%esp 1147f1: 8b 75 0c mov 0xc(%ebp),%esi 1147f4: 8b 55 10 mov 0x10(%ebp),%edx 1147f7: 8b 7d 14 mov 0x14(%ebp),%edi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 1147fa: b8 03 00 00 00 mov $0x3,%eax rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 1147ff: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 114803: 0f 84 ce 00 00 00 je 1148d7 return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 114809: b0 09 mov $0x9,%al register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) 11480b: 85 f6 test %esi,%esi 11480d: 0f 84 c4 00 00 00 je 1148d7 return RTEMS_INVALID_ADDRESS; if ( !id ) 114813: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 114817: 0f 84 ba 00 00 00 je 1148d7 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 11481d: 85 ff test %edi,%edi 11481f: 0f 84 ad 00 00 00 je 1148d2 114825: 85 d2 test %edx,%edx 114827: 0f 84 a5 00 00 00 je 1148d2 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 11482d: b0 08 mov $0x8,%al return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 11482f: 39 fa cmp %edi,%edx 114831: 0f 82 a0 00 00 00 jb 1148d7 114837: f7 c7 03 00 00 00 test $0x3,%edi 11483d: 0f 85 94 00 00 00 jne 1148d7 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; 114843: b0 09 mov $0x9,%al if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 114845: f7 c6 03 00 00 00 test $0x3,%esi 11484b: 0f 85 86 00 00 00 jne 1148d7 114851: a1 d4 d6 13 00 mov 0x13d6d4,%eax 114856: 40 inc %eax 114857: a3 d4 d6 13 00 mov %eax,0x13d6d4 * This function allocates a partition control block from * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 11485c: 83 ec 0c sub $0xc,%esp 11485f: 68 64 d5 13 00 push $0x13d564 114864: 89 55 e4 mov %edx,-0x1c(%ebp) 114867: e8 24 3e 00 00 call 118690 <_Objects_Allocate> 11486c: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 11486e: 83 c4 10 add $0x10,%esp 114871: 85 c0 test %eax,%eax 114873: 8b 55 e4 mov -0x1c(%ebp),%edx 114876: 75 0c jne 114884 _Thread_Enable_dispatch(); 114878: e8 5d 4c 00 00 call 1194da <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 11487d: b8 05 00 00 00 mov $0x5,%eax 114882: eb 53 jmp 1148d7 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 114884: 89 70 10 mov %esi,0x10(%eax) the_partition->length = length; 114887: 89 50 14 mov %edx,0x14(%eax) the_partition->buffer_size = buffer_size; 11488a: 89 78 18 mov %edi,0x18(%eax) the_partition->attribute_set = attribute_set; 11488d: 8b 45 18 mov 0x18(%ebp),%eax 114890: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 114893: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 11489a: 57 push %edi 11489b: 89 d0 mov %edx,%eax 11489d: 31 d2 xor %edx,%edx 11489f: f7 f7 div %edi 1148a1: 50 push %eax 1148a2: 56 push %esi 1148a3: 8d 43 24 lea 0x24(%ebx),%eax 1148a6: 50 push %eax 1148a7: e8 84 2a 00 00 call 117330 <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1148ac: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1148af: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1148b2: 8b 15 80 d5 13 00 mov 0x13d580,%edx 1148b8: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1148bb: 8b 55 08 mov 0x8(%ebp),%edx 1148be: 89 53 0c mov %edx,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 1148c1: 8b 55 1c mov 0x1c(%ebp),%edx 1148c4: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1148c6: e8 0f 4c 00 00 call 1194da <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1148cb: 83 c4 10 add $0x10,%esp 1148ce: 31 c0 xor %eax,%eax 1148d0: eb 05 jmp 1148d7 if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 1148d2: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1148d7: 8d 65 f4 lea -0xc(%ebp),%esp 1148da: 5b pop %ebx 1148db: 5e pop %esi 1148dc: 5f pop %edi 1148dd: c9 leave 1148de: c3 ret =============================================================================== 0010b03d : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 10b03d: 55 push %ebp 10b03e: 89 e5 mov %esp,%ebp 10b040: 57 push %edi 10b041: 56 push %esi 10b042: 53 push %ebx 10b043: 83 ec 30 sub $0x30,%esp 10b046: 8b 75 08 mov 0x8(%ebp),%esi 10b049: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); 10b04c: 8d 45 e4 lea -0x1c(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 10b04f: 50 push %eax 10b050: 56 push %esi 10b051: 68 14 73 12 00 push $0x127314 10b056: e8 49 1e 00 00 call 10cea4 <_Objects_Get> 10b05b: 89 c7 mov %eax,%edi switch ( location ) { 10b05d: 83 c4 10 add $0x10,%esp 10b060: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b064: 0f 85 3b 01 00 00 jne 10b1a5 <== NEVER TAKEN case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10b06a: a1 50 79 12 00 mov 0x127950,%eax 10b06f: 39 47 40 cmp %eax,0x40(%edi) 10b072: 74 0f je 10b083 _Thread_Enable_dispatch(); 10b074: e8 09 28 00 00 call 10d882 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 10b079: be 17 00 00 00 mov $0x17,%esi 10b07e: e9 27 01 00 00 jmp 10b1aa } if ( length == RTEMS_PERIOD_STATUS ) { 10b083: 85 db test %ebx,%ebx 10b085: 75 1b jne 10b0a2 switch ( the_period->state ) { 10b087: 8b 47 38 mov 0x38(%edi),%eax 10b08a: 31 f6 xor %esi,%esi 10b08c: 83 f8 04 cmp $0x4,%eax 10b08f: 77 07 ja 10b098 <== NEVER TAKEN 10b091: 8b 34 85 a8 0d 12 00 mov 0x120da8(,%eax,4),%esi case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10b098: e8 e5 27 00 00 call 10d882 <_Thread_Enable_dispatch> return( return_value ); 10b09d: e9 08 01 00 00 jmp 10b1aa } _ISR_Disable( level ); 10b0a2: 9c pushf 10b0a3: fa cli 10b0a4: 8f 45 d4 popl -0x2c(%ebp) if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 10b0a7: 8b 47 38 mov 0x38(%edi),%eax 10b0aa: 85 c0 test %eax,%eax 10b0ac: 75 4c jne 10b0fa _ISR_Enable( level ); 10b0ae: ff 75 d4 pushl -0x2c(%ebp) 10b0b1: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10b0b2: 83 ec 0c sub $0xc,%esp 10b0b5: 57 push %edi 10b0b6: e8 3f fe ff ff call 10aefa <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10b0bb: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10b0c2: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10b0c9: c7 47 2c b4 b3 10 00 movl $0x10b3b4,0x2c(%edi) the_watchdog->id = id; 10b0d0: 89 77 30 mov %esi,0x30(%edi) the_watchdog->user_data = user_data; 10b0d3: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10b0da: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b0dd: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b0e0: 58 pop %eax 10b0e1: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b0e2: 83 c7 10 add $0x10,%edi 10b0e5: 57 push %edi 10b0e6: 68 e8 74 12 00 push $0x1274e8 10b0eb: e8 38 35 00 00 call 10e628 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b0f0: e8 8d 27 00 00 call 10d882 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b0f5: 83 c4 10 add $0x10,%esp 10b0f8: eb 65 jmp 10b15f } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 10b0fa: 83 f8 02 cmp $0x2,%eax 10b0fd: 75 64 jne 10b163 /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10b0ff: 83 ec 0c sub $0xc,%esp 10b102: 57 push %edi 10b103: e8 5a fe ff ff call 10af62 <_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; 10b108: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) the_period->next_length = length; 10b10f: 89 5f 3c mov %ebx,0x3c(%edi) _ISR_Enable( level ); 10b112: ff 75 d4 pushl -0x2c(%ebp) 10b115: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10b116: a1 50 79 12 00 mov 0x127950,%eax 10b11b: 8b 57 08 mov 0x8(%edi),%edx 10b11e: 89 50 20 mov %edx,0x20(%eax) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b121: 5b pop %ebx 10b122: 5e pop %esi 10b123: 68 00 40 00 00 push $0x4000 10b128: 50 push %eax 10b129: e8 0a 2f 00 00 call 10e038 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10b12e: 9c pushf 10b12f: fa cli 10b130: 5a pop %edx local_state = the_period->state; 10b131: 8b 47 38 mov 0x38(%edi),%eax the_period->state = RATE_MONOTONIC_ACTIVE; 10b134: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) _ISR_Enable( level ); 10b13b: 52 push %edx 10b13c: 9d popf /* * 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 ) 10b13d: 83 c4 10 add $0x10,%esp 10b140: 83 f8 03 cmp $0x3,%eax 10b143: 75 15 jne 10b15a _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b145: 51 push %ecx 10b146: 51 push %ecx 10b147: 68 00 40 00 00 push $0x4000 10b14c: ff 35 50 79 12 00 pushl 0x127950 10b152: e8 f9 23 00 00 call 10d550 <_Thread_Clear_state> 10b157: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 10b15a: e8 23 27 00 00 call 10d882 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b15f: 31 f6 xor %esi,%esi 10b161: eb 47 jmp 10b1aa #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b163: be 04 00 00 00 mov $0x4,%esi _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 10b168: 83 f8 04 cmp $0x4,%eax 10b16b: 75 3d jne 10b1aa <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10b16d: 83 ec 0c sub $0xc,%esp 10b170: 57 push %edi 10b171: e8 ec fd ff ff call 10af62 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10b176: ff 75 d4 pushl -0x2c(%ebp) 10b179: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10b17a: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) the_period->next_length = length; 10b181: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b184: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b187: 58 pop %eax 10b188: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b189: 83 c7 10 add $0x10,%edi 10b18c: 57 push %edi 10b18d: 68 e8 74 12 00 push $0x1274e8 10b192: e8 91 34 00 00 call 10e628 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b197: e8 e6 26 00 00 call 10d882 <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 10b19c: 83 c4 10 add $0x10,%esp 10b19f: 66 be 06 00 mov $0x6,%si 10b1a3: eb 05 jmp 10b1aa #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b1a5: be 04 00 00 00 mov $0x4,%esi } 10b1aa: 89 f0 mov %esi,%eax 10b1ac: 8d 65 f4 lea -0xc(%ebp),%esp 10b1af: 5b pop %ebx 10b1b0: 5e pop %esi 10b1b1: 5f pop %edi 10b1b2: c9 leave 10b1b3: c3 ret =============================================================================== 0010b1b4 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 10b1b4: 55 push %ebp 10b1b5: 89 e5 mov %esp,%ebp 10b1b7: 57 push %edi 10b1b8: 56 push %esi 10b1b9: 53 push %ebx 10b1ba: 83 ec 7c sub $0x7c,%esp 10b1bd: 8b 5d 08 mov 0x8(%ebp),%ebx 10b1c0: 8b 7d 0c mov 0xc(%ebp),%edi rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 10b1c3: 85 ff test %edi,%edi 10b1c5: 0f 84 2b 01 00 00 je 10b2f6 <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10b1cb: 52 push %edx 10b1cc: 52 push %edx 10b1cd: 68 bc 0d 12 00 push $0x120dbc 10b1d2: 53 push %ebx 10b1d3: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 10b1d5: 5e pop %esi 10b1d6: 58 pop %eax 10b1d7: 68 da 0d 12 00 push $0x120dda 10b1dc: 53 push %ebx 10b1dd: ff d7 call *%edi (*print)( context, "--- Wall times are in seconds ---\n" ); 10b1df: 5a pop %edx 10b1e0: 59 pop %ecx 10b1e1: 68 fc 0d 12 00 push $0x120dfc 10b1e6: 53 push %ebx 10b1e7: ff d7 call *%edi Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10b1e9: 5e pop %esi 10b1ea: 58 pop %eax 10b1eb: 68 1f 0e 12 00 push $0x120e1f 10b1f0: 53 push %ebx 10b1f1: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 10b1f3: 5a pop %edx 10b1f4: 59 pop %ecx 10b1f5: 68 6a 0e 12 00 push $0x120e6a 10b1fa: 53 push %ebx 10b1fb: ff d7 call *%edi /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 10b1fd: 8b 35 1c 73 12 00 mov 0x12731c,%esi 10b203: 83 c4 10 add $0x10,%esp 10b206: e9 df 00 00 00 jmp 10b2ea id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10b20b: 50 push %eax 10b20c: 50 push %eax 10b20d: 8d 45 88 lea -0x78(%ebp),%eax 10b210: 50 push %eax 10b211: 56 push %esi 10b212: e8 89 56 00 00 call 1108a0 if ( status != RTEMS_SUCCESSFUL ) 10b217: 83 c4 10 add $0x10,%esp 10b21a: 85 c0 test %eax,%eax 10b21c: 0f 85 c7 00 00 00 jne 10b2e9 #if defined(RTEMS_DEBUG) status = rtems_rate_monotonic_get_status( id, &the_status ); if ( status != RTEMS_SUCCESSFUL ) continue; #else (void) rtems_rate_monotonic_get_status( id, &the_status ); 10b222: 51 push %ecx 10b223: 51 push %ecx 10b224: 8d 55 c0 lea -0x40(%ebp),%edx 10b227: 52 push %edx 10b228: 56 push %esi 10b229: e8 16 57 00 00 call 110944 #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 10b22e: 83 c4 0c add $0xc,%esp 10b231: 8d 45 e3 lea -0x1d(%ebp),%eax 10b234: 50 push %eax 10b235: 6a 05 push $0x5 10b237: ff 75 c0 pushl -0x40(%ebp) 10b23a: e8 01 02 00 00 call 10b440 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10b23f: 58 pop %eax 10b240: 5a pop %edx 10b241: ff 75 8c pushl -0x74(%ebp) 10b244: ff 75 88 pushl -0x78(%ebp) 10b247: 8d 55 e3 lea -0x1d(%ebp),%edx 10b24a: 52 push %edx 10b24b: 56 push %esi 10b24c: 68 b6 0e 12 00 push $0x120eb6 10b251: 53 push %ebx 10b252: ff d7 call *%edi ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10b254: 8b 45 88 mov -0x78(%ebp),%eax 10b257: 83 c4 20 add $0x20,%esp 10b25a: 85 c0 test %eax,%eax 10b25c: 75 0f jne 10b26d (*print)( context, "\n" ); 10b25e: 51 push %ecx 10b25f: 51 push %ecx 10b260: 68 30 11 12 00 push $0x121130 10b265: 53 push %ebx 10b266: ff d7 call *%edi continue; 10b268: 83 c4 10 add $0x10,%esp 10b26b: eb 7c jmp 10b2e9 struct timespec cpu_average; struct timespec *min_cpu = &the_stats.min_cpu_time; struct timespec *max_cpu = &the_stats.max_cpu_time; struct timespec *total_cpu = &the_stats.total_cpu_time; _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 10b26d: 52 push %edx 10b26e: 8d 55 d8 lea -0x28(%ebp),%edx 10b271: 52 push %edx 10b272: 50 push %eax 10b273: 8d 45 a0 lea -0x60(%ebp),%eax 10b276: 50 push %eax 10b277: e8 80 30 00 00 call 10e2fc <_Timespec_Divide_by_integer> (*print)( context, 10b27c: 8b 45 dc mov -0x24(%ebp),%eax 10b27f: b9 e8 03 00 00 mov $0x3e8,%ecx 10b284: 99 cltd 10b285: f7 f9 idiv %ecx 10b287: 50 push %eax 10b288: ff 75 d8 pushl -0x28(%ebp) 10b28b: 8b 45 9c mov -0x64(%ebp),%eax 10b28e: 99 cltd 10b28f: f7 f9 idiv %ecx 10b291: 50 push %eax 10b292: ff 75 98 pushl -0x68(%ebp) 10b295: 8b 45 94 mov -0x6c(%ebp),%eax 10b298: 99 cltd 10b299: f7 f9 idiv %ecx 10b29b: 50 push %eax 10b29c: ff 75 90 pushl -0x70(%ebp) 10b29f: 68 cd 0e 12 00 push $0x120ecd 10b2a4: 53 push %ebx 10b2a5: 89 4d 84 mov %ecx,-0x7c(%ebp) 10b2a8: ff d7 call *%edi struct timespec wall_average; struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 10b2aa: 83 c4 2c add $0x2c,%esp 10b2ad: 8d 55 d8 lea -0x28(%ebp),%edx 10b2b0: 52 push %edx 10b2b1: ff 75 88 pushl -0x78(%ebp) { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ struct timespec wall_average; struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; 10b2b4: 8d 45 b8 lea -0x48(%ebp),%eax _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 10b2b7: 50 push %eax 10b2b8: e8 3f 30 00 00 call 10e2fc <_Timespec_Divide_by_integer> (*print)( context, 10b2bd: 8b 45 dc mov -0x24(%ebp),%eax 10b2c0: 8b 4d 84 mov -0x7c(%ebp),%ecx 10b2c3: 99 cltd 10b2c4: f7 f9 idiv %ecx 10b2c6: 50 push %eax 10b2c7: ff 75 d8 pushl -0x28(%ebp) 10b2ca: 8b 45 b4 mov -0x4c(%ebp),%eax 10b2cd: 99 cltd 10b2ce: f7 f9 idiv %ecx 10b2d0: 50 push %eax 10b2d1: ff 75 b0 pushl -0x50(%ebp) 10b2d4: 8b 45 ac mov -0x54(%ebp),%eax 10b2d7: 99 cltd 10b2d8: f7 f9 idiv %ecx 10b2da: 50 push %eax 10b2db: ff 75 a8 pushl -0x58(%ebp) 10b2de: 68 ec 0e 12 00 push $0x120eec 10b2e3: 53 push %ebx 10b2e4: ff d7 call *%edi 10b2e6: 83 c4 30 add $0x30,%esp * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 10b2e9: 46 inc %esi /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 10b2ea: 3b 35 20 73 12 00 cmp 0x127320,%esi 10b2f0: 0f 86 15 ff ff ff jbe 10b20b the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10b2f6: 8d 65 f4 lea -0xc(%ebp),%esp 10b2f9: 5b pop %ebx 10b2fa: 5e pop %esi 10b2fb: 5f pop %edi 10b2fc: c9 leave 10b2fd: c3 ret =============================================================================== 00115b48 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 115b48: 55 push %ebp 115b49: 89 e5 mov %esp,%ebp 115b4b: 53 push %ebx 115b4c: 83 ec 14 sub $0x14,%esp 115b4f: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; 115b52: b8 0a 00 00 00 mov $0xa,%eax register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 115b57: 85 db test %ebx,%ebx 115b59: 74 6d je 115bc8 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 115b5b: 50 push %eax 115b5c: 50 push %eax 115b5d: 8d 45 f4 lea -0xc(%ebp),%eax 115b60: 50 push %eax 115b61: ff 75 08 pushl 0x8(%ebp) 115b64: e8 93 39 00 00 call 1194fc <_Thread_Get> switch ( location ) { 115b69: 83 c4 10 add $0x10,%esp 115b6c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 115b70: 75 51 jne 115bc3 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 115b72: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 115b78: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 115b7c: 74 39 je 115bb7 if ( asr->is_enabled ) { 115b7e: 80 7a 08 00 cmpb $0x0,0x8(%edx) 115b82: 74 22 je 115ba6 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115b84: 9c pushf 115b85: fa cli 115b86: 59 pop %ecx *signal_set |= signals; 115b87: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 115b8a: 51 push %ecx 115b8b: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 115b8c: 83 3d 24 dc 13 00 00 cmpl $0x0,0x13dc24 115b93: 74 19 je 115bae 115b95: 3b 05 28 dc 13 00 cmp 0x13dc28,%eax 115b9b: 75 11 jne 115bae <== NEVER TAKEN _Thread_Dispatch_necessary = true; 115b9d: c6 05 34 dc 13 00 01 movb $0x1,0x13dc34 115ba4: eb 08 jmp 115bae rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115ba6: 9c pushf 115ba7: fa cli 115ba8: 58 pop %eax *signal_set |= signals; 115ba9: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 115bac: 50 push %eax 115bad: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 115bae: e8 27 39 00 00 call 1194da <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115bb3: 31 c0 xor %eax,%eax 115bb5: eb 11 jmp 115bc8 } _Thread_Enable_dispatch(); 115bb7: e8 1e 39 00 00 call 1194da <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 115bbc: b8 0b 00 00 00 mov $0xb,%eax 115bc1: eb 05 jmp 115bc8 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115bc3: b8 04 00 00 00 mov $0x4,%eax } 115bc8: 8b 5d fc mov -0x4(%ebp),%ebx 115bcb: c9 leave 115bcc: c3 ret =============================================================================== 00110d70 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 110d70: 55 push %ebp 110d71: 89 e5 mov %esp,%ebp 110d73: 57 push %edi 110d74: 56 push %esi 110d75: 53 push %ebx 110d76: 83 ec 1c sub $0x1c,%esp 110d79: 8b 4d 10 mov 0x10(%ebp),%ecx bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) return RTEMS_INVALID_ADDRESS; 110d7c: b8 09 00 00 00 mov $0x9,%eax ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 110d81: 85 c9 test %ecx,%ecx 110d83: 0f 84 fb 00 00 00 je 110e84 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 110d89: 8b 35 2c 48 12 00 mov 0x12482c,%esi api = executing->API_Extensions[ THREAD_API_RTEMS ]; 110d8f: 8b 9e e8 00 00 00 mov 0xe8(%esi),%ebx asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 110d95: 80 7e 74 01 cmpb $0x1,0x74(%esi) 110d99: 19 ff sbb %edi,%edi 110d9b: 81 e7 00 01 00 00 and $0x100,%edi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 110da1: 83 7e 7c 00 cmpl $0x0,0x7c(%esi) 110da5: 74 06 je 110dad old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 110da7: 81 cf 00 02 00 00 or $0x200,%edi old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 110dad: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 110db1: 19 d2 sbb %edx,%edx 110db3: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 110db9: 89 55 e4 mov %edx,-0x1c(%ebp) 110dbc: 89 4d e0 mov %ecx,-0x20(%ebp) 110dbf: e8 b1 c5 ff ff call 10d375 <_CPU_ISR_Get_level> if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 110dc4: 8b 55 e4 mov -0x1c(%ebp),%edx 110dc7: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 110dc9: 09 f8 or %edi,%eax 110dcb: 8b 4d e0 mov -0x20(%ebp),%ecx 110dce: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 110dd0: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 110dd7: 74 0b je 110de4 executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 110dd9: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 110de0: 0f 94 46 74 sete 0x74(%esi) if ( mask & RTEMS_TIMESLICE_MASK ) { 110de4: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 110deb: 74 21 je 110e0e if ( _Modes_Is_timeslice(mode_set) ) { 110ded: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 110df4: 74 11 je 110e07 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 110df6: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 110dfd: a1 b0 42 12 00 mov 0x1242b0,%eax 110e02: 89 46 78 mov %eax,0x78(%esi) 110e05: eb 07 jmp 110e0e } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 110e07: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 110e0e: f6 45 0c 01 testb $0x1,0xc(%ebp) 110e12: 74 0a je 110e1e */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 110e14: f6 45 08 01 testb $0x1,0x8(%ebp) 110e18: 74 03 je 110e1d 110e1a: fa cli 110e1b: eb 01 jmp 110e1e 110e1d: fb sti /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110e1e: 31 c9 xor %ecx,%ecx if ( mask & RTEMS_ASR_MASK ) { 110e20: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 110e27: 74 2a je 110e53 * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 110e29: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 110e30: 0f 94 c0 sete %al is_asr_enabled = false; needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; if ( is_asr_enabled != asr->is_enabled ) { 110e33: 3a 43 08 cmp 0x8(%ebx),%al 110e36: 74 1b je 110e53 asr->is_enabled = is_asr_enabled; 110e38: 88 43 08 mov %al,0x8(%ebx) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 110e3b: 9c pushf 110e3c: fa cli 110e3d: 58 pop %eax _signals = information->signals_pending; 110e3e: 8b 53 18 mov 0x18(%ebx),%edx information->signals_pending = information->signals_posted; 110e41: 8b 4b 14 mov 0x14(%ebx),%ecx 110e44: 89 4b 18 mov %ecx,0x18(%ebx) information->signals_posted = _signals; 110e47: 89 53 14 mov %edx,0x14(%ebx) _ISR_Enable( _level ); 110e4a: 50 push %eax 110e4b: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110e4c: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 110e50: 0f 95 c1 setne %cl if ( _System_state_Is_up( _System_state_Get() ) ) { if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; 110e53: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 110e55: 83 3d 5c 44 12 00 03 cmpl $0x3,0x12445c 110e5c: 75 26 jne 110e84 <== NEVER TAKEN bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 110e5e: 8b 15 2c 48 12 00 mov 0x12482c,%edx if ( are_signals_pending || 110e64: 84 c9 test %cl,%cl 110e66: 75 0e jne 110e76 110e68: 3b 15 30 48 12 00 cmp 0x124830,%edx 110e6e: 74 14 je 110e84 (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 110e70: 80 7a 74 00 cmpb $0x0,0x74(%edx) 110e74: 74 0e je 110e84 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 110e76: c6 05 38 48 12 00 01 movb $0x1,0x124838 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 110e7d: e8 1e b1 ff ff call 10bfa0 <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 110e82: 31 c0 xor %eax,%eax } 110e84: 83 c4 1c add $0x1c,%esp 110e87: 5b pop %ebx 110e88: 5e pop %esi 110e89: 5f pop %edi 110e8a: c9 leave 110e8b: c3 ret =============================================================================== 0010dd24 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10dd24: 55 push %ebp 10dd25: 89 e5 mov %esp,%ebp 10dd27: 56 push %esi 10dd28: 53 push %ebx 10dd29: 83 ec 10 sub $0x10,%esp 10dd2c: 8b 5d 0c mov 0xc(%ebp),%ebx 10dd2f: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd32: 85 db test %ebx,%ebx 10dd34: 74 10 je 10dd46 RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 10dd36: 0f b6 15 f4 41 12 00 movzbl 0x1241f4,%edx !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10dd3d: b8 13 00 00 00 mov $0x13,%eax ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd42: 39 d3 cmp %edx,%ebx 10dd44: 77 52 ja 10dd98 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10dd46: b8 09 00 00 00 mov $0x9,%eax if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10dd4b: 85 f6 test %esi,%esi 10dd4d: 74 49 je 10dd98 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10dd4f: 51 push %ecx 10dd50: 51 push %ecx 10dd51: 8d 45 f4 lea -0xc(%ebp),%eax 10dd54: 50 push %eax 10dd55: ff 75 08 pushl 0x8(%ebp) 10dd58: e8 03 1e 00 00 call 10fb60 <_Thread_Get> switch ( location ) { 10dd5d: 83 c4 10 add $0x10,%esp 10dd60: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10dd64: 75 2d jne 10dd93 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10dd66: 8b 50 14 mov 0x14(%eax),%edx 10dd69: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10dd6b: 85 db test %ebx,%ebx 10dd6d: 74 1b je 10dd8a the_thread->real_priority = new_priority; 10dd6f: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10dd72: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10dd76: 74 05 je 10dd7d 10dd78: 39 58 14 cmp %ebx,0x14(%eax) 10dd7b: 76 0d jbe 10dd8a <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10dd7d: 52 push %edx 10dd7e: 6a 00 push $0x0 10dd80: 53 push %ebx 10dd81: 50 push %eax 10dd82: e8 71 19 00 00 call 10f6f8 <_Thread_Change_priority> 10dd87: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10dd8a: e8 af 1d 00 00 call 10fb3e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10dd8f: 31 c0 xor %eax,%eax 10dd91: eb 05 jmp 10dd98 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10dd93: b8 04 00 00 00 mov $0x4,%eax } 10dd98: 8d 65 f8 lea -0x8(%ebp),%esp 10dd9b: 5b pop %ebx 10dd9c: 5e pop %esi 10dd9d: c9 leave 10dd9e: c3 ret =============================================================================== 0011639c : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 11639c: 55 push %ebp 11639d: 89 e5 mov %esp,%ebp 11639f: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 1163a2: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 1163a5: 50 push %eax 1163a6: ff 75 08 pushl 0x8(%ebp) 1163a9: 68 40 e0 13 00 push $0x13e040 1163ae: e8 49 27 00 00 call 118afc <_Objects_Get> switch ( location ) { 1163b3: 83 c4 10 add $0x10,%esp 1163b6: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 1163ba: 75 1e jne 1163da case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 1163bc: 83 78 38 04 cmpl $0x4,0x38(%eax) 1163c0: 74 0f je 1163d1 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 1163c2: 83 ec 0c sub $0xc,%esp 1163c5: 83 c0 10 add $0x10,%eax 1163c8: 50 push %eax 1163c9: e8 3a 41 00 00 call 11a508 <_Watchdog_Remove> 1163ce: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 1163d1: e8 04 31 00 00 call 1194da <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1163d6: 31 c0 xor %eax,%eax 1163d8: eb 05 jmp 1163df #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1163da: b8 04 00 00 00 mov $0x4,%eax } 1163df: c9 leave 1163e0: c3 ret =============================================================================== 001167fc : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 1167fc: 55 push %ebp 1167fd: 89 e5 mov %esp,%ebp 1167ff: 57 push %edi 116800: 56 push %esi 116801: 53 push %ebx 116802: 83 ec 1c sub $0x1c,%esp 116805: 8b 7d 0c mov 0xc(%ebp),%edi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 116808: 8b 35 80 e0 13 00 mov 0x13e080,%esi if ( !timer_server ) return RTEMS_INCORRECT_STATE; 11680e: bb 0e 00 00 00 mov $0xe,%ebx Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) 116813: 85 f6 test %esi,%esi 116815: 0f 84 b1 00 00 00 je 1168cc return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 11681b: b3 0b mov $0xb,%bl Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 11681d: 80 3d e8 d6 13 00 00 cmpb $0x0,0x13d6e8 116824: 0f 84 a2 00 00 00 je 1168cc <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 11682a: b3 09 mov $0x9,%bl return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 11682c: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 116830: 0f 84 96 00 00 00 je 1168cc return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 116836: 83 ec 0c sub $0xc,%esp 116839: 57 push %edi 11683a: e8 ad d6 ff ff call 113eec <_TOD_Validate> 11683f: 83 c4 10 add $0x10,%esp return RTEMS_INVALID_CLOCK; 116842: b3 14 mov $0x14,%bl return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 116844: 84 c0 test %al,%al 116846: 0f 84 80 00 00 00 je 1168cc return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 11684c: 83 ec 0c sub $0xc,%esp 11684f: 57 push %edi 116850: e8 2f d6 ff ff call 113e84 <_TOD_To_seconds> 116855: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 116857: 83 c4 10 add $0x10,%esp 11685a: 3b 05 80 d7 13 00 cmp 0x13d780,%eax 116860: 76 6a jbe 1168cc 116862: 51 push %ecx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 116863: 8d 45 e4 lea -0x1c(%ebp),%eax 116866: 50 push %eax 116867: ff 75 08 pushl 0x8(%ebp) 11686a: 68 40 e0 13 00 push $0x13e040 11686f: e8 88 22 00 00 call 118afc <_Objects_Get> 116874: 89 c3 mov %eax,%ebx switch ( location ) { 116876: 83 c4 10 add $0x10,%esp 116879: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 11687d: 75 48 jne 1168c7 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 11687f: 83 ec 0c sub $0xc,%esp 116882: 8d 40 10 lea 0x10(%eax),%eax 116885: 50 push %eax 116886: e8 7d 3c 00 00 call 11a508 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 11688b: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 116892: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) the_watchdog->routine = routine; 116899: 8b 45 10 mov 0x10(%ebp),%eax 11689c: 89 43 2c mov %eax,0x2c(%ebx) the_watchdog->id = id; 11689f: 8b 45 08 mov 0x8(%ebp),%eax 1168a2: 89 43 30 mov %eax,0x30(%ebx) the_watchdog->user_data = user_data; 1168a5: 8b 45 14 mov 0x14(%ebp),%eax 1168a8: 89 43 34 mov %eax,0x34(%ebx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 1168ab: 2b 3d 80 d7 13 00 sub 0x13d780,%edi 1168b1: 89 7b 1c mov %edi,0x1c(%ebx) (*timer_server->schedule_operation)( timer_server, the_timer ); 1168b4: 58 pop %eax 1168b5: 5a pop %edx 1168b6: 53 push %ebx 1168b7: 56 push %esi 1168b8: ff 56 04 call *0x4(%esi) _Thread_Enable_dispatch(); 1168bb: e8 1a 2c 00 00 call 1194da <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1168c0: 83 c4 10 add $0x10,%esp 1168c3: 31 db xor %ebx,%ebx 1168c5: eb 05 jmp 1168cc #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1168c7: bb 04 00 00 00 mov $0x4,%ebx } 1168cc: 89 d8 mov %ebx,%eax 1168ce: 8d 65 f4 lea -0xc(%ebp),%esp 1168d1: 5b pop %ebx 1168d2: 5e pop %esi 1168d3: 5f pop %edi 1168d4: c9 leave 1168d5: c3 ret =============================================================================== 0010a8f0 : #include int sched_get_priority_max( int policy ) { 10a8f0: 55 push %ebp 10a8f1: 89 e5 mov %esp,%ebp 10a8f3: 83 ec 08 sub $0x8,%esp 10a8f6: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a8f9: 83 f9 04 cmp $0x4,%ecx 10a8fc: 77 0b ja 10a909 10a8fe: b8 01 00 00 00 mov $0x1,%eax 10a903: d3 e0 shl %cl,%eax 10a905: a8 17 test $0x17,%al 10a907: 75 10 jne 10a919 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a909: e8 42 74 00 00 call 111d50 <__errno> 10a90e: c7 00 16 00 00 00 movl $0x16,(%eax) 10a914: 83 c8 ff or $0xffffffff,%eax 10a917: eb 08 jmp 10a921 } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 10a919: 0f b6 05 18 12 12 00 movzbl 0x121218,%eax 10a920: 48 dec %eax } 10a921: c9 leave 10a922: c3 ret =============================================================================== 0010a924 : #include int sched_get_priority_min( int policy ) { 10a924: 55 push %ebp 10a925: 89 e5 mov %esp,%ebp 10a927: 83 ec 08 sub $0x8,%esp 10a92a: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a92d: 83 f9 04 cmp $0x4,%ecx 10a930: 77 11 ja 10a943 10a932: ba 01 00 00 00 mov $0x1,%edx 10a937: d3 e2 shl %cl,%edx default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; 10a939: b8 01 00 00 00 mov $0x1,%eax int sched_get_priority_min( int policy ) { switch ( policy ) { 10a93e: 80 e2 17 and $0x17,%dl 10a941: 75 0e jne 10a951 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a943: e8 08 74 00 00 call 111d50 <__errno> 10a948: c7 00 16 00 00 00 movl $0x16,(%eax) 10a94e: 83 c8 ff or $0xffffffff,%eax } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10a951: c9 leave 10a952: c3 ret =============================================================================== 0010a954 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10a954: 55 push %ebp 10a955: 89 e5 mov %esp,%ebp 10a957: 56 push %esi 10a958: 53 push %ebx 10a959: 8b 75 08 mov 0x8(%ebp),%esi 10a95c: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10a95f: 85 f6 test %esi,%esi 10a961: 74 16 je 10a979 <== NEVER TAKEN 10a963: e8 b8 d0 ff ff call 107a20 10a968: 39 c6 cmp %eax,%esi 10a96a: 74 0d je 10a979 rtems_set_errno_and_return_minus_one( ESRCH ); 10a96c: e8 df 73 00 00 call 111d50 <__errno> 10a971: c7 00 03 00 00 00 movl $0x3,(%eax) 10a977: eb 0f jmp 10a988 if ( !interval ) 10a979: 85 db test %ebx,%ebx 10a97b: 75 10 jne 10a98d rtems_set_errno_and_return_minus_one( EINVAL ); 10a97d: e8 ce 73 00 00 call 111d50 <__errno> 10a982: c7 00 16 00 00 00 movl $0x16,(%eax) 10a988: 83 c8 ff or $0xffffffff,%eax 10a98b: eb 13 jmp 10a9a0 _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10a98d: 50 push %eax 10a98e: 50 push %eax 10a98f: 53 push %ebx 10a990: ff 35 a0 52 12 00 pushl 0x1252a0 10a996: e8 89 30 00 00 call 10da24 <_Timespec_From_ticks> return 0; 10a99b: 83 c4 10 add $0x10,%esp 10a99e: 31 c0 xor %eax,%eax } 10a9a0: 8d 65 f8 lea -0x8(%ebp),%esp 10a9a3: 5b pop %ebx 10a9a4: 5e pop %esi 10a9a5: c9 leave 10a9a6: c3 ret =============================================================================== 0010d040 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10d040: 55 push %ebp 10d041: 89 e5 mov %esp,%ebp 10d043: 57 push %edi 10d044: 56 push %esi 10d045: 53 push %ebx 10d046: 83 ec 2c sub $0x2c,%esp 10d049: 8b 75 08 mov 0x8(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10d04c: a1 c8 a4 12 00 mov 0x12a4c8,%eax 10d051: 40 inc %eax 10d052: a3 c8 a4 12 00 mov %eax,0x12a4c8 va_list arg; mode_t mode; unsigned int value = 0; 10d057: 31 ff xor %edi,%edi POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10d059: 8b 45 0c mov 0xc(%ebp),%eax 10d05c: 25 00 02 00 00 and $0x200,%eax 10d061: 89 45 d4 mov %eax,-0x2c(%ebp) 10d064: 74 03 je 10d069 va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10d066: 8b 7d 14 mov 0x14(%ebp),%edi va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10d069: 52 push %edx 10d06a: 52 push %edx 10d06b: 8d 45 e4 lea -0x1c(%ebp),%eax 10d06e: 50 push %eax 10d06f: 56 push %esi 10d070: e8 7b 59 00 00 call 1129f0 <_POSIX_Semaphore_Name_to_id> 10d075: 89 c3 mov %eax,%ebx * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10d077: 83 c4 10 add $0x10,%esp 10d07a: 85 c0 test %eax,%eax 10d07c: 74 19 je 10d097 /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10d07e: 83 f8 02 cmp $0x2,%eax 10d081: 75 06 jne 10d089 <== NEVER TAKEN 10d083: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10d087: 75 59 jne 10d0e2 _Thread_Enable_dispatch(); 10d089: e8 74 27 00 00 call 10f802 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10d08e: e8 d9 7f 00 00 call 11506c <__errno> 10d093: 89 18 mov %ebx,(%eax) 10d095: eb 1f jmp 10d0b6 /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10d097: 8b 45 0c mov 0xc(%ebp),%eax 10d09a: 25 00 0a 00 00 and $0xa00,%eax 10d09f: 3d 00 0a 00 00 cmp $0xa00,%eax 10d0a4: 75 15 jne 10d0bb _Thread_Enable_dispatch(); 10d0a6: e8 57 27 00 00 call 10f802 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10d0ab: e8 bc 7f 00 00 call 11506c <__errno> 10d0b0: c7 00 11 00 00 00 movl $0x11,(%eax) 10d0b6: 83 c8 ff or $0xffffffff,%eax 10d0b9: eb 4a jmp 10d105 10d0bb: 50 push %eax } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10d0bc: 8d 45 dc lea -0x24(%ebp),%eax 10d0bf: 50 push %eax 10d0c0: ff 75 e4 pushl -0x1c(%ebp) 10d0c3: 68 90 a7 12 00 push $0x12a790 10d0c8: e8 e3 1c 00 00 call 10edb0 <_Objects_Get> 10d0cd: 89 45 e0 mov %eax,-0x20(%ebp) the_semaphore->open_count += 1; 10d0d0: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10d0d3: e8 2a 27 00 00 call 10f802 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10d0d8: e8 25 27 00 00 call 10f802 <_Thread_Enable_dispatch> goto return_id; 10d0dd: 83 c4 10 add $0x10,%esp 10d0e0: eb 1d jmp 10d0ff /* * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status =_POSIX_Semaphore_Create_support( 10d0e2: 8d 45 e0 lea -0x20(%ebp),%eax 10d0e5: 50 push %eax 10d0e6: 57 push %edi 10d0e7: 6a 00 push $0x0 10d0e9: 56 push %esi 10d0ea: e8 cd 57 00 00 call 1128bc <_POSIX_Semaphore_Create_support> 10d0ef: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10d0f1: e8 0c 27 00 00 call 10f802 <_Thread_Enable_dispatch> if ( status == -1 ) 10d0f6: 83 c4 10 add $0x10,%esp return SEM_FAILED; 10d0f9: 83 c8 ff or $0xffffffff,%eax * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 10d0fc: 43 inc %ebx 10d0fd: 74 06 je 10d105 return_id: #if defined(RTEMS_USE_16_BIT_OBJECT) the_semaphore->Semaphore_id = the_semaphore->Object.id; id = &the_semaphore->Semaphore_id; #else id = (sem_t *)&the_semaphore->Object.id; 10d0ff: 8b 45 e0 mov -0x20(%ebp),%eax 10d102: 83 c0 08 add $0x8,%eax #endif return id; } 10d105: 8d 65 f4 lea -0xc(%ebp),%esp 10d108: 5b pop %ebx 10d109: 5e pop %esi 10d10a: 5f pop %edi 10d10b: c9 leave 10d10c: c3 ret =============================================================================== 0010a7d8 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10a7d8: 55 push %ebp 10a7d9: 89 e5 mov %esp,%ebp 10a7db: 57 push %edi 10a7dc: 56 push %esi 10a7dd: 53 push %ebx 10a7de: 83 ec 1c sub $0x1c,%esp 10a7e1: 8b 5d 08 mov 0x8(%ebp),%ebx 10a7e4: 8b 55 0c mov 0xc(%ebp),%edx 10a7e7: 8b 45 10 mov 0x10(%ebp),%eax ISR_Level level; if ( oact ) 10a7ea: 85 c0 test %eax,%eax 10a7ec: 74 12 je 10a800 *oact = _POSIX_signals_Vectors[ sig ]; 10a7ee: 6b f3 0c imul $0xc,%ebx,%esi 10a7f1: 81 c6 a0 68 12 00 add $0x1268a0,%esi 10a7f7: b9 03 00 00 00 mov $0x3,%ecx 10a7fc: 89 c7 mov %eax,%edi 10a7fe: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10a800: 85 db test %ebx,%ebx 10a802: 74 0d je 10a811 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a804: 8d 43 ff lea -0x1(%ebx),%eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10a807: 83 f8 1f cmp $0x1f,%eax 10a80a: 77 05 ja 10a811 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10a80c: 83 fb 09 cmp $0x9,%ebx 10a80f: 75 10 jne 10a821 rtems_set_errno_and_return_minus_one( EINVAL ); 10a811: e8 ce 77 00 00 call 111fe4 <__errno> 10a816: c7 00 16 00 00 00 movl $0x16,(%eax) 10a81c: 83 c8 ff or $0xffffffff,%eax 10a81f: eb 57 jmp 10a878 * now (signals not posted when SIG_IGN). * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; 10a821: 31 c0 xor %eax,%eax /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10a823: 85 d2 test %edx,%edx 10a825: 74 51 je 10a878 <== NEVER TAKEN /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 10a827: 9c pushf 10a828: fa cli 10a829: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10a82c: 83 7a 08 00 cmpl $0x0,0x8(%edx) 10a830: 75 1a jne 10a84c _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10a832: 6b f3 0c imul $0xc,%ebx,%esi 10a835: 8d 86 a0 68 12 00 lea 0x1268a0(%esi),%eax 10a83b: 81 c6 9c 09 12 00 add $0x12099c,%esi 10a841: b9 03 00 00 00 mov $0x3,%ecx 10a846: 89 c7 mov %eax,%edi 10a848: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a84a: eb 26 jmp 10a872 } else { _POSIX_signals_Clear_process_signals( sig ); 10a84c: 83 ec 0c sub $0xc,%esp 10a84f: 53 push %ebx 10a850: 89 55 e0 mov %edx,-0x20(%ebp) 10a853: e8 74 4e 00 00 call 10f6cc <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10a858: 6b db 0c imul $0xc,%ebx,%ebx 10a85b: 81 c3 a0 68 12 00 add $0x1268a0,%ebx 10a861: b9 03 00 00 00 mov $0x3,%ecx 10a866: 8b 55 e0 mov -0x20(%ebp),%edx 10a869: 89 df mov %ebx,%edi 10a86b: 89 d6 mov %edx,%esi 10a86d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a86f: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10a872: ff 75 e4 pushl -0x1c(%ebp) 10a875: 9d popf * now (signals not posted when SIG_IGN). * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; 10a876: 31 c0 xor %eax,%eax } 10a878: 8d 65 f4 lea -0xc(%ebp),%esp 10a87b: 5b pop %ebx 10a87c: 5e pop %esi 10a87d: 5f pop %edi 10a87e: c9 leave 10a87f: c3 ret =============================================================================== 0010aba3 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10aba3: 55 push %ebp 10aba4: 89 e5 mov %esp,%ebp 10aba6: 57 push %edi 10aba7: 56 push %esi 10aba8: 53 push %ebx 10aba9: 83 ec 3c sub $0x3c,%esp 10abac: 8b 75 08 mov 0x8(%ebp),%esi 10abaf: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10abb2: 85 f6 test %esi,%esi 10abb4: 74 24 je 10abda /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10abb6: 85 db test %ebx,%ebx 10abb8: 74 30 je 10abea if ( !_Timespec_Is_valid( timeout ) ) 10abba: 83 ec 0c sub $0xc,%esp 10abbd: 53 push %ebx 10abbe: e8 25 31 00 00 call 10dce8 <_Timespec_Is_valid> 10abc3: 83 c4 10 add $0x10,%esp 10abc6: 84 c0 test %al,%al 10abc8: 74 10 je 10abda rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10abca: 83 ec 0c sub $0xc,%esp 10abcd: 53 push %ebx 10abce: e8 6d 31 00 00 call 10dd40 <_Timespec_To_ticks> if ( !interval ) 10abd3: 83 c4 10 add $0x10,%esp 10abd6: 85 c0 test %eax,%eax 10abd8: 75 12 jne 10abec <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10abda: e8 ad 79 00 00 call 11258c <__errno> 10abdf: c7 00 16 00 00 00 movl $0x16,(%eax) 10abe5: e9 39 01 00 00 jmp 10ad23 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; 10abea: 31 c0 xor %eax,%eax /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10abec: 8b 7d 0c mov 0xc(%ebp),%edi 10abef: 85 ff test %edi,%edi 10abf1: 75 03 jne 10abf6 10abf3: 8d 7d dc lea -0x24(%ebp),%edi the_thread = _Thread_Executing; 10abf6: 8b 15 6c 68 12 00 mov 0x12686c,%edx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10abfc: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx 10ac02: 89 4d d4 mov %ecx,-0x2c(%ebp) * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10ac05: 9c pushf 10ac06: fa cli 10ac07: 8f 45 d0 popl -0x30(%ebp) if ( *set & api->signals_pending ) { 10ac0a: 8b 1e mov (%esi),%ebx 10ac0c: 89 5d c4 mov %ebx,-0x3c(%ebp) 10ac0f: 8b 5d d4 mov -0x2c(%ebp),%ebx 10ac12: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx 10ac18: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac1b: 74 32 je 10ac4f /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10ac1d: 83 ec 0c sub $0xc,%esp 10ac20: 51 push %ecx 10ac21: e8 3e ff ff ff call 10ab64 <_POSIX_signals_Get_lowest> 10ac26: 89 07 mov %eax,(%edi) _POSIX_signals_Clear_signals( 10ac28: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac2f: 6a 00 push $0x0 10ac31: 57 push %edi 10ac32: 50 push %eax 10ac33: 53 push %ebx 10ac34: e8 df 50 00 00 call 10fd18 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10ac39: ff 75 d0 pushl -0x30(%ebp) 10ac3c: 9d popf the_info->si_code = SI_USER; 10ac3d: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac44: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return the_info->si_signo; 10ac4b: 8b 1f mov (%edi),%ebx 10ac4d: eb 3d jmp 10ac8c } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10ac4f: 8b 0d 94 6a 12 00 mov 0x126a94,%ecx 10ac55: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac58: 74 3a je 10ac94 signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 10ac5a: 83 ec 0c sub $0xc,%esp 10ac5d: 51 push %ecx 10ac5e: e8 01 ff ff ff call 10ab64 <_POSIX_signals_Get_lowest> 10ac63: 89 c3 mov %eax,%ebx _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10ac65: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac6c: 6a 01 push $0x1 10ac6e: 57 push %edi 10ac6f: 50 push %eax 10ac70: ff 75 d4 pushl -0x2c(%ebp) 10ac73: e8 a0 50 00 00 call 10fd18 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 10ac78: ff 75 d0 pushl -0x30(%ebp) 10ac7b: 9d popf the_info->si_signo = signo; 10ac7c: 89 1f mov %ebx,(%edi) the_info->si_code = SI_USER; 10ac7e: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac85: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return signo; 10ac8c: 83 c4 20 add $0x20,%esp 10ac8f: e9 92 00 00 00 jmp 10ad26 } the_info->si_signo = -1; 10ac94: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10ac9a: 8b 0d 20 63 12 00 mov 0x126320,%ecx 10aca0: 41 inc %ecx 10aca1: 89 0d 20 63 12 00 mov %ecx,0x126320 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10aca7: c7 42 44 2c 6a 12 00 movl $0x126a2c,0x44(%edx) the_thread->Wait.return_code = EINTR; 10acae: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) the_thread->Wait.option = *set; 10acb5: 8b 0e mov (%esi),%ecx 10acb7: 89 4a 30 mov %ecx,0x30(%edx) the_thread->Wait.return_argument = the_info; 10acba: 89 7a 28 mov %edi,0x28(%edx) RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10acbd: c7 05 5c 6a 12 00 01 movl $0x1,0x126a5c 10acc4: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10acc7: ff 75 d0 pushl -0x30(%ebp) 10acca: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10accb: 52 push %edx 10accc: 68 0c da 10 00 push $0x10da0c 10acd1: 50 push %eax 10acd2: 68 2c 6a 12 00 push $0x126a2c 10acd7: e8 54 2a 00 00 call 10d730 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10acdc: e8 cd 25 00 00 call 10d2ae <_Thread_Enable_dispatch> /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); 10ace1: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ace8: 6a 00 push $0x0 10acea: 57 push %edi 10aceb: ff 37 pushl (%edi) 10aced: ff 75 d4 pushl -0x2c(%ebp) 10acf0: e8 23 50 00 00 call 10fd18 <_POSIX_signals_Clear_signals> /* Set errno only if return code is not EINTR or * if EINTR was caused by a signal being caught, which * was not in our set. */ if ( (_Thread_Executing->Wait.return_code != EINTR) 10acf5: 83 c4 20 add $0x20,%esp 10acf8: a1 6c 68 12 00 mov 0x12686c,%eax 10acfd: 83 78 34 04 cmpl $0x4,0x34(%eax) 10ad01: 75 10 jne 10ad13 || !(*set & signo_to_mask( the_info->si_signo )) ) { 10ad03: 8b 1f mov (%edi),%ebx 10ad05: 8d 4b ff lea -0x1(%ebx),%ecx 10ad08: b8 01 00 00 00 mov $0x1,%eax 10ad0d: d3 e0 shl %cl,%eax 10ad0f: 85 06 test %eax,(%esi) 10ad11: 75 13 jne 10ad26 errno = _Thread_Executing->Wait.return_code; 10ad13: e8 74 78 00 00 call 11258c <__errno> 10ad18: 8b 15 6c 68 12 00 mov 0x12686c,%edx 10ad1e: 8b 52 34 mov 0x34(%edx),%edx 10ad21: 89 10 mov %edx,(%eax) return -1; 10ad23: 83 cb ff or $0xffffffff,%ebx } return the_info->si_signo; } 10ad26: 89 d8 mov %ebx,%eax 10ad28: 8d 65 f4 lea -0xc(%ebp),%esp 10ad2b: 5b pop %ebx 10ad2c: 5e pop %esi 10ad2d: 5f pop %edi 10ad2e: c9 leave 10ad2f: c3 ret =============================================================================== 0010ca14 : int sigwait( const sigset_t *set, int *sig ) { 10ca14: 55 push %ebp 10ca15: 89 e5 mov %esp,%ebp 10ca17: 53 push %ebx 10ca18: 83 ec 08 sub $0x8,%esp 10ca1b: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10ca1e: 6a 00 push $0x0 10ca20: 6a 00 push $0x0 10ca22: ff 75 08 pushl 0x8(%ebp) 10ca25: e8 45 fe ff ff call 10c86f 10ca2a: 89 c2 mov %eax,%edx if ( status != -1 ) { 10ca2c: 83 c4 10 add $0x10,%esp 10ca2f: 83 f8 ff cmp $0xffffffff,%eax 10ca32: 74 0a je 10ca3e if ( sig ) *sig = status; return 0; 10ca34: 31 c0 xor %eax,%eax int status; status = sigtimedwait( set, NULL, NULL ); if ( status != -1 ) { if ( sig ) 10ca36: 85 db test %ebx,%ebx 10ca38: 74 0b je 10ca45 <== NEVER TAKEN *sig = status; 10ca3a: 89 13 mov %edx,(%ebx) 10ca3c: eb 07 jmp 10ca45 return 0; } return errno; 10ca3e: e8 61 73 00 00 call 113da4 <__errno> 10ca43: 8b 00 mov (%eax),%eax } 10ca45: 8b 5d fc mov -0x4(%ebp),%ebx 10ca48: c9 leave 10ca49: c3 ret =============================================================================== 0010a02c : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10a02c: 55 push %ebp 10a02d: 89 e5 mov %esp,%ebp 10a02f: 56 push %esi 10a030: 53 push %ebx 10a031: 8b 5d 0c mov 0xc(%ebp),%ebx 10a034: 8b 75 10 mov 0x10(%ebp),%esi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10a037: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10a03b: 75 1d jne 10a05a rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10a03d: 85 f6 test %esi,%esi 10a03f: 74 19 je 10a05a /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10a041: 85 db test %ebx,%ebx 10a043: 74 22 je 10a067 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10a045: 8b 03 mov (%ebx),%eax 10a047: 48 dec %eax 10a048: 83 f8 01 cmp $0x1,%eax 10a04b: 77 0d ja 10a05a <== NEVER TAKEN ( evp->sigev_notify != SIGEV_SIGNAL ) ) { /* The value of the field sigev_notify is not valid */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !evp->sigev_signo ) 10a04d: 8b 43 04 mov 0x4(%ebx),%eax 10a050: 85 c0 test %eax,%eax 10a052: 74 06 je 10a05a <== NEVER TAKEN static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a054: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10a055: 83 f8 1f cmp $0x1f,%eax 10a058: 76 0d jbe 10a067 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10a05a: e8 11 7d 00 00 call 111d70 <__errno> 10a05f: c7 00 16 00 00 00 movl $0x16,(%eax) 10a065: eb 2f jmp 10a096 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a067: a1 34 63 12 00 mov 0x126334,%eax 10a06c: 40 inc %eax 10a06d: a3 34 63 12 00 mov %eax,0x126334 * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void ) { return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information ); 10a072: 83 ec 0c sub $0xc,%esp 10a075: 68 3c 66 12 00 push $0x12663c 10a07a: e8 7d 1b 00 00 call 10bbfc <_Objects_Allocate> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10a07f: 83 c4 10 add $0x10,%esp 10a082: 85 c0 test %eax,%eax 10a084: 75 18 jne 10a09e _Thread_Enable_dispatch(); 10a086: e8 7f 29 00 00 call 10ca0a <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10a08b: e8 e0 7c 00 00 call 111d70 <__errno> 10a090: c7 00 0b 00 00 00 movl $0xb,(%eax) 10a096: 83 c8 ff or $0xffffffff,%eax 10a099: e9 83 00 00 00 jmp 10a121 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10a09e: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10a0a2: 8b 15 80 68 12 00 mov 0x126880,%edx 10a0a8: 8b 52 08 mov 0x8(%edx),%edx 10a0ab: 89 50 38 mov %edx,0x38(%eax) if ( evp != NULL ) { 10a0ae: 85 db test %ebx,%ebx 10a0b0: 74 11 je 10a0c3 ptimer->inf.sigev_notify = evp->sigev_notify; 10a0b2: 8b 13 mov (%ebx),%edx 10a0b4: 89 50 40 mov %edx,0x40(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10a0b7: 8b 53 04 mov 0x4(%ebx),%edx 10a0ba: 89 50 44 mov %edx,0x44(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10a0bd: 8b 53 08 mov 0x8(%ebx),%edx 10a0c0: 89 50 48 mov %edx,0x48(%eax) } ptimer->overrun = 0; 10a0c3: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) ptimer->timer_data.it_value.tv_sec = 0; 10a0ca: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10a0d1: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10a0d8: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10a0df: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10a0e6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10a0ed: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10a0f4: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10a0fb: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a102: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a105: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a108: 8b 0d 58 66 12 00 mov 0x126658,%ecx 10a10e: 89 04 99 mov %eax,(%ecx,%ebx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10a111: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 10a118: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10a11a: e8 eb 28 00 00 call 10ca0a <_Thread_Enable_dispatch> return 0; 10a11f: 31 c0 xor %eax,%eax } 10a121: 8d 65 f8 lea -0x8(%ebp),%esp 10a124: 5b pop %ebx 10a125: 5e pop %esi 10a126: c9 leave 10a127: c3 ret =============================================================================== 0010a128 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10a128: 55 push %ebp 10a129: 89 e5 mov %esp,%ebp 10a12b: 57 push %edi 10a12c: 56 push %esi 10a12d: 53 push %ebx 10a12e: 83 ec 2c sub $0x2c,%esp 10a131: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10a134: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a138: 0f 84 58 01 00 00 je 10a296 <== NEVER TAKEN /* * First, it verifies if the structure "value" is correct * if the number of nanoseconds is not correct return EINVAL */ if ( !_Timespec_Is_valid( &(value->it_value) ) ) { 10a13e: 83 ec 0c sub $0xc,%esp 10a141: 8b 45 10 mov 0x10(%ebp),%eax 10a144: 83 c0 08 add $0x8,%eax 10a147: 50 push %eax 10a148: e8 1b 33 00 00 call 10d468 <_Timespec_Is_valid> 10a14d: 83 c4 10 add $0x10,%esp 10a150: 84 c0 test %al,%al 10a152: 0f 84 3e 01 00 00 je 10a296 rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 10a158: 83 ec 0c sub $0xc,%esp 10a15b: ff 75 10 pushl 0x10(%ebp) 10a15e: e8 05 33 00 00 call 10d468 <_Timespec_Is_valid> 10a163: 83 c4 10 add $0x10,%esp 10a166: 84 c0 test %al,%al 10a168: 0f 84 28 01 00 00 je 10a296 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10a16e: 85 db test %ebx,%ebx 10a170: 74 09 je 10a17b 10a172: 83 fb 04 cmp $0x4,%ebx 10a175: 0f 85 1b 01 00 00 jne 10a296 rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10a17b: 8d 7d cc lea -0x34(%ebp),%edi 10a17e: b9 04 00 00 00 mov $0x4,%ecx 10a183: 8b 75 10 mov 0x10(%ebp),%esi 10a186: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 10a188: 83 fb 04 cmp $0x4,%ebx 10a18b: 75 2f jne 10a1bc struct timespec now; _TOD_Get( &now ); 10a18d: 83 ec 0c sub $0xc,%esp 10a190: 8d 5d dc lea -0x24(%ebp),%ebx 10a193: 53 push %ebx 10a194: e8 b3 15 00 00 call 10b74c <_TOD_Get> /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 10a199: 59 pop %ecx 10a19a: 5e pop %esi 10a19b: 8d 75 d4 lea -0x2c(%ebp),%esi 10a19e: 56 push %esi 10a19f: 53 push %ebx 10a1a0: e8 9f 32 00 00 call 10d444 <_Timespec_Greater_than> 10a1a5: 83 c4 10 add $0x10,%esp 10a1a8: 84 c0 test %al,%al 10a1aa: 0f 85 e6 00 00 00 jne 10a296 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 10a1b0: 52 push %edx 10a1b1: 56 push %esi 10a1b2: 56 push %esi 10a1b3: 53 push %ebx 10a1b4: e8 d3 32 00 00 call 10d48c <_Timespec_Subtract> 10a1b9: 83 c4 10 add $0x10,%esp timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) _Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location ); 10a1bc: 50 push %eax /* If the function reaches this point, then it will be necessary to do * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); 10a1bd: 8d 45 e4 lea -0x1c(%ebp),%eax 10a1c0: 50 push %eax 10a1c1: ff 75 08 pushl 0x8(%ebp) 10a1c4: 68 3c 66 12 00 push $0x12663c 10a1c9: e8 5e 1e 00 00 call 10c02c <_Objects_Get> 10a1ce: 89 c3 mov %eax,%ebx switch ( location ) { 10a1d0: 83 c4 10 add $0x10,%esp 10a1d3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10a1d7: 0f 85 b9 00 00 00 jne 10a296 case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 10a1dd: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10a1e1: 75 3b jne 10a21e 10a1e3: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10a1e7: 75 35 jne 10a21e /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10a1e9: 83 ec 0c sub $0xc,%esp 10a1ec: 8d 40 10 lea 0x10(%eax),%eax 10a1ef: 50 push %eax 10a1f0: e8 5b 36 00 00 call 10d850 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 10a1f5: 83 c4 10 add $0x10,%esp 10a1f8: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a1fc: 74 0d je 10a20b *ovalue = ptimer->timer_data; 10a1fe: 8d 73 54 lea 0x54(%ebx),%esi 10a201: b9 04 00 00 00 mov $0x4,%ecx 10a206: 8b 7d 14 mov 0x14(%ebp),%edi 10a209: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* The new data are set */ ptimer->timer_data = normalize; 10a20b: 8d 7b 54 lea 0x54(%ebx),%edi 10a20e: 8d 75 cc lea -0x34(%ebp),%esi 10a211: b9 04 00 00 00 mov $0x4,%ecx 10a216: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a218: c6 43 3c 04 movb $0x4,0x3c(%ebx) 10a21c: eb 35 jmp 10a253 _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10a21e: 83 ec 0c sub $0xc,%esp 10a221: ff 75 10 pushl 0x10(%ebp) 10a224: e8 97 32 00 00 call 10d4c0 <_Timespec_To_ticks> 10a229: 89 43 64 mov %eax,0x64(%ebx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 10a22c: 8d 45 d4 lea -0x2c(%ebp),%eax 10a22f: 89 04 24 mov %eax,(%esp) 10a232: e8 89 32 00 00 call 10d4c0 <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 10a237: 89 1c 24 mov %ebx,(%esp) 10a23a: 68 ac a2 10 00 push $0x10a2ac 10a23f: ff 73 08 pushl 0x8(%ebx) 10a242: 50 push %eax 10a243: 8d 43 10 lea 0x10(%ebx),%eax 10a246: 50 push %eax 10a247: e8 44 57 00 00 call 10f990 <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10a24c: 83 c4 20 add $0x20,%esp 10a24f: 84 c0 test %al,%al 10a251: 75 07 jne 10a25a _Thread_Enable_dispatch(); 10a253: e8 b2 27 00 00 call 10ca0a <_Thread_Enable_dispatch> 10a258: eb 38 jmp 10a292 /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10a25a: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a25e: 74 0d je 10a26d *ovalue = ptimer->timer_data; 10a260: 8d 73 54 lea 0x54(%ebx),%esi 10a263: b9 04 00 00 00 mov $0x4,%ecx 10a268: 8b 7d 14 mov 0x14(%ebp),%edi 10a26b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 10a26d: 8d 7b 54 lea 0x54(%ebx),%edi 10a270: 8d 75 cc lea -0x34(%ebp),%esi 10a273: b9 04 00 00 00 mov $0x4,%ecx 10a278: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a27a: c6 43 3c 03 movb $0x3,0x3c(%ebx) _TOD_Get( &ptimer->time ); 10a27e: 83 ec 0c sub $0xc,%esp 10a281: 83 c3 6c add $0x6c,%ebx 10a284: 53 push %ebx 10a285: e8 c2 14 00 00 call 10b74c <_TOD_Get> _Thread_Enable_dispatch(); 10a28a: e8 7b 27 00 00 call 10ca0a <_Thread_Enable_dispatch> return 0; 10a28f: 83 c4 10 add $0x10,%esp 10a292: 31 c0 xor %eax,%eax 10a294: eb 0e jmp 10a2a4 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a296: e8 d5 7a 00 00 call 111d70 <__errno> 10a29b: c7 00 16 00 00 00 movl $0x16,(%eax) 10a2a1: 83 c8 ff or $0xffffffff,%eax } 10a2a4: 8d 65 f4 lea -0xc(%ebp),%esp 10a2a7: 5b pop %ebx 10a2a8: 5e pop %esi 10a2a9: 5f pop %edi 10a2aa: c9 leave 10a2ab: c3 ret =============================================================================== 00109f68 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 109f68: 55 push %ebp 109f69: 89 e5 mov %esp,%ebp 109f6b: 57 push %edi 109f6c: 56 push %esi 109f6d: 53 push %ebx 109f6e: 83 ec 1c sub $0x1c,%esp 109f71: 8b 75 08 mov 0x8(%ebp),%esi /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 109f74: 83 3d 44 6c 12 00 00 cmpl $0x0,0x126c44 109f7b: 75 2c jne 109fa9 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 109f7d: c7 05 30 6c 12 00 00 movl $0x0,0x126c30 109f84: 00 00 00 the_watchdog->routine = routine; 109f87: c7 05 44 6c 12 00 30 movl $0x109f30,0x126c44 109f8e: 9f 10 00 the_watchdog->id = id; 109f91: c7 05 48 6c 12 00 00 movl $0x0,0x126c48 109f98: 00 00 00 the_watchdog->user_data = user_data; 109f9b: c7 05 4c 6c 12 00 00 movl $0x0,0x126c4c 109fa2: 00 00 00 useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109fa5: 31 db xor %ebx,%ebx 109fa7: eb 4f jmp 109ff8 if ( !the_timer->routine ) { _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 109fa9: 83 ec 0c sub $0xc,%esp 109fac: 68 28 6c 12 00 push $0x126c28 109fb1: e8 82 34 00 00 call 10d438 <_Watchdog_Remove> if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 109fb6: 83 e8 02 sub $0x2,%eax 109fb9: 83 c4 10 add $0x10,%esp useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109fbc: 31 db xor %ebx,%ebx _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 109fbe: 83 f8 01 cmp $0x1,%eax 109fc1: 77 35 ja 109ff8 <== NEVER TAKEN * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 109fc3: a1 3c 6c 12 00 mov 0x126c3c,%eax 109fc8: 03 05 34 6c 12 00 add 0x126c34,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fce: 57 push %edi 109fcf: 57 push %edi 109fd0: 8d 55 e0 lea -0x20(%ebp),%edx 109fd3: 52 push %edx * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 109fd4: 2b 05 40 6c 12 00 sub 0x126c40,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fda: 50 push %eax 109fdb: e8 00 30 00 00 call 10cfe0 <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 109fe0: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx remaining += tp.tv_nsec / 1000; 109fe7: 8b 45 e4 mov -0x1c(%ebp),%eax 109fea: bf e8 03 00 00 mov $0x3e8,%edi 109fef: 99 cltd 109ff0: f7 ff idiv %edi 109ff2: 8d 1c 08 lea (%eax,%ecx,1),%ebx 109ff5: 83 c4 10 add $0x10,%esp /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 109ff8: 85 f6 test %esi,%esi 109ffa: 74 44 je 10a040 <== NEVER TAKEN Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 109ffc: b9 40 42 0f 00 mov $0xf4240,%ecx 10a001: 89 f0 mov %esi,%eax 10a003: 31 d2 xor %edx,%edx 10a005: f7 f1 div %ecx 10a007: 89 45 e0 mov %eax,-0x20(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10a00a: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx 10a010: 89 55 e4 mov %edx,-0x1c(%ebp) ticks = _Timespec_To_ticks( &tp ); 10a013: 83 ec 0c sub $0xc,%esp 10a016: 8d 75 e0 lea -0x20(%ebp),%esi 10a019: 56 push %esi 10a01a: e8 1d 30 00 00 call 10d03c <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 10a01f: 89 34 24 mov %esi,(%esp) 10a022: e8 15 30 00 00 call 10d03c <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a027: a3 34 6c 12 00 mov %eax,0x126c34 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a02c: 59 pop %ecx 10a02d: 5e pop %esi 10a02e: 68 28 6c 12 00 push $0x126c28 10a033: 68 14 64 12 00 push $0x126414 10a038: e8 e3 32 00 00 call 10d320 <_Watchdog_Insert> 10a03d: 83 c4 10 add $0x10,%esp } return remaining; } 10a040: 89 d8 mov %ebx,%eax 10a042: 8d 65 f4 lea -0xc(%ebp),%esp 10a045: 5b pop %ebx 10a046: 5e pop %esi 10a047: 5f pop %edi 10a048: c9 leave 10a049: c3 ret