=============================================================================== 0010ce60 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10ce60: 55 push %ebp 10ce61: 89 e5 mov %esp,%ebp 10ce63: 53 push %ebx 10ce64: 83 ec 04 sub $0x4,%esp 10ce67: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10ce6a: 8b 15 78 88 12 00 mov 0x128878,%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 ); 10ce70: 9c pushf 10ce71: fa cli 10ce72: 58 pop %eax if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10ce73: 8b 4b 44 mov 0x44(%ebx),%ecx 10ce76: 85 c9 test %ecx,%ecx 10ce78: 75 0b jne 10ce85 <_CORE_RWLock_Release+0x25> _ISR_Enable( level ); 10ce7a: 50 push %eax 10ce7b: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ce7c: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) return CORE_RWLOCK_SUCCESSFUL; 10ce83: eb 72 jmp 10cef7 <_CORE_RWLock_Release+0x97> } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10ce85: 49 dec %ecx 10ce86: 75 0f jne 10ce97 <_CORE_RWLock_Release+0x37> the_rwlock->number_of_readers -= 1; 10ce88: 8b 4b 48 mov 0x48(%ebx),%ecx 10ce8b: 49 dec %ecx 10ce8c: 89 4b 48 mov %ecx,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10ce8f: 85 c9 test %ecx,%ecx 10ce91: 74 04 je 10ce97 <_CORE_RWLock_Release+0x37> /* must be unlocked again */ _ISR_Enable( level ); 10ce93: 50 push %eax 10ce94: 9d popf return CORE_RWLOCK_SUCCESSFUL; 10ce95: eb 60 jmp 10cef7 <_CORE_RWLock_Release+0x97> } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce97: 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; 10ce9e: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10cea5: 50 push %eax 10cea6: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10cea7: 83 ec 0c sub $0xc,%esp 10ceaa: 53 push %ebx 10ceab: e8 f0 17 00 00 call 10e6a0 <_Thread_queue_Dequeue> if ( next ) { 10ceb0: 83 c4 10 add $0x10,%esp 10ceb3: 85 c0 test %eax,%eax 10ceb5: 74 40 je 10cef7 <_CORE_RWLock_Release+0x97> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10ceb7: 83 78 30 01 cmpl $0x1,0x30(%eax) 10cebb: 75 09 jne 10cec6 <_CORE_RWLock_Release+0x66> the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10cebd: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10cec4: eb 31 jmp 10cef7 <_CORE_RWLock_Release+0x97> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10cec6: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10cec9: 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 ); 10ced0: 83 ec 0c sub $0xc,%esp 10ced3: 53 push %ebx 10ced4: e8 bf 1b 00 00 call 10ea98 <_Thread_queue_First> if ( !next || 10ced9: 83 c4 10 add $0x10,%esp 10cedc: 85 c0 test %eax,%eax 10cede: 74 17 je 10cef7 <_CORE_RWLock_Release+0x97> 10cee0: 83 78 30 01 cmpl $0x1,0x30(%eax) 10cee4: 74 11 je 10cef7 <_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; 10cee6: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10cee9: 52 push %edx 10ceea: 52 push %edx 10ceeb: 50 push %eax 10ceec: 53 push %ebx 10ceed: e8 96 1a 00 00 call 10e988 <_Thread_queue_Extract> } 10cef2: 83 c4 10 add $0x10,%esp 10cef5: eb d9 jmp 10ced0 <_CORE_RWLock_Release+0x70> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cef7: 31 c0 xor %eax,%eax 10cef9: 8b 5d fc mov -0x4(%ebp),%ebx 10cefc: c9 leave 10cefd: c3 ret =============================================================================== 0010cf00 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10cf00: 55 push %ebp 10cf01: 89 e5 mov %esp,%ebp 10cf03: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cf06: 8d 45 f4 lea -0xc(%ebp),%eax 10cf09: 50 push %eax 10cf0a: ff 75 08 pushl 0x8(%ebp) 10cf0d: e8 72 14 00 00 call 10e384 <_Thread_Get> switch ( location ) { 10cf12: 83 c4 10 add $0x10,%esp 10cf15: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10cf19: 75 17 jne 10cf32 <_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 ); 10cf1b: 83 ec 0c sub $0xc,%esp 10cf1e: 50 push %eax 10cf1f: e8 40 1c 00 00 call 10eb64 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10cf24: a1 50 83 12 00 mov 0x128350,%eax 10cf29: 48 dec %eax 10cf2a: a3 50 83 12 00 mov %eax,0x128350 10cf2f: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10cf32: c9 leave 10cf33: c3 ret =============================================================================== 00112274 <_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 ) { 112274: 55 push %ebp 112275: 89 e5 mov %esp,%ebp 112277: 57 push %edi 112278: 56 push %esi 112279: 53 push %ebx 11227a: 83 ec 1c sub $0x1c,%esp 11227d: 8b 5d 08 mov 0x8(%ebp),%ebx 112280: 8b 7d 10 mov 0x10(%ebp),%edi 112283: 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; 112286: 89 7b 44 mov %edi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 112289: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 112290: 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; 112293: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) the_message_queue->notify_argument = the_argument; 11229a: 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)) { 1122a1: 89 d0 mov %edx,%eax 1122a3: f6 c2 03 test $0x3,%dl 1122a6: 74 0c je 1122b4 <_CORE_message_queue_Initialize+0x40> allocated_message_size += sizeof(uint32_t); 1122a8: 83 c0 04 add $0x4,%eax allocated_message_size &= ~(sizeof(uint32_t) - 1); 1122ab: 83 e0 fc and $0xfffffffc,%eax } if (allocated_message_size < maximum_message_size) return false; 1122ae: 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) 1122b0: 39 d0 cmp %edx,%eax 1122b2: 72 68 jb 11231c <_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)); 1122b4: 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 * 1122b7: 89 d1 mov %edx,%ecx 1122b9: 0f af cf imul %edi,%ecx (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) return false; 1122bc: 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) 1122be: 39 c1 cmp %eax,%ecx 1122c0: 72 5a jb 11231c <_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 ); 1122c2: 83 ec 0c sub $0xc,%esp 1122c5: 51 push %ecx 1122c6: 89 55 e4 mov %edx,-0x1c(%ebp) 1122c9: e8 b4 27 00 00 call 114a82 <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 1122ce: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 1122d1: 83 c4 10 add $0x10,%esp 1122d4: 85 c0 test %eax,%eax 1122d6: 8b 55 e4 mov -0x1c(%ebp),%edx 1122d9: 74 41 je 11231c <_CORE_message_queue_Initialize+0xa8> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 1122db: 52 push %edx 1122dc: 57 push %edi 1122dd: 50 push %eax 1122de: 8d 43 68 lea 0x68(%ebx),%eax 1122e1: 50 push %eax 1122e2: e8 f5 4a 00 00 call 116ddc <_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 ); 1122e7: 8d 43 54 lea 0x54(%ebx),%eax 1122ea: 89 43 50 mov %eax,0x50(%ebx) head->next = tail; head->previous = NULL; 1122ed: 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 ); 1122f4: 8d 43 50 lea 0x50(%ebx),%eax 1122f7: 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( 1122fa: 6a 06 push $0x6 1122fc: 68 80 00 00 00 push $0x80 112301: 8b 45 0c mov 0xc(%ebp),%eax 112304: 83 38 01 cmpl $0x1,(%eax) 112307: 0f 94 c0 sete %al 11230a: 0f b6 c0 movzbl %al,%eax 11230d: 50 push %eax 11230e: 53 push %ebx 11230f: e8 94 1f 00 00 call 1142a8 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 112314: 83 c4 20 add $0x20,%esp 112317: be 01 00 00 00 mov $0x1,%esi } 11231c: 89 f0 mov %esi,%eax 11231e: 8d 65 f4 lea -0xc(%ebp),%esp 112321: 5b pop %ebx 112322: 5e pop %esi 112323: 5f pop %edi 112324: c9 leave 112325: c3 ret =============================================================================== 00112328 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 112328: 55 push %ebp 112329: 89 e5 mov %esp,%ebp 11232b: 57 push %edi 11232c: 56 push %esi 11232d: 53 push %ebx 11232e: 83 ec 2c sub $0x2c,%esp 112331: 8b 55 08 mov 0x8(%ebp),%edx 112334: 8b 45 0c mov 0xc(%ebp),%eax 112337: 89 45 dc mov %eax,-0x24(%ebp) 11233a: 8b 5d 10 mov 0x10(%ebp),%ebx 11233d: 89 5d e0 mov %ebx,-0x20(%ebp) 112340: 8b 4d 14 mov 0x14(%ebp),%ecx 112343: 8b 75 1c mov 0x1c(%ebp),%esi 112346: 89 75 d4 mov %esi,-0x2c(%ebp) 112349: 8a 45 18 mov 0x18(%ebp),%al 11234c: 88 45 db mov %al,-0x25(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; executing = _Thread_Executing; 11234f: a1 f0 d9 12 00 mov 0x12d9f0,%eax executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 112354: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _ISR_Disable( level ); 11235b: 9c pushf 11235c: fa cli 11235d: 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 ); } 112360: 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 ); 112363: 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)) 112366: 39 f3 cmp %esi,%ebx 112368: 0f 84 8a 00 00 00 je 1123f8 <_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; 11236e: 8b 33 mov (%ebx),%esi head->next = new_first; 112370: 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 ); 112373: 8d 7a 50 lea 0x50(%edx),%edi 112376: 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 ) { 112379: 85 db test %ebx,%ebx 11237b: 74 7b je 1123f8 <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN the_message_queue->number_of_pending_messages -= 1; 11237d: ff 4a 48 decl 0x48(%edx) _ISR_Enable( level ); 112380: ff 75 e4 pushl -0x1c(%ebp) 112383: 9d popf *size_p = the_message->Contents.size; 112384: 8b 43 0c mov 0xc(%ebx),%eax 112387: 89 01 mov %eax,(%ecx) _Thread_Executing->Wait.count = 112389: 8b 73 08 mov 0x8(%ebx),%esi 11238c: a1 f0 d9 12 00 mov 0x12d9f0,%eax 112391: 89 70 24 mov %esi,0x24(%eax) _CORE_message_queue_Get_message_priority( the_message ); _CORE_message_queue_Copy_buffer( the_message->Contents.buffer, 112394: 8d 73 10 lea 0x10(%ebx),%esi 112397: 89 75 e4 mov %esi,-0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 11239a: 8b 09 mov (%ecx),%ecx 11239c: 8b 7d e0 mov -0x20(%ebp),%edi 11239f: 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 ); 1123a1: 83 ec 0c sub $0xc,%esp 1123a4: 52 push %edx 1123a5: 89 55 d0 mov %edx,-0x30(%ebp) 1123a8: e8 c3 1b 00 00 call 113f70 <_Thread_queue_Dequeue> if ( !the_thread ) { 1123ad: 83 c4 10 add $0x10,%esp 1123b0: 85 c0 test %eax,%eax 1123b2: 8b 55 d0 mov -0x30(%ebp),%edx 1123b5: 75 15 jne 1123cc <_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 ); 1123b7: 89 5d 0c mov %ebx,0xc(%ebp) 1123ba: 83 c2 68 add $0x68,%edx 1123bd: 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 ); } 1123c0: 8d 65 f4 lea -0xc(%ebp),%esp 1123c3: 5b pop %ebx 1123c4: 5e pop %esi 1123c5: 5f pop %edi 1123c6: c9 leave 1123c7: e9 28 fe ff ff jmp 1121f4 <_Chain_Append> CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 1123cc: 8b 48 24 mov 0x24(%eax),%ecx 1123cf: 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; 1123d2: 8b 48 30 mov 0x30(%eax),%ecx 1123d5: 89 4b 0c mov %ecx,0xc(%ebx) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 1123d8: 8b 70 2c mov 0x2c(%eax),%esi 1123db: 8b 7d e4 mov -0x1c(%ebp),%edi 1123de: 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( 1123e0: 8b 43 08 mov 0x8(%ebx),%eax 1123e3: 89 45 10 mov %eax,0x10(%ebp) 1123e6: 89 5d 0c mov %ebx,0xc(%ebp) 1123e9: 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 ); } 1123ec: 8d 65 f4 lea -0xc(%ebp),%esp 1123ef: 5b pop %ebx 1123f0: 5e pop %esi 1123f1: 5f pop %edi 1123f2: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 1123f3: e9 1c 4a 00 00 jmp 116e14 <_CORE_message_queue_Insert_message> return; } #endif } if ( !wait ) { 1123f8: 80 7d db 00 cmpb $0x0,-0x25(%ebp) 1123fc: 75 13 jne 112411 <_CORE_message_queue_Seize+0xe9> _ISR_Enable( level ); 1123fe: ff 75 e4 pushl -0x1c(%ebp) 112401: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 112402: 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 ); } 112409: 8d 65 f4 lea -0xc(%ebp),%esp 11240c: 5b pop %ebx 11240d: 5e pop %esi 11240e: 5f pop %edi 11240f: c9 leave 112410: 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; 112411: 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; 112418: 89 50 44 mov %edx,0x44(%eax) executing->Wait.id = id; 11241b: 8b 5d dc mov -0x24(%ebp),%ebx 11241e: 89 58 20 mov %ebx,0x20(%eax) executing->Wait.return_argument_second.mutable_object = buffer; 112421: 8b 75 e0 mov -0x20(%ebp),%esi 112424: 89 70 2c mov %esi,0x2c(%eax) executing->Wait.return_argument = size_p; 112427: 89 48 28 mov %ecx,0x28(%eax) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 11242a: ff 75 e4 pushl -0x1c(%ebp) 11242d: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 11242e: c7 45 10 58 43 11 00 movl $0x114358,0x10(%ebp) 112435: 8b 45 d4 mov -0x2c(%ebp),%eax 112438: 89 45 0c mov %eax,0xc(%ebp) 11243b: 89 55 08 mov %edx,0x8(%ebp) } 11243e: 8d 65 f4 lea -0xc(%ebp),%esp 112441: 5b pop %ebx 112442: 5e pop %esi 112443: 5f pop %edi 112444: 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 ); 112445: e9 32 1c 00 00 jmp 11407c <_Thread_queue_Enqueue_with_handler> =============================================================================== 0010ab98 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10ab98: 55 push %ebp 10ab99: 89 e5 mov %esp,%ebp 10ab9b: 57 push %edi 10ab9c: 56 push %esi 10ab9d: 53 push %ebx 10ab9e: 83 ec 0c sub $0xc,%esp 10aba1: 8b 55 08 mov 0x8(%ebp),%edx 10aba4: 8b 5d 0c mov 0xc(%ebp),%ebx 10aba7: 8b 45 10 mov 0x10(%ebp),%eax /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 10abaa: 8d 7a 40 lea 0x40(%edx),%edi 10abad: b9 04 00 00 00 mov $0x4,%ecx 10abb2: 89 de mov %ebx,%esi 10abb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_mutex->lock = initial_lock; 10abb6: 89 42 50 mov %eax,0x50(%edx) the_mutex->blocked_count = 0; 10abb9: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) if ( initial_lock == CORE_MUTEX_LOCKED ) { 10abc0: 85 c0 test %eax,%eax 10abc2: 75 35 jne 10abf9 <_CORE_mutex_Initialize+0x61> the_mutex->nest_count = 1; 10abc4: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx) the_mutex->holder = _Thread_Executing; 10abcb: 8b 0d 68 58 12 00 mov 0x125868,%ecx 10abd1: 89 4a 5c mov %ecx,0x5c(%edx) the_mutex->holder_id = _Thread_Executing->Object.id; 10abd4: 8b 41 08 mov 0x8(%ecx),%eax 10abd7: 89 42 60 mov %eax,0x60(%edx) STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10abda: 8b 42 48 mov 0x48(%edx),%eax if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10abdd: 83 f8 02 cmp $0x2,%eax 10abe0: 74 05 je 10abe7 <_CORE_mutex_Initialize+0x4f> 10abe2: 83 f8 03 cmp $0x3,%eax 10abe5: 75 27 jne 10ac0e <_CORE_mutex_Initialize+0x76> _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; 10abe7: b8 06 00 00 00 mov $0x6,%eax the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10abec: 8b 72 4c mov 0x4c(%edx),%esi 10abef: 39 71 14 cmp %esi,0x14(%ecx) 10abf2: 72 36 jb 10ac2a <_CORE_mutex_Initialize+0x92><== NEVER TAKEN _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = _Thread_Executing->current_priority; #endif _Thread_Executing->resource_count++; 10abf4: ff 41 1c incl 0x1c(%ecx) 10abf7: eb 15 jmp 10ac0e <_CORE_mutex_Initialize+0x76> } } else { the_mutex->nest_count = 0; 10abf9: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) the_mutex->holder = NULL; 10ac00: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) the_mutex->holder_id = 0; 10ac07: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx) } _Thread_queue_Initialize( 10ac0e: 6a 05 push $0x5 10ac10: 68 00 04 00 00 push $0x400 10ac15: 31 c0 xor %eax,%eax 10ac17: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10ac1b: 0f 95 c0 setne %al 10ac1e: 50 push %eax 10ac1f: 52 push %edx 10ac20: e8 4b 1c 00 00 call 10c870 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY, STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; 10ac25: 83 c4 10 add $0x10,%esp 10ac28: 31 c0 xor %eax,%eax } 10ac2a: 8d 65 f4 lea -0xc(%ebp),%esp 10ac2d: 5b pop %ebx 10ac2e: 5e pop %esi 10ac2f: 5f pop %edi 10ac30: c9 leave 10ac31: c3 ret =============================================================================== 0010ac81 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10ac81: 55 push %ebp 10ac82: 89 e5 mov %esp,%ebp 10ac84: 53 push %ebx 10ac85: 83 ec 14 sub $0x14,%esp 10ac88: 8b 5d 08 mov 0x8(%ebp),%ebx 10ac8b: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10ac8e: a1 40 53 12 00 mov 0x125340,%eax 10ac93: 85 c0 test %eax,%eax 10ac95: 74 19 je 10acb0 <_CORE_mutex_Seize+0x2f> 10ac97: 84 d2 test %dl,%dl 10ac99: 74 15 je 10acb0 <_CORE_mutex_Seize+0x2f><== NEVER TAKEN 10ac9b: 83 3d 9c 54 12 00 01 cmpl $0x1,0x12549c 10aca2: 76 0c jbe 10acb0 <_CORE_mutex_Seize+0x2f> 10aca4: 53 push %ebx 10aca5: 6a 12 push $0x12 10aca7: 6a 00 push $0x0 10aca9: 6a 00 push $0x0 10acab: e8 dc 05 00 00 call 10b28c <_Internal_error_Occurred> 10acb0: 51 push %ecx 10acb1: 51 push %ecx 10acb2: 8d 45 18 lea 0x18(%ebp),%eax 10acb5: 50 push %eax 10acb6: 53 push %ebx 10acb7: 88 55 f4 mov %dl,-0xc(%ebp) 10acba: e8 d5 47 00 00 call 10f494 <_CORE_mutex_Seize_interrupt_trylock> 10acbf: 83 c4 10 add $0x10,%esp 10acc2: 85 c0 test %eax,%eax 10acc4: 8a 55 f4 mov -0xc(%ebp),%dl 10acc7: 74 48 je 10ad11 <_CORE_mutex_Seize+0x90> 10acc9: 84 d2 test %dl,%dl 10accb: 75 12 jne 10acdf <_CORE_mutex_Seize+0x5e> 10accd: ff 75 18 pushl 0x18(%ebp) 10acd0: 9d popf 10acd1: a1 68 58 12 00 mov 0x125868,%eax 10acd6: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) 10acdd: eb 32 jmp 10ad11 <_CORE_mutex_Seize+0x90> 10acdf: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10ace6: a1 68 58 12 00 mov 0x125868,%eax 10aceb: 89 58 44 mov %ebx,0x44(%eax) 10acee: 8b 55 0c mov 0xc(%ebp),%edx 10acf1: 89 50 20 mov %edx,0x20(%eax) 10acf4: a1 40 53 12 00 mov 0x125340,%eax 10acf9: 40 inc %eax 10acfa: a3 40 53 12 00 mov %eax,0x125340 10acff: ff 75 18 pushl 0x18(%ebp) 10ad02: 9d popf 10ad03: 50 push %eax 10ad04: 50 push %eax 10ad05: ff 75 14 pushl 0x14(%ebp) 10ad08: 53 push %ebx 10ad09: e8 26 ff ff ff call 10ac34 <_CORE_mutex_Seize_interrupt_blocking> 10ad0e: 83 c4 10 add $0x10,%esp } 10ad11: 8b 5d fc mov -0x4(%ebp),%ebx 10ad14: c9 leave 10ad15: c3 ret =============================================================================== 0010ae3c <_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 ) { 10ae3c: 55 push %ebp 10ae3d: 89 e5 mov %esp,%ebp 10ae3f: 53 push %ebx 10ae40: 83 ec 10 sub $0x10,%esp 10ae43: 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)) ) { 10ae46: 53 push %ebx 10ae47: e8 ec 16 00 00 call 10c538 <_Thread_queue_Dequeue> 10ae4c: 89 c2 mov %eax,%edx 10ae4e: 83 c4 10 add $0x10,%esp { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10ae51: 31 c0 xor %eax,%eax if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10ae53: 85 d2 test %edx,%edx 10ae55: 75 15 jne 10ae6c <_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 ); 10ae57: 9c pushf 10ae58: fa cli 10ae59: 59 pop %ecx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10ae5a: 8b 53 48 mov 0x48(%ebx),%edx the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10ae5d: 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 ) 10ae5f: 3b 53 40 cmp 0x40(%ebx),%edx 10ae62: 73 06 jae 10ae6a <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN the_semaphore->count += 1; 10ae64: 42 inc %edx 10ae65: 89 53 48 mov %edx,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10ae68: 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 ); 10ae6a: 51 push %ecx 10ae6b: 9d popf } return status; } 10ae6c: 8b 5d fc mov -0x4(%ebp),%ebx 10ae6f: c9 leave 10ae70: c3 ret =============================================================================== 00109da0 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109da0: 55 push %ebp 109da1: 89 e5 mov %esp,%ebp 109da3: 57 push %edi 109da4: 56 push %esi 109da5: 53 push %ebx 109da6: 83 ec 2c sub $0x2c,%esp 109da9: 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 ]; 109dac: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi option_set = (rtems_option) the_thread->Wait.option; 109db2: 8b 43 30 mov 0x30(%ebx),%eax 109db5: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109db8: 9c pushf 109db9: fa cli 109dba: 58 pop %eax pending_events = api->pending_events; 109dbb: 8b 17 mov (%edi),%edx 109dbd: 89 55 d4 mov %edx,-0x2c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109dc0: 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 ) ) { 109dc3: 21 f2 and %esi,%edx 109dc5: 75 07 jne 109dce <_Event_Surrender+0x2e> _ISR_Enable( level ); 109dc7: 50 push %eax 109dc8: 9d popf return; 109dc9: e9 af 00 00 00 jmp 109e7d <_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() && 109dce: 83 3d 64 58 12 00 00 cmpl $0x0,0x125864 109dd5: 74 49 je 109e20 <_Event_Surrender+0x80> 109dd7: 3b 1d 68 58 12 00 cmp 0x125868,%ebx 109ddd: 75 41 jne 109e20 <_Event_Surrender+0x80> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109ddf: 8b 0d 3c 5c 12 00 mov 0x125c3c,%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 ) && 109de5: 83 f9 02 cmp $0x2,%ecx 109de8: 74 09 je 109df3 <_Event_Surrender+0x53> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109dea: 8b 0d 3c 5c 12 00 mov 0x125c3c,%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) || 109df0: 49 dec %ecx 109df1: 75 2d jne 109e20 <_Event_Surrender+0x80> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109df3: 39 f2 cmp %esi,%edx 109df5: 74 06 je 109dfd <_Event_Surrender+0x5d> 109df7: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109dfb: 74 1f je 109e1c <_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) ); 109dfd: 89 d6 mov %edx,%esi 109dff: f7 d6 not %esi 109e01: 23 75 d4 and -0x2c(%ebp),%esi 109e04: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 109e06: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109e0d: 8b 4b 28 mov 0x28(%ebx),%ecx 109e10: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109e12: c7 05 3c 5c 12 00 03 movl $0x3,0x125c3c 109e19: 00 00 00 } _ISR_Enable( level ); 109e1c: 50 push %eax 109e1d: 9d popf return; 109e1e: eb 5d jmp 109e7d <_Event_Surrender+0xdd> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109e20: f6 43 11 01 testb $0x1,0x11(%ebx) 109e24: 74 55 je 109e7b <_Event_Surrender+0xdb> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109e26: 39 f2 cmp %esi,%edx 109e28: 74 06 je 109e30 <_Event_Surrender+0x90> 109e2a: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109e2e: 74 4b je 109e7b <_Event_Surrender+0xdb> <== NEVER TAKEN 109e30: 89 d6 mov %edx,%esi 109e32: f7 d6 not %esi 109e34: 23 75 d4 and -0x2c(%ebp),%esi 109e37: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 109e39: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109e40: 8b 4b 28 mov 0x28(%ebx),%ecx 109e43: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109e45: 50 push %eax 109e46: 9d popf 109e47: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109e48: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109e4c: 74 06 je 109e54 <_Event_Surrender+0xb4> _ISR_Enable( level ); 109e4e: 50 push %eax 109e4f: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109e50: 51 push %ecx 109e51: 51 push %ecx 109e52: eb 17 jmp 109e6b <_Event_Surrender+0xcb> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109e54: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109e5b: 50 push %eax 109e5c: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109e5d: 83 ec 0c sub $0xc,%esp 109e60: 8d 43 48 lea 0x48(%ebx),%eax 109e63: 50 push %eax 109e64: e8 c7 30 00 00 call 10cf30 <_Watchdog_Remove> 109e69: 58 pop %eax 109e6a: 5a pop %edx 109e6b: 68 f8 ff 03 10 push $0x1003fff8 109e70: 53 push %ebx 109e71: e8 6e 20 00 00 call 10bee4 <_Thread_Clear_state> 109e76: 83 c4 10 add $0x10,%esp 109e79: eb 02 jmp 109e7d <_Event_Surrender+0xdd> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109e7b: 50 push %eax 109e7c: 9d popf } 109e7d: 8d 65 f4 lea -0xc(%ebp),%esp 109e80: 5b pop %ebx 109e81: 5e pop %esi 109e82: 5f pop %edi 109e83: c9 leave 109e84: c3 ret =============================================================================== 00109e88 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109e88: 55 push %ebp 109e89: 89 e5 mov %esp,%ebp 109e8b: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109e8e: 8d 45 f4 lea -0xc(%ebp),%eax 109e91: 50 push %eax 109e92: ff 75 08 pushl 0x8(%ebp) 109e95: e8 82 23 00 00 call 10c21c <_Thread_Get> switch ( location ) { 109e9a: 83 c4 10 add $0x10,%esp 109e9d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 109ea1: 75 49 jne 109eec <_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 ); 109ea3: 9c pushf 109ea4: fa cli 109ea5: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 109ea6: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 109ead: 3b 05 68 58 12 00 cmp 0x125868,%eax 109eb3: 75 13 jne 109ec8 <_Event_Timeout+0x40> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 109eb5: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx 109ebb: 49 dec %ecx 109ebc: 75 0a jne 109ec8 <_Event_Timeout+0x40> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 109ebe: c7 05 3c 5c 12 00 02 movl $0x2,0x125c3c 109ec5: 00 00 00 } the_thread->Wait.return_code = RTEMS_TIMEOUT; 109ec8: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 109ecf: 52 push %edx 109ed0: 9d popf 109ed1: 52 push %edx 109ed2: 52 push %edx 109ed3: 68 f8 ff 03 10 push $0x1003fff8 109ed8: 50 push %eax 109ed9: e8 06 20 00 00 call 10bee4 <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 109ede: a1 40 53 12 00 mov 0x125340,%eax 109ee3: 48 dec %eax 109ee4: a3 40 53 12 00 mov %eax,0x125340 _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; 109ee9: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 109eec: c9 leave 109eed: c3 ret =============================================================================== 0010faeb <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 10faeb: 55 push %ebp 10faec: 89 e5 mov %esp,%ebp 10faee: 57 push %edi 10faef: 56 push %esi 10faf0: 53 push %ebx 10faf1: 83 ec 4c sub $0x4c,%esp 10faf4: 8b 5d 08 mov 0x8(%ebp),%ebx 10faf7: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 10fafa: 8b 43 20 mov 0x20(%ebx),%eax 10fafd: 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; 10fb00: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 10fb07: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 10fb0e: 8b 53 10 mov 0x10(%ebx),%edx 10fb11: 89 55 c4 mov %edx,-0x3c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10fb14: 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; 10fb17: 8b 7b 30 mov 0x30(%ebx),%edi 10fb1a: 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; 10fb1d: 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 ) { 10fb1f: 8b 7d 0c mov 0xc(%ebp),%edi 10fb22: 01 cf add %ecx,%edi 10fb24: 0f 82 d4 01 00 00 jb 10fcfe <_Heap_Extend+0x213> return false; } extend_area_ok = _Heap_Get_first_and_last_block( 10fb2a: 52 push %edx 10fb2b: 52 push %edx 10fb2c: 8d 55 e0 lea -0x20(%ebp),%edx 10fb2f: 52 push %edx 10fb30: 8d 55 e4 lea -0x1c(%ebp),%edx 10fb33: 52 push %edx 10fb34: 50 push %eax 10fb35: ff 75 c4 pushl -0x3c(%ebp) 10fb38: 51 push %ecx 10fb39: ff 75 0c pushl 0xc(%ebp) 10fb3c: e8 6e b8 ff ff call 10b3af <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 10fb41: 83 c4 20 add $0x20,%esp 10fb44: 84 c0 test %al,%al 10fb46: 0f 84 b2 01 00 00 je 10fcfe <_Heap_Extend+0x213> 10fb4c: 8b 4d c0 mov -0x40(%ebp),%ecx 10fb4f: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 10fb56: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 10fb5d: 31 f6 xor %esi,%esi 10fb5f: 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; 10fb66: 8b 43 18 mov 0x18(%ebx),%eax 10fb69: 89 5d b8 mov %ebx,-0x48(%ebp) 10fb6c: eb 02 jmp 10fb70 <_Heap_Extend+0x85> 10fb6e: 89 c8 mov %ecx,%eax uintptr_t const sub_area_end = start_block->prev_size; 10fb70: 8b 19 mov (%ecx),%ebx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 10fb72: 39 c7 cmp %eax,%edi 10fb74: 76 09 jbe 10fb7f <_Heap_Extend+0x94> 10fb76: 39 5d 0c cmp %ebx,0xc(%ebp) 10fb79: 0f 82 7d 01 00 00 jb 10fcfc <_Heap_Extend+0x211> <== NEVER TAKEN sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fb7f: 39 c7 cmp %eax,%edi 10fb81: 74 06 je 10fb89 <_Heap_Extend+0x9e> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10fb83: 39 df cmp %ebx,%edi 10fb85: 72 07 jb 10fb8e <_Heap_Extend+0xa3> 10fb87: eb 08 jmp 10fb91 <_Heap_Extend+0xa6> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fb89: 89 4d d0 mov %ecx,-0x30(%ebp) 10fb8c: eb 03 jmp 10fb91 <_Heap_Extend+0xa6> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10fb8e: 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); 10fb91: 8d 43 f8 lea -0x8(%ebx),%eax 10fb94: 89 45 d4 mov %eax,-0x2c(%ebp) 10fb97: 89 d8 mov %ebx,%eax 10fb99: 31 d2 xor %edx,%edx 10fb9b: 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); 10fb9e: 29 55 d4 sub %edx,-0x2c(%ebp) link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 10fba1: 3b 5d 0c cmp 0xc(%ebp),%ebx 10fba4: 75 07 jne 10fbad <_Heap_Extend+0xc2> start_block->prev_size = extend_area_end; 10fba6: 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 ) 10fba8: 8b 75 d4 mov -0x2c(%ebp),%esi 10fbab: eb 08 jmp 10fbb5 <_Heap_Extend+0xca> merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 10fbad: 73 06 jae 10fbb5 <_Heap_Extend+0xca> 10fbaf: 8b 55 d4 mov -0x2c(%ebp),%edx 10fbb2: 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; 10fbb5: 8b 45 d4 mov -0x2c(%ebp),%eax 10fbb8: 8b 48 04 mov 0x4(%eax),%ecx 10fbbb: 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); 10fbbe: 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 ); 10fbc0: 3b 4d c0 cmp -0x40(%ebp),%ecx 10fbc3: 75 a9 jne 10fb6e <_Heap_Extend+0x83> 10fbc5: 8b 5d b8 mov -0x48(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 10fbc8: 8b 55 0c mov 0xc(%ebp),%edx 10fbcb: 3b 53 18 cmp 0x18(%ebx),%edx 10fbce: 73 05 jae 10fbd5 <_Heap_Extend+0xea> heap->area_begin = extend_area_begin; 10fbd0: 89 53 18 mov %edx,0x18(%ebx) 10fbd3: eb 08 jmp 10fbdd <_Heap_Extend+0xf2> } else if ( heap->area_end < extend_area_end ) { 10fbd5: 39 7b 1c cmp %edi,0x1c(%ebx) 10fbd8: 73 03 jae 10fbdd <_Heap_Extend+0xf2> heap->area_end = extend_area_end; 10fbda: 89 7b 1c mov %edi,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 10fbdd: 8b 45 e0 mov -0x20(%ebp),%eax 10fbe0: 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 = 10fbe3: 89 c1 mov %eax,%ecx 10fbe5: 29 d1 sub %edx,%ecx 10fbe7: 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; 10fbea: 89 3a mov %edi,(%edx) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 10fbec: 83 c9 01 or $0x1,%ecx 10fbef: 89 4a 04 mov %ecx,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 10fbf2: 8b 4d d4 mov -0x2c(%ebp),%ecx 10fbf5: 89 08 mov %ecx,(%eax) extend_last_block->size_and_flag = 0; 10fbf7: 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 ) { 10fbfe: 39 53 20 cmp %edx,0x20(%ebx) 10fc01: 76 05 jbe 10fc08 <_Heap_Extend+0x11d> heap->first_block = extend_first_block; 10fc03: 89 53 20 mov %edx,0x20(%ebx) 10fc06: eb 08 jmp 10fc10 <_Heap_Extend+0x125> } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 10fc08: 39 43 24 cmp %eax,0x24(%ebx) 10fc0b: 73 03 jae 10fc10 <_Heap_Extend+0x125> heap->last_block = extend_last_block; 10fc0d: 89 43 24 mov %eax,0x24(%ebx) } if ( merge_below_block != NULL ) { 10fc10: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fc14: 74 3b je 10fc51 <_Heap_Extend+0x166> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 10fc16: 8b 43 10 mov 0x10(%ebx),%eax 10fc19: 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 ); 10fc1c: 8b 4d 0c mov 0xc(%ebp),%ecx 10fc1f: 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; 10fc22: 89 c8 mov %ecx,%eax 10fc24: 31 d2 xor %edx,%edx 10fc26: f7 75 d4 divl -0x2c(%ebp) if ( remainder != 0 ) { 10fc29: 85 d2 test %edx,%edx 10fc2b: 74 05 je 10fc32 <_Heap_Extend+0x147> return value - remainder + alignment; 10fc2d: 03 4d d4 add -0x2c(%ebp),%ecx 10fc30: 29 d1 sub %edx,%ecx uintptr_t const new_first_block_begin = 10fc32: 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; 10fc35: 8b 45 d0 mov -0x30(%ebp),%eax 10fc38: 8b 00 mov (%eax),%eax 10fc3a: 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 = 10fc3d: 8b 45 d0 mov -0x30(%ebp),%eax 10fc40: 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; 10fc42: 83 c8 01 or $0x1,%eax 10fc45: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 10fc48: 89 d8 mov %ebx,%eax 10fc4a: e8 81 fe ff ff call 10fad0 <_Heap_Free_block> 10fc4f: eb 14 jmp 10fc65 <_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 ) { 10fc51: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10fc55: 74 0e je 10fc65 <_Heap_Extend+0x17a> _Heap_Link_below( 10fc57: 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; 10fc5a: 8b 45 c8 mov -0x38(%ebp),%eax 10fc5d: 29 d0 sub %edx,%eax 10fc5f: 83 c8 01 or $0x1,%eax 10fc62: 89 42 04 mov %eax,0x4(%edx) link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 10fc65: 85 f6 test %esi,%esi 10fc67: 74 30 je 10fc99 <_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, 10fc69: 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( 10fc6c: 29 f7 sub %esi,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10fc6e: 89 f8 mov %edi,%eax 10fc70: 31 d2 xor %edx,%edx 10fc72: f7 73 10 divl 0x10(%ebx) 10fc75: 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) 10fc77: 8b 46 04 mov 0x4(%esi),%eax 10fc7a: 29 f8 sub %edi,%eax | HEAP_PREV_BLOCK_USED; 10fc7c: 83 c8 01 or $0x1,%eax 10fc7f: 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; 10fc83: 8b 46 04 mov 0x4(%esi),%eax 10fc86: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 10fc89: 09 f8 or %edi,%eax 10fc8b: 89 46 04 mov %eax,0x4(%esi) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 10fc8e: 89 f2 mov %esi,%edx 10fc90: 89 d8 mov %ebx,%eax 10fc92: e8 39 fe ff ff call 10fad0 <_Heap_Free_block> 10fc97: eb 21 jmp 10fcba <_Heap_Extend+0x1cf> ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 10fc99: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10fc9d: 74 1b je 10fcba <_Heap_Extend+0x1cf> _Heap_Link_above( 10fc9f: 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 ); 10fca2: 8b 45 e4 mov -0x1c(%ebp),%eax 10fca5: 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; 10fca8: 8b 7d cc mov -0x34(%ebp),%edi 10fcab: 8b 57 04 mov 0x4(%edi),%edx 10fcae: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 10fcb1: 09 d0 or %edx,%eax 10fcb3: 89 47 04 mov %eax,0x4(%edi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 10fcb6: 83 49 04 01 orl $0x1,0x4(%ecx) extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 10fcba: 85 f6 test %esi,%esi 10fcbc: 75 10 jne 10fcce <_Heap_Extend+0x1e3> 10fcbe: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fcc2: 75 0a jne 10fcce <_Heap_Extend+0x1e3> _Heap_Free_block( heap, extend_first_block ); 10fcc4: 8b 55 e4 mov -0x1c(%ebp),%edx 10fcc7: 89 d8 mov %ebx,%eax 10fcc9: e8 02 fe ff ff call 10fad0 <_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 10fcce: 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( 10fcd1: 8b 43 20 mov 0x20(%ebx),%eax 10fcd4: 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; 10fcd6: 8b 4a 04 mov 0x4(%edx),%ecx 10fcd9: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 10fcdc: 09 c8 or %ecx,%eax 10fcde: 89 42 04 mov %eax,0x4(%edx) } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 10fce1: 8b 43 30 mov 0x30(%ebx),%eax 10fce4: 2b 45 bc sub -0x44(%ebp),%eax /* Statistics */ stats->size += extended_size; 10fce7: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 10fcea: 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 ) 10fcef: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10fcf3: 74 09 je 10fcfe <_Heap_Extend+0x213> <== NEVER TAKEN *extended_size_ptr = extended_size; 10fcf5: 8b 55 14 mov 0x14(%ebp),%edx 10fcf8: 89 02 mov %eax,(%edx) 10fcfa: eb 02 jmp 10fcfe <_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; 10fcfc: 31 f6 xor %esi,%esi if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 10fcfe: 89 f0 mov %esi,%eax 10fd00: 8d 65 f4 lea -0xc(%ebp),%esp 10fd03: 5b pop %ebx 10fd04: 5e pop %esi 10fd05: 5f pop %edi 10fd06: c9 leave 10fd07: c3 ret =============================================================================== 0010f730 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 10f730: 55 push %ebp 10f731: 89 e5 mov %esp,%ebp 10f733: 57 push %edi 10f734: 56 push %esi 10f735: 53 push %ebx 10f736: 83 ec 14 sub $0x14,%esp 10f739: 8b 4d 08 mov 0x8(%ebp),%ecx 10f73c: 8b 55 0c mov 0xc(%ebp),%edx * If NULL return true so a free on NULL is considered a valid release. This * is a special case that could be handled by the in heap check how-ever that * would result in false being returned which is wrong. */ if ( alloc_begin_ptr == NULL ) { return true; 10f73f: b0 01 mov $0x1,%al /* * If NULL return true so a free on NULL is considered a valid release. This * is a special case that could be handled by the in heap check how-ever that * would result in false being returned which is wrong. */ if ( alloc_begin_ptr == NULL ) { 10f741: 85 d2 test %edx,%edx 10f743: 0f 84 4b 01 00 00 je 10f894 <_Heap_Free+0x164> 10f749: 8d 5a f8 lea -0x8(%edx),%ebx 10f74c: 89 d0 mov %edx,%eax 10f74e: 31 d2 xor %edx,%edx 10f750: 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); 10f753: 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 10f755: 8b 41 20 mov 0x20(%ecx),%eax 10f758: 89 45 ec mov %eax,-0x14(%ebp) && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f75b: 31 d2 xor %edx,%edx 10f75d: 39 c3 cmp %eax,%ebx 10f75f: 72 08 jb 10f769 <_Heap_Free+0x39> 10f761: 31 d2 xor %edx,%edx 10f763: 39 59 24 cmp %ebx,0x24(%ecx) 10f766: 0f 93 c2 setae %dl alloc_begin = (uintptr_t) alloc_begin_ptr; block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 10f769: 31 c0 xor %eax,%eax } alloc_begin = (uintptr_t) alloc_begin_ptr; block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { 10f76b: 85 d2 test %edx,%edx 10f76d: 0f 84 21 01 00 00 je 10f894 <_Heap_Free+0x164> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f773: 8b 43 04 mov 0x4(%ebx),%eax 10f776: 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; 10f779: 89 c6 mov %eax,%esi 10f77b: 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); 10f77e: 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; 10f781: 31 ff xor %edi,%edi 10f783: 3b 55 ec cmp -0x14(%ebp),%edx 10f786: 72 0a jb 10f792 <_Heap_Free+0x62> <== NEVER TAKEN 10f788: 31 c0 xor %eax,%eax 10f78a: 39 51 24 cmp %edx,0x24(%ecx) 10f78d: 0f 93 c0 setae %al 10f790: 89 c7 mov %eax,%edi block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { return false; 10f792: 31 c0 xor %eax,%eax _Heap_Protection_block_check( heap, block ); block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10f794: 85 ff test %edi,%edi 10f796: 0f 84 f8 00 00 00 je 10f894 <_Heap_Free+0x164> <== NEVER TAKEN --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f79c: 8b 7a 04 mov 0x4(%edx),%edi return false; } _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_prev_used( next_block ) ) { 10f79f: f7 c7 01 00 00 00 test $0x1,%edi 10f7a5: 0f 84 e9 00 00 00 je 10f894 <_Heap_Free+0x164> <== 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; 10f7ab: 83 e7 fe and $0xfffffffe,%edi 10f7ae: 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 10f7b1: 8b 41 24 mov 0x24(%ecx),%eax 10f7b4: 89 45 e4 mov %eax,-0x1c(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 10f7b7: 31 c0 xor %eax,%eax 10f7b9: 3b 55 e4 cmp -0x1c(%ebp),%edx 10f7bc: 74 0a je 10f7c8 <_Heap_Free+0x98> 10f7be: 31 c0 xor %eax,%eax 10f7c0: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 10f7c5: 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 10f7c8: 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 ) ) { 10f7cb: f6 45 f0 01 testb $0x1,-0x10(%ebp) 10f7cf: 75 62 jne 10f833 <_Heap_Free+0x103> uintptr_t const prev_size = block->prev_size; 10f7d1: 8b 03 mov (%ebx),%eax 10f7d3: 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); 10f7d6: 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; 10f7d8: 31 ff xor %edi,%edi 10f7da: 3b 5d ec cmp -0x14(%ebp),%ebx 10f7dd: 72 0a jb 10f7e9 <_Heap_Free+0xb9> <== NEVER TAKEN 10f7df: 31 c0 xor %eax,%eax 10f7e1: 39 5d e4 cmp %ebx,-0x1c(%ebp) 10f7e4: 0f 93 c0 setae %al 10f7e7: 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 ); 10f7e9: 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 ) ) { 10f7eb: 85 ff test %edi,%edi 10f7ed: 0f 84 a1 00 00 00 je 10f894 <_Heap_Free+0x164> <== 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) ) { 10f7f3: f6 43 04 01 testb $0x1,0x4(%ebx) 10f7f7: 0f 84 97 00 00 00 je 10f894 <_Heap_Free+0x164> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 10f7fd: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f801: 74 1a je 10f81d <_Heap_Free+0xed> uintptr_t const size = block_size + prev_size + next_block_size; 10f803: 8b 45 e8 mov -0x18(%ebp),%eax 10f806: 8d 04 06 lea (%esi,%eax,1),%eax 10f809: 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; 10f80c: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = block->prev; 10f80f: 8b 52 0c mov 0xc(%edx),%edx prev->next = next; 10f812: 89 7a 08 mov %edi,0x8(%edx) next->prev = prev; 10f815: 89 57 0c mov %edx,0xc(%edi) _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 10f818: ff 49 38 decl 0x38(%ecx) 10f81b: eb 33 jmp 10f850 <_Heap_Free+0x120> 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; 10f81d: 8b 45 f0 mov -0x10(%ebp),%eax 10f820: 8d 04 06 lea (%esi,%eax,1),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f823: 89 c7 mov %eax,%edi 10f825: 83 cf 01 or $0x1,%edi 10f828: 89 7b 04 mov %edi,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f82b: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 10f82f: 89 02 mov %eax,(%edx) 10f831: eb 56 jmp 10f889 <_Heap_Free+0x159> } } else if ( next_is_free ) { /* coalesce next */ 10f833: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f837: 74 24 je 10f85d <_Heap_Free+0x12d> uintptr_t const size = block_size + next_block_size; 10f839: 8b 45 e8 mov -0x18(%ebp),%eax 10f83c: 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; 10f83e: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = old_block->prev; 10f841: 8b 52 0c mov 0xc(%edx),%edx new_block->next = next; 10f844: 89 7b 08 mov %edi,0x8(%ebx) new_block->prev = prev; 10f847: 89 53 0c mov %edx,0xc(%ebx) next->prev = new_block; 10f84a: 89 5f 0c mov %ebx,0xc(%edi) prev->next = new_block; 10f84d: 89 5a 08 mov %ebx,0x8(%edx) _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f850: 89 c2 mov %eax,%edx 10f852: 83 ca 01 or $0x1,%edx 10f855: 89 53 04 mov %edx,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 10f858: 89 04 03 mov %eax,(%ebx,%eax,1) 10f85b: eb 2c jmp 10f889 <_Heap_Free+0x159> RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 10f85d: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 10f860: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 10f863: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 10f866: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 10f869: 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; 10f86c: 89 f0 mov %esi,%eax 10f86e: 83 c8 01 or $0x1,%eax 10f871: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f874: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 10f878: 89 32 mov %esi,(%edx) /* Statistics */ ++stats->free_blocks; 10f87a: 8b 41 38 mov 0x38(%ecx),%eax 10f87d: 40 inc %eax 10f87e: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 10f881: 39 41 3c cmp %eax,0x3c(%ecx) 10f884: 73 03 jae 10f889 <_Heap_Free+0x159> stats->max_free_blocks = stats->free_blocks; 10f886: 89 41 3c mov %eax,0x3c(%ecx) } } /* Statistics */ --stats->used_blocks; 10f889: ff 49 40 decl 0x40(%ecx) ++stats->frees; 10f88c: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 10f88f: 01 71 30 add %esi,0x30(%ecx) return( true ); 10f892: b0 01 mov $0x1,%al } 10f894: 83 c4 14 add $0x14,%esp 10f897: 5b pop %ebx 10f898: 5e pop %esi 10f899: 5f pop %edi 10f89a: c9 leave 10f89b: c3 ret =============================================================================== 0011d4e0 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11d4e0: 55 push %ebp 11d4e1: 89 e5 mov %esp,%ebp 11d4e3: 57 push %edi 11d4e4: 56 push %esi 11d4e5: 53 push %ebx 11d4e6: 8b 5d 08 mov 0x8(%ebp),%ebx 11d4e9: 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); 11d4ec: 8d 4e f8 lea -0x8(%esi),%ecx 11d4ef: 89 f0 mov %esi,%eax 11d4f1: 31 d2 xor %edx,%edx 11d4f3: 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); 11d4f6: 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 11d4f8: 8b 53 20 mov 0x20(%ebx),%edx && (uintptr_t) block <= (uintptr_t) heap->last_block; 11d4fb: 31 ff xor %edi,%edi 11d4fd: 39 d1 cmp %edx,%ecx 11d4ff: 72 0a jb 11d50b <_Heap_Size_of_alloc_area+0x2b> 11d501: 31 c0 xor %eax,%eax 11d503: 39 4b 24 cmp %ecx,0x24(%ebx) 11d506: 0f 93 c0 setae %al 11d509: 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; 11d50b: 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 ) ) { 11d50d: 85 ff test %edi,%edi 11d50f: 74 30 je 11d541 <_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; 11d511: 8b 41 04 mov 0x4(%ecx),%eax 11d514: 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); 11d517: 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; 11d519: 31 ff xor %edi,%edi 11d51b: 39 d1 cmp %edx,%ecx 11d51d: 72 0a jb 11d529 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN 11d51f: 31 c0 xor %eax,%eax 11d521: 39 4b 24 cmp %ecx,0x24(%ebx) 11d524: 0f 93 c0 setae %al 11d527: 89 c7 mov %eax,%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) ) { return false; 11d529: 31 c0 xor %eax,%eax } block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( 11d52b: 85 ff test %edi,%edi 11d52d: 74 12 je 11d541 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 11d52f: f6 41 04 01 testb $0x1,0x4(%ecx) 11d533: 74 0c je 11d541 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11d535: 29 f1 sub %esi,%ecx 11d537: 8d 51 04 lea 0x4(%ecx),%edx 11d53a: 8b 45 10 mov 0x10(%ebp),%eax 11d53d: 89 10 mov %edx,(%eax) return true; 11d53f: b0 01 mov $0x1,%al } 11d541: 5b pop %ebx 11d542: 5e pop %esi 11d543: 5f pop %edi 11d544: c9 leave 11d545: c3 ret =============================================================================== 0010bca6 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10bca6: 55 push %ebp 10bca7: 89 e5 mov %esp,%ebp 10bca9: 57 push %edi 10bcaa: 56 push %esi 10bcab: 53 push %ebx 10bcac: 83 ec 4c sub $0x4c,%esp 10bcaf: 8b 75 08 mov 0x8(%ebp),%esi 10bcb2: 8b 5d 0c mov 0xc(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10bcb5: 8b 46 10 mov 0x10(%esi),%eax 10bcb8: 89 45 d8 mov %eax,-0x28(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10bcbb: 8b 4e 14 mov 0x14(%esi),%ecx 10bcbe: 89 4d d4 mov %ecx,-0x2c(%ebp) Heap_Block *const first_block = heap->first_block; 10bcc1: 8b 46 20 mov 0x20(%esi),%eax 10bcc4: 89 45 d0 mov %eax,-0x30(%ebp) Heap_Block *const last_block = heap->last_block; 10bcc7: 8b 4e 24 mov 0x24(%esi),%ecx 10bcca: 89 4d c8 mov %ecx,-0x38(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10bccd: c7 45 e4 68 bc 10 00 movl $0x10bc68,-0x1c(%ebp) 10bcd4: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10bcd8: 74 07 je 10bce1 <_Heap_Walk+0x3b> 10bcda: c7 45 e4 6d bc 10 00 movl $0x10bc6d,-0x1c(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; 10bce1: 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() ) ) { 10bce3: 83 3d 24 75 12 00 03 cmpl $0x3,0x127524 10bcea: 0f 85 e8 02 00 00 jne 10bfd8 <_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)( 10bcf0: 52 push %edx 10bcf1: ff 76 0c pushl 0xc(%esi) 10bcf4: ff 76 08 pushl 0x8(%esi) 10bcf7: ff 75 c8 pushl -0x38(%ebp) 10bcfa: ff 75 d0 pushl -0x30(%ebp) 10bcfd: ff 76 1c pushl 0x1c(%esi) 10bd00: ff 76 18 pushl 0x18(%esi) 10bd03: ff 75 d4 pushl -0x2c(%ebp) 10bd06: ff 75 d8 pushl -0x28(%ebp) 10bd09: 68 dd 00 12 00 push $0x1200dd 10bd0e: 6a 00 push $0x0 10bd10: 53 push %ebx 10bd11: 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 ) { 10bd14: 83 c4 30 add $0x30,%esp 10bd17: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10bd1b: 75 0b jne 10bd28 <_Heap_Walk+0x82> (*printer)( source, true, "page size is zero\n" ); 10bd1d: 50 push %eax 10bd1e: 68 6e 01 12 00 push $0x12016e 10bd23: e9 6b 02 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10bd28: f6 45 d8 03 testb $0x3,-0x28(%ebp) 10bd2c: 74 0d je 10bd3b <_Heap_Walk+0x95> (*printer)( 10bd2e: ff 75 d8 pushl -0x28(%ebp) 10bd31: 68 81 01 12 00 push $0x120181 10bd36: e9 58 02 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bd3b: 8b 45 d4 mov -0x2c(%ebp),%eax 10bd3e: 31 d2 xor %edx,%edx 10bd40: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10bd43: 85 d2 test %edx,%edx 10bd45: 74 0d je 10bd54 <_Heap_Walk+0xae> (*printer)( 10bd47: ff 75 d4 pushl -0x2c(%ebp) 10bd4a: 68 9f 01 12 00 push $0x12019f 10bd4f: e9 3f 02 00 00 jmp 10bf93 <_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; 10bd54: 8b 45 d0 mov -0x30(%ebp),%eax 10bd57: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bd5a: 31 d2 xor %edx,%edx 10bd5c: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( 10bd5f: 85 d2 test %edx,%edx 10bd61: 74 0d je 10bd70 <_Heap_Walk+0xca> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10bd63: ff 75 d0 pushl -0x30(%ebp) 10bd66: 68 c3 01 12 00 push $0x1201c3 10bd6b: e9 23 02 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10bd70: 8b 45 d0 mov -0x30(%ebp),%eax 10bd73: f6 40 04 01 testb $0x1,0x4(%eax) 10bd77: 75 0b jne 10bd84 <_Heap_Walk+0xde> (*printer)( 10bd79: 57 push %edi 10bd7a: 68 f4 01 12 00 push $0x1201f4 10bd7f: e9 0f 02 00 00 jmp 10bf93 <_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; 10bd84: 8b 4d c8 mov -0x38(%ebp),%ecx 10bd87: 8b 79 04 mov 0x4(%ecx),%edi 10bd8a: 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); 10bd8d: 01 cf add %ecx,%edi ); return false; } if ( _Heap_Is_free( last_block ) ) { 10bd8f: f6 47 04 01 testb $0x1,0x4(%edi) 10bd93: 75 0b jne 10bda0 <_Heap_Walk+0xfa> (*printer)( 10bd95: 56 push %esi 10bd96: 68 22 02 12 00 push $0x120222 10bd9b: e9 f3 01 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> ); return false; } if ( 10bda0: 3b 7d d0 cmp -0x30(%ebp),%edi 10bda3: 74 0b je 10bdb0 <_Heap_Walk+0x10a> _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10bda5: 51 push %ecx 10bda6: 68 37 02 12 00 push $0x120237 10bdab: e9 e3 01 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10bdb0: 8b 46 10 mov 0x10(%esi),%eax 10bdb3: 89 45 e0 mov %eax,-0x20(%ebp) block = next_block; } while ( block != first_block ); return true; } 10bdb6: 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 ); 10bdb9: 89 75 dc mov %esi,-0x24(%ebp) 10bdbc: eb 75 jmp 10be33 <_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; 10bdbe: 31 c0 xor %eax,%eax 10bdc0: 39 4e 20 cmp %ecx,0x20(%esi) 10bdc3: 77 08 ja 10bdcd <_Heap_Walk+0x127> 10bdc5: 31 c0 xor %eax,%eax 10bdc7: 39 4e 24 cmp %ecx,0x24(%esi) 10bdca: 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 ) ) { 10bdcd: 85 c0 test %eax,%eax 10bdcf: 75 0b jne 10bddc <_Heap_Walk+0x136> (*printer)( 10bdd1: 51 push %ecx 10bdd2: 68 66 02 12 00 push $0x120266 10bdd7: e9 b7 01 00 00 jmp 10bf93 <_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; 10bddc: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bddf: 31 d2 xor %edx,%edx 10bde1: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10bde4: 85 d2 test %edx,%edx 10bde6: 74 0b je 10bdf3 <_Heap_Walk+0x14d> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10bde8: 51 push %ecx 10bde9: 68 86 02 12 00 push $0x120286 10bdee: e9 a0 01 00 00 jmp 10bf93 <_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; 10bdf3: 8b 41 04 mov 0x4(%ecx),%eax 10bdf6: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10bdf9: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10bdfe: 74 0b je 10be0b <_Heap_Walk+0x165> (*printer)( 10be00: 51 push %ecx 10be01: 68 b6 02 12 00 push $0x1202b6 10be06: e9 88 01 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> ); return false; } if ( free_block->prev != prev_block ) { 10be0b: 8b 41 0c mov 0xc(%ecx),%eax 10be0e: 3b 45 dc cmp -0x24(%ebp),%eax 10be11: 74 1a je 10be2d <_Heap_Walk+0x187> (*printer)( 10be13: 83 ec 0c sub $0xc,%esp 10be16: 50 push %eax 10be17: 51 push %ecx 10be18: 68 d2 02 12 00 push $0x1202d2 10be1d: 6a 01 push $0x1 10be1f: 53 push %ebx 10be20: ff 55 e4 call *-0x1c(%ebp) 10be23: 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; 10be26: 31 c0 xor %eax,%eax 10be28: e9 ab 01 00 00 jmp 10bfd8 <_Heap_Walk+0x332> return false; } prev_block = free_block; free_block = free_block->next; 10be2d: 89 4d dc mov %ecx,-0x24(%ebp) 10be30: 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 ) { 10be33: 39 f1 cmp %esi,%ecx 10be35: 75 87 jne 10bdbe <_Heap_Walk+0x118> 10be37: 89 5d dc mov %ebx,-0x24(%ebp) 10be3a: eb 02 jmp 10be3e <_Heap_Walk+0x198> block->prev_size ); } block = next_block; } while ( block != first_block ); 10be3c: 89 df mov %ebx,%edi return true; } 10be3e: 8b 4f 04 mov 0x4(%edi),%ecx 10be41: 89 4d cc mov %ecx,-0x34(%ebp) 10be44: 83 e1 fe and $0xfffffffe,%ecx 10be47: 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); 10be4a: 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; 10be4d: 31 c0 xor %eax,%eax 10be4f: 39 5e 20 cmp %ebx,0x20(%esi) 10be52: 77 08 ja 10be5c <_Heap_Walk+0x1b6> <== NEVER TAKEN 10be54: 31 c0 xor %eax,%eax 10be56: 39 5e 24 cmp %ebx,0x24(%esi) 10be59: 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 ) ) { 10be5c: 85 c0 test %eax,%eax 10be5e: 75 11 jne 10be71 <_Heap_Walk+0x1cb> 10be60: 89 d9 mov %ebx,%ecx 10be62: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be65: 83 ec 0c sub $0xc,%esp 10be68: 51 push %ecx 10be69: 57 push %edi 10be6a: 68 04 03 12 00 push $0x120304 10be6f: eb ac jmp 10be1d <_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; 10be71: 3b 7d c8 cmp -0x38(%ebp),%edi 10be74: 0f 95 c1 setne %cl RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10be77: 8b 45 e0 mov -0x20(%ebp),%eax 10be7a: 31 d2 xor %edx,%edx 10be7c: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10be7f: 85 d2 test %edx,%edx 10be81: 74 15 je 10be98 <_Heap_Walk+0x1f2> 10be83: 84 c9 test %cl,%cl 10be85: 74 11 je 10be98 <_Heap_Walk+0x1f2> 10be87: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be8a: 83 ec 0c sub $0xc,%esp 10be8d: ff 75 e0 pushl -0x20(%ebp) 10be90: 57 push %edi 10be91: 68 31 03 12 00 push $0x120331 10be96: eb 85 jmp 10be1d <_Heap_Walk+0x177> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10be98: 8b 45 d4 mov -0x2c(%ebp),%eax 10be9b: 39 45 e0 cmp %eax,-0x20(%ebp) 10be9e: 73 18 jae 10beb8 <_Heap_Walk+0x212> 10bea0: 84 c9 test %cl,%cl 10bea2: 74 14 je 10beb8 <_Heap_Walk+0x212> <== NEVER TAKEN 10bea4: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bea7: 52 push %edx 10bea8: 52 push %edx 10bea9: 50 push %eax 10beaa: ff 75 e0 pushl -0x20(%ebp) 10bead: 57 push %edi 10beae: 68 5f 03 12 00 push $0x12035f 10beb3: e9 65 ff ff ff jmp 10be1d <_Heap_Walk+0x177> ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10beb8: 39 fb cmp %edi,%ebx 10beba: 77 18 ja 10bed4 <_Heap_Walk+0x22e> 10bebc: 84 c9 test %cl,%cl 10bebe: 74 14 je 10bed4 <_Heap_Walk+0x22e> 10bec0: 89 d9 mov %ebx,%ecx 10bec2: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bec5: 83 ec 0c sub $0xc,%esp 10bec8: 51 push %ecx 10bec9: 57 push %edi 10beca: 68 8a 03 12 00 push $0x12038a 10becf: e9 49 ff ff ff jmp 10be1d <_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; 10bed4: 8b 4d cc mov -0x34(%ebp),%ecx 10bed7: 83 e1 01 and $0x1,%ecx 10beda: 89 4d c4 mov %ecx,-0x3c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10bedd: f6 43 04 01 testb $0x1,0x4(%ebx) 10bee1: 0f 85 ba 00 00 00 jne 10bfa1 <_Heap_Walk+0x2fb> block = next_block; } while ( block != first_block ); return true; } 10bee7: 8b 46 08 mov 0x8(%esi),%eax 10beea: 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 ? 10beed: 8b 4f 08 mov 0x8(%edi),%ecx 10bef0: 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)( 10bef3: ba aa 00 12 00 mov $0x1200aa,%edx 10bef8: 3b 4e 0c cmp 0xc(%esi),%ecx 10befb: 74 0e je 10bf0b <_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)" : "") 10befd: ba f1 ff 11 00 mov $0x11fff1,%edx 10bf02: 39 f1 cmp %esi,%ecx 10bf04: 75 05 jne 10bf0b <_Heap_Walk+0x265> 10bf06: ba b9 00 12 00 mov $0x1200b9,%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 ? 10bf0b: 8b 47 0c mov 0xc(%edi),%eax 10bf0e: 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)( 10bf11: b8 c3 00 12 00 mov $0x1200c3,%eax 10bf16: 8b 4d c0 mov -0x40(%ebp),%ecx 10bf19: 39 4d cc cmp %ecx,-0x34(%ebp) 10bf1c: 74 0f je 10bf2d <_Heap_Walk+0x287> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10bf1e: b8 f1 ff 11 00 mov $0x11fff1,%eax 10bf23: 39 75 cc cmp %esi,-0x34(%ebp) 10bf26: 75 05 jne 10bf2d <_Heap_Walk+0x287> 10bf28: b8 d3 00 12 00 mov $0x1200d3,%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)( 10bf2d: 83 ec 0c sub $0xc,%esp 10bf30: 52 push %edx 10bf31: ff 75 b4 pushl -0x4c(%ebp) 10bf34: 50 push %eax 10bf35: ff 75 cc pushl -0x34(%ebp) 10bf38: ff 75 e0 pushl -0x20(%ebp) 10bf3b: 57 push %edi 10bf3c: 68 be 03 12 00 push $0x1203be 10bf41: 6a 00 push $0x0 10bf43: ff 75 dc pushl -0x24(%ebp) 10bf46: 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 ) { 10bf49: 8b 03 mov (%ebx),%eax 10bf4b: 83 c4 30 add $0x30,%esp 10bf4e: 39 45 e0 cmp %eax,-0x20(%ebp) 10bf51: 74 16 je 10bf69 <_Heap_Walk+0x2c3> 10bf53: 89 d9 mov %ebx,%ecx 10bf55: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bf58: 56 push %esi 10bf59: 51 push %ecx 10bf5a: 50 push %eax 10bf5b: ff 75 e0 pushl -0x20(%ebp) 10bf5e: 57 push %edi 10bf5f: 68 f3 03 12 00 push $0x1203f3 10bf64: e9 b4 fe ff ff jmp 10be1d <_Heap_Walk+0x177> ); return false; } if ( !prev_used ) { 10bf69: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bf6d: 75 0b jne 10bf7a <_Heap_Walk+0x2d4> 10bf6f: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bf72: 57 push %edi 10bf73: 68 2c 04 12 00 push $0x12042c 10bf78: eb 19 jmp 10bf93 <_Heap_Walk+0x2ed> block = next_block; } while ( block != first_block ); return true; } 10bf7a: 8b 46 08 mov 0x8(%esi),%eax 10bf7d: eb 07 jmp 10bf86 <_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 ) { 10bf7f: 39 f8 cmp %edi,%eax 10bf81: 74 4a je 10bfcd <_Heap_Walk+0x327> return true; } free_block = free_block->next; 10bf83: 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 ) { 10bf86: 39 f0 cmp %esi,%eax 10bf88: 75 f5 jne 10bf7f <_Heap_Walk+0x2d9> 10bf8a: 8b 5d dc mov -0x24(%ebp),%ebx return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10bf8d: 57 push %edi 10bf8e: 68 97 04 12 00 push $0x120497 10bf93: 6a 01 push $0x1 10bf95: 53 push %ebx 10bf96: ff 55 e4 call *-0x1c(%ebp) 10bf99: 83 c4 10 add $0x10,%esp 10bf9c: e9 85 fe ff ff jmp 10be26 <_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) { 10bfa1: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bfa5: 74 0e je 10bfb5 <_Heap_Walk+0x30f> (*printer)( 10bfa7: 83 ec 0c sub $0xc,%esp 10bfaa: ff 75 e0 pushl -0x20(%ebp) 10bfad: 57 push %edi 10bfae: 68 5b 04 12 00 push $0x12045b 10bfb3: eb 0d jmp 10bfc2 <_Heap_Walk+0x31c> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10bfb5: 51 push %ecx 10bfb6: 51 push %ecx 10bfb7: ff 37 pushl (%edi) 10bfb9: ff 75 e0 pushl -0x20(%ebp) 10bfbc: 57 push %edi 10bfbd: 68 72 04 12 00 push $0x120472 10bfc2: 6a 00 push $0x0 10bfc4: ff 75 dc pushl -0x24(%ebp) 10bfc7: ff 55 e4 call *-0x1c(%ebp) 10bfca: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10bfcd: 3b 5d d0 cmp -0x30(%ebp),%ebx 10bfd0: 0f 85 66 fe ff ff jne 10be3c <_Heap_Walk+0x196> return true; 10bfd6: b0 01 mov $0x1,%al } 10bfd8: 8d 65 f4 lea -0xc(%ebp),%esp 10bfdb: 5b pop %ebx 10bfdc: 5e pop %esi 10bfdd: 5f pop %edi 10bfde: c9 leave 10bfdf: c3 ret =============================================================================== 0010b28c <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10b28c: 55 push %ebp 10b28d: 89 e5 mov %esp,%ebp 10b28f: 53 push %ebx 10b290: 83 ec 08 sub $0x8,%esp 10b293: 8b 45 08 mov 0x8(%ebp),%eax 10b296: 8b 55 0c mov 0xc(%ebp),%edx 10b299: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10b29c: a3 d8 53 12 00 mov %eax,0x1253d8 _Internal_errors_What_happened.is_internal = is_internal; 10b2a1: 88 15 dc 53 12 00 mov %dl,0x1253dc _Internal_errors_What_happened.the_error = the_error; 10b2a7: 89 1d e0 53 12 00 mov %ebx,0x1253e0 _User_extensions_Fatal( the_source, is_internal, the_error ); 10b2ad: 53 push %ebx 10b2ae: 0f b6 d2 movzbl %dl,%edx 10b2b1: 52 push %edx 10b2b2: 50 push %eax 10b2b3: e8 37 1a 00 00 call 10ccef <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10b2b8: c7 05 9c 54 12 00 05 movl $0x5,0x12549c <== NOT EXECUTED 10b2bf: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b2c2: fa cli <== NOT EXECUTED 10b2c3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b2c5: f4 hlt <== NOT EXECUTED 10b2c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b2c9: eb fe jmp 10b2c9 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010b31c <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b31c: 55 push %ebp 10b31d: 89 e5 mov %esp,%ebp 10b31f: 56 push %esi 10b320: 53 push %ebx 10b321: 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; 10b324: 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 ) 10b326: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10b32a: 74 53 je 10b37f <_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 ); 10b32c: 8d 73 20 lea 0x20(%ebx),%esi 10b32f: 83 ec 0c sub $0xc,%esp 10b332: 56 push %esi 10b333: e8 38 f7 ff ff call 10aa70 <_Chain_Get> 10b338: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10b33a: 83 c4 10 add $0x10,%esp 10b33d: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10b341: 74 3c je 10b37f <_Objects_Allocate+0x63> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b343: 85 c0 test %eax,%eax 10b345: 75 1a jne 10b361 <_Objects_Allocate+0x45> _Objects_Extend_information( information ); 10b347: 83 ec 0c sub $0xc,%esp 10b34a: 53 push %ebx 10b34b: e8 60 00 00 00 call 10b3b0 <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b350: 89 34 24 mov %esi,(%esp) 10b353: e8 18 f7 ff ff call 10aa70 <_Chain_Get> 10b358: 89 c1 mov %eax,%ecx } if ( the_object ) { 10b35a: 83 c4 10 add $0x10,%esp 10b35d: 85 c0 test %eax,%eax 10b35f: 74 1e je 10b37f <_Objects_Allocate+0x63> uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10b361: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10b365: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10b369: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10b36b: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10b36f: 31 d2 xor %edx,%edx 10b371: f7 f6 div %esi information->inactive_per_block[ block ]--; 10b373: c1 e0 02 shl $0x2,%eax 10b376: 03 43 30 add 0x30(%ebx),%eax 10b379: ff 08 decl (%eax) information->inactive--; 10b37b: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10b37f: 89 c8 mov %ecx,%eax 10b381: 8d 65 f8 lea -0x8(%ebp),%esp 10b384: 5b pop %ebx 10b385: 5e pop %esi 10b386: c9 leave 10b387: c3 ret =============================================================================== 0010b6a0 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10b6a0: 55 push %ebp 10b6a1: 89 e5 mov %esp,%ebp 10b6a3: 57 push %edi 10b6a4: 56 push %esi 10b6a5: 53 push %ebx 10b6a6: 83 ec 0c sub $0xc,%esp 10b6a9: 8b 75 08 mov 0x8(%ebp),%esi 10b6ac: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 10b6af: 31 db xor %ebx,%ebx ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10b6b1: 66 85 ff test %di,%di 10b6b4: 74 37 je 10b6ed <_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 ); 10b6b6: 83 ec 0c sub $0xc,%esp 10b6b9: 56 push %esi 10b6ba: e8 dd 41 00 00 call 10f89c <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10b6bf: 83 c4 10 add $0x10,%esp 10b6c2: 85 c0 test %eax,%eax 10b6c4: 74 27 je 10b6ed <_Objects_Get_information+0x4d> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10b6c6: 0f b7 ff movzwl %di,%edi 10b6c9: 39 c7 cmp %eax,%edi 10b6cb: 77 20 ja 10b6ed <_Objects_Get_information+0x4d> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b6cd: 8b 04 b5 18 53 12 00 mov 0x125318(,%esi,4),%eax 10b6d4: 85 c0 test %eax,%eax 10b6d6: 74 15 je 10b6ed <_Objects_Get_information+0x4d><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10b6d8: 8b 1c b8 mov (%eax,%edi,4),%ebx if ( !info ) 10b6db: 85 db test %ebx,%ebx 10b6dd: 74 0e je 10b6ed <_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; 10b6df: 31 c0 xor %eax,%eax 10b6e1: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx) 10b6e6: 0f 95 c0 setne %al 10b6e9: f7 d8 neg %eax 10b6eb: 21 c3 and %eax,%ebx #endif return info; } 10b6ed: 89 d8 mov %ebx,%eax 10b6ef: 8d 65 f4 lea -0xc(%ebp),%esp 10b6f2: 5b pop %ebx 10b6f3: 5e pop %esi 10b6f4: 5f pop %edi 10b6f5: c9 leave 10b6f6: c3 ret =============================================================================== 00118bb0 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 118bb0: 55 push %ebp 118bb1: 89 e5 mov %esp,%ebp 118bb3: 53 push %ebx 118bb4: 8b 55 08 mov 0x8(%ebp),%edx 118bb7: 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; 118bba: b8 01 00 00 00 mov $0x1,%eax 118bbf: 2b 42 08 sub 0x8(%edx),%eax 118bc2: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 118bc5: 0f b7 5a 10 movzwl 0x10(%edx),%ebx 118bc9: 39 c3 cmp %eax,%ebx 118bcb: 72 12 jb 118bdf <_Objects_Get_no_protection+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { 118bcd: 8b 52 1c mov 0x1c(%edx),%edx 118bd0: 8b 04 82 mov (%edx,%eax,4),%eax 118bd3: 85 c0 test %eax,%eax 118bd5: 74 08 je 118bdf <_Objects_Get_no_protection+0x2f><== NEVER TAKEN *location = OBJECTS_LOCAL; 118bd7: c7 01 00 00 00 00 movl $0x0,(%ecx) return the_object; 118bdd: eb 08 jmp 118be7 <_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; 118bdf: c7 01 01 00 00 00 movl $0x1,(%ecx) return NULL; 118be5: 31 c0 xor %eax,%eax } 118be7: 5b pop %ebx 118be8: c9 leave 118be9: c3 ret =============================================================================== 0010c8bc <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10c8bc: 55 push %ebp 10c8bd: 89 e5 mov %esp,%ebp 10c8bf: 53 push %ebx 10c8c0: 83 ec 14 sub $0x14,%esp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10c8c3: 8b 45 08 mov 0x8(%ebp),%eax 10c8c6: 85 c0 test %eax,%eax 10c8c8: 75 08 jne 10c8d2 <_Objects_Id_to_name+0x16> 10c8ca: a1 d4 78 12 00 mov 0x1278d4,%eax 10c8cf: 8b 40 08 mov 0x8(%eax),%eax 10c8d2: 89 c2 mov %eax,%edx 10c8d4: c1 ea 18 shr $0x18,%edx 10c8d7: 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 ) 10c8da: 8d 4a ff lea -0x1(%edx),%ecx the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 10c8dd: bb 03 00 00 00 mov $0x3,%ebx 10c8e2: 83 f9 02 cmp $0x2,%ecx 10c8e5: 77 36 ja 10c91d <_Objects_Id_to_name+0x61> 10c8e7: eb 3b jmp 10c924 <_Objects_Id_to_name+0x68> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10c8e9: 89 c1 mov %eax,%ecx 10c8eb: 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 ]; 10c8ee: 8b 14 8a mov (%edx,%ecx,4),%edx if ( !information ) 10c8f1: 85 d2 test %edx,%edx 10c8f3: 74 28 je 10c91d <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10c8f5: 80 7a 38 00 cmpb $0x0,0x38(%edx) 10c8f9: 75 22 jne 10c91d <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 10c8fb: 51 push %ecx 10c8fc: 8d 4d f4 lea -0xc(%ebp),%ecx 10c8ff: 51 push %ecx 10c900: 50 push %eax 10c901: 52 push %edx 10c902: e8 5d ff ff ff call 10c864 <_Objects_Get> if ( !the_object ) 10c907: 83 c4 10 add $0x10,%esp 10c90a: 85 c0 test %eax,%eax 10c90c: 74 0f je 10c91d <_Objects_Id_to_name+0x61> return OBJECTS_INVALID_ID; *name = the_object->name; 10c90e: 8b 50 0c mov 0xc(%eax),%edx 10c911: 8b 45 0c mov 0xc(%ebp),%eax 10c914: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10c916: e8 73 0a 00 00 call 10d38e <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10c91b: 31 db xor %ebx,%ebx } 10c91d: 89 d8 mov %ebx,%eax 10c91f: 8b 5d fc mov -0x4(%ebp),%ebx 10c922: c9 leave 10c923: 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 ] ) 10c924: 8b 14 95 84 73 12 00 mov 0x127384(,%edx,4),%edx 10c92b: 85 d2 test %edx,%edx 10c92d: 75 ba jne 10c8e9 <_Objects_Id_to_name+0x2d> 10c92f: eb ec jmp 10c91d <_Objects_Id_to_name+0x61> =============================================================================== 0010e310 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10e310: 55 push %ebp 10e311: 89 e5 mov %esp,%ebp 10e313: 57 push %edi 10e314: 56 push %esi 10e315: 53 push %ebx 10e316: 83 ec 30 sub $0x30,%esp 10e319: 8b 75 08 mov 0x8(%ebp),%esi 10e31c: 8b 5d 14 mov 0x14(%ebp),%ebx 10e31f: 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 ); 10e322: 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( 10e325: 50 push %eax 10e326: 56 push %esi 10e327: 68 30 e3 12 00 push $0x12e330 10e32c: 88 55 d4 mov %dl,-0x2c(%ebp) 10e32f: e8 f0 2a 00 00 call 110e24 <_Objects_Get> switch ( location ) { 10e334: 83 c4 10 add $0x10,%esp 10e337: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10e33b: 8a 55 d4 mov -0x2c(%ebp),%dl 10e33e: 0f 85 aa 00 00 00 jne 10e3ee <_POSIX_Message_queue_Receive_support+0xde> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10e344: 8b 78 14 mov 0x14(%eax),%edi 10e347: 89 f9 mov %edi,%ecx 10e349: 83 e1 03 and $0x3,%ecx 10e34c: 49 dec %ecx 10e34d: 75 0a jne 10e359 <_POSIX_Message_queue_Receive_support+0x49> _Thread_Enable_dispatch(); 10e34f: e8 f6 35 00 00 call 11194a <_Thread_Enable_dispatch> 10e354: e9 95 00 00 00 jmp 10e3ee <_POSIX_Message_queue_Receive_support+0xde> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10e359: 8b 40 10 mov 0x10(%eax),%eax if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10e35c: 8b 48 68 mov 0x68(%eax),%ecx 10e35f: 39 4d 10 cmp %ecx,0x10(%ebp) 10e362: 73 15 jae 10e379 <_POSIX_Message_queue_Receive_support+0x69> _Thread_Enable_dispatch(); 10e364: e8 e1 35 00 00 call 11194a <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10e369: e8 ee 8a 00 00 call 116e5c <__errno> 10e36e: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10e374: e9 80 00 00 00 jmp 10e3f9 <_POSIX_Message_queue_Receive_support+0xe9> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10e379: 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 ) 10e380: 31 c9 xor %ecx,%ecx 10e382: 84 d2 test %dl,%dl 10e384: 74 09 je 10e38f <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true; 10e386: 81 e7 00 40 00 00 and $0x4000,%edi 10e38c: 0f 94 c1 sete %cl do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10e38f: 52 push %edx 10e390: 52 push %edx 10e391: ff 75 1c pushl 0x1c(%ebp) 10e394: 0f b6 c9 movzbl %cl,%ecx 10e397: 51 push %ecx 10e398: 8d 55 e0 lea -0x20(%ebp),%edx 10e39b: 52 push %edx 10e39c: ff 75 0c pushl 0xc(%ebp) 10e39f: 56 push %esi 10e3a0: 83 c0 1c add $0x1c,%eax 10e3a3: 50 push %eax 10e3a4: e8 7f 1c 00 00 call 110028 <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10e3a9: 83 c4 20 add $0x20,%esp 10e3ac: e8 99 35 00 00 call 11194a <_Thread_Enable_dispatch> *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10e3b1: a1 a8 e3 12 00 mov 0x12e3a8,%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); 10e3b6: 8b 50 24 mov 0x24(%eax),%edx 10e3b9: c1 fa 1f sar $0x1f,%edx 10e3bc: 8b 48 24 mov 0x24(%eax),%ecx 10e3bf: 31 d1 xor %edx,%ecx 10e3c1: 89 0b mov %ecx,(%ebx) 10e3c3: 29 13 sub %edx,(%ebx) if ( !_Thread_Executing->Wait.return_code ) 10e3c5: 83 78 34 00 cmpl $0x0,0x34(%eax) 10e3c9: 75 05 jne 10e3d0 <_POSIX_Message_queue_Receive_support+0xc0> return length_out; 10e3cb: 8b 45 e0 mov -0x20(%ebp),%eax 10e3ce: eb 2c jmp 10e3fc <_POSIX_Message_queue_Receive_support+0xec> rtems_set_errno_and_return_minus_one( 10e3d0: e8 87 8a 00 00 call 116e5c <__errno> 10e3d5: 89 c3 mov %eax,%ebx 10e3d7: 83 ec 0c sub $0xc,%esp 10e3da: a1 a8 e3 12 00 mov 0x12e3a8,%eax 10e3df: ff 70 34 pushl 0x34(%eax) 10e3e2: e8 ed 01 00 00 call 10e5d4 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10e3e7: 89 03 mov %eax,(%ebx) 10e3e9: 83 c4 10 add $0x10,%esp 10e3ec: eb 0b jmp 10e3f9 <_POSIX_Message_queue_Receive_support+0xe9> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e3ee: e8 69 8a 00 00 call 116e5c <__errno> 10e3f3: c7 00 09 00 00 00 movl $0x9,(%eax) 10e3f9: 83 c8 ff or $0xffffffff,%eax } 10e3fc: 8d 65 f4 lea -0xc(%ebp),%esp 10e3ff: 5b pop %ebx 10e400: 5e pop %esi 10e401: 5f pop %edi 10e402: c9 leave 10e403: c3 ret =============================================================================== 0010bccb <_POSIX_Mutex_Get_interrupt_disable>: POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable ( pthread_mutex_t *mutex, Objects_Locations *location, ISR_Level *level ) { 10bccb: 55 push %ebp 10bccc: 89 e5 mov %esp,%ebp 10bcce: 56 push %esi 10bccf: 53 push %ebx 10bcd0: 8b 5d 08 mov 0x8(%ebp),%ebx 10bcd3: 8b 75 0c mov 0xc(%ebp),%esi ___POSIX_Mutex_Get_support_error_check( mutex, location ); 10bcd6: 85 db test %ebx,%ebx 10bcd8: 74 16 je 10bcf0 <_POSIX_Mutex_Get_interrupt_disable+0x25> ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); 10bcda: 83 3b ff cmpl $0xffffffff,(%ebx) 10bcdd: 75 1b jne 10bcfa <_POSIX_Mutex_Get_interrupt_disable+0x2f> 10bcdf: 51 push %ecx 10bce0: 51 push %ecx 10bce1: 6a 00 push $0x0 10bce3: 53 push %ebx 10bce4: e8 73 00 00 00 call 10bd5c 10bce9: 83 c4 10 add $0x10,%esp 10bcec: 85 c0 test %eax,%eax 10bcee: 74 0a je 10bcfa <_POSIX_Mutex_Get_interrupt_disable+0x2f><== NEVER TAKEN 10bcf0: c7 06 01 00 00 00 movl $0x1,(%esi) 10bcf6: 31 c0 xor %eax,%eax 10bcf8: eb 13 jmp 10bd0d <_POSIX_Mutex_Get_interrupt_disable+0x42> return (POSIX_Mutex_Control *) _Objects_Get_isr_disable( 10bcfa: ff 75 10 pushl 0x10(%ebp) 10bcfd: 56 push %esi 10bcfe: ff 33 pushl (%ebx) 10bd00: 68 54 a7 12 00 push $0x12a754 10bd05: e8 06 27 00 00 call 10e410 <_Objects_Get_isr_disable> 10bd0a: 83 c4 10 add $0x10,%esp &_POSIX_Mutex_Information, (Objects_Id) *mutex, location, level ); } 10bd0d: 8d 65 f8 lea -0x8(%ebp),%esp 10bd10: 5b pop %ebx 10bd11: 5e pop %esi 10bd12: c9 leave 10bd13: c3 ret =============================================================================== 0010e9dc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 10e9dc: 55 push %ebp 10e9dd: 89 e5 mov %esp,%ebp 10e9df: 83 ec 08 sub $0x8,%esp 10e9e2: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e9e5: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10e9eb: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10e9f2: 75 2c jne 10ea20 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN 10e9f4: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 10e9fb: 75 23 jne 10ea20 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44> thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 10e9fd: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10ea04: 74 1a je 10ea20 <_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; 10ea06: a1 50 63 12 00 mov 0x126350,%eax 10ea0b: 48 dec %eax 10ea0c: a3 50 63 12 00 mov %eax,0x126350 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 10ea11: 50 push %eax 10ea12: 50 push %eax 10ea13: 6a ff push $0xffffffff 10ea15: 52 push %edx 10ea16: e8 51 08 00 00 call 10f26c <_POSIX_Thread_Exit> 10ea1b: 83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 10ea1e: c9 leave 10ea1f: c3 ret 10ea20: 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(); 10ea21: e9 78 db ff ff jmp 10c59e <_Thread_Enable_dispatch> =============================================================================== 0010fc74 <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 10fc74: 55 push %ebp 10fc75: 89 e5 mov %esp,%ebp 10fc77: 57 push %edi 10fc78: 56 push %esi 10fc79: 53 push %ebx 10fc7a: 83 ec 28 sub $0x28,%esp 10fc7d: 8b 55 08 mov 0x8(%ebp),%edx 10fc80: 8b 5d 0c mov 0xc(%ebp),%ebx 10fc83: 8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10fc86: ff 33 pushl (%ebx) 10fc88: 89 55 e0 mov %edx,-0x20(%ebp) 10fc8b: e8 c4 ff ff ff call 10fc54 <_POSIX_Priority_Is_valid> 10fc90: 83 c4 10 add $0x10,%esp return EINVAL; 10fc93: 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 ) ) 10fc98: 84 c0 test %al,%al 10fc9a: 8b 55 e0 mov -0x20(%ebp),%edx 10fc9d: 0f 84 a4 00 00 00 je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10fca3: c7 07 00 00 00 00 movl $0x0,(%edi) *budget_callout = NULL; 10fca9: 8b 45 14 mov 0x14(%ebp),%eax 10fcac: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 10fcb2: 85 d2 test %edx,%edx 10fcb4: 75 0b jne 10fcc1 <_POSIX_Thread_Translate_sched_param+0x4d> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10fcb6: c7 07 01 00 00 00 movl $0x1,(%edi) 10fcbc: e9 83 00 00 00 jmp 10fd44 <_POSIX_Thread_Translate_sched_param+0xd0> return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 10fcc1: 31 f6 xor %esi,%esi if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 10fcc3: 83 fa 01 cmp $0x1,%edx 10fcc6: 74 7f je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 10fcc8: 83 fa 02 cmp $0x2,%edx 10fccb: 75 08 jne 10fcd5 <_POSIX_Thread_Translate_sched_param+0x61> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 10fccd: c7 07 02 00 00 00 movl $0x2,(%edi) return 0; 10fcd3: eb 72 jmp 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; 10fcd5: 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 ) { 10fcda: 83 fa 04 cmp $0x4,%edx 10fcdd: 75 68 jne 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> if ( (param->sched_ss_repl_period.tv_sec == 0) && 10fcdf: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10fce3: 75 06 jne 10fceb <_POSIX_Thread_Translate_sched_param+0x77> 10fce5: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10fce9: 74 5c je 10fd47 <_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) && 10fceb: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fcef: 75 0b jne 10fcfc <_POSIX_Thread_Translate_sched_param+0x88> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; 10fcf1: 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) && 10fcf6: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fcfa: 74 4b je 10fd47 <_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 ) < 10fcfc: 83 ec 0c sub $0xc,%esp 10fcff: 8d 43 08 lea 0x8(%ebx),%eax 10fd02: 50 push %eax 10fd03: e8 00 de ff ff call 10db08 <_Timespec_To_ticks> 10fd08: 89 45 e4 mov %eax,-0x1c(%ebp) _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 10fd0b: 8d 43 10 lea 0x10(%ebx),%eax 10fd0e: 89 04 24 mov %eax,(%esp) 10fd11: e8 f2 dd ff ff call 10db08 <_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 ) < 10fd16: 83 c4 10 add $0x10,%esp _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; 10fd19: 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 ) < 10fd1e: 39 45 e4 cmp %eax,-0x1c(%ebp) 10fd21: 72 24 jb 10fd47 <_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 ) ) 10fd23: 83 ec 0c sub $0xc,%esp 10fd26: ff 73 04 pushl 0x4(%ebx) 10fd29: e8 26 ff ff ff call 10fc54 <_POSIX_Priority_Is_valid> 10fd2e: 83 c4 10 add $0x10,%esp 10fd31: 84 c0 test %al,%al 10fd33: 74 12 je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 10fd35: c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 10fd3b: 8b 45 14 mov 0x14(%ebp),%eax 10fd3e: c7 00 41 a8 10 00 movl $0x10a841,(%eax) return 0; 10fd44: 66 31 f6 xor %si,%si } return EINVAL; } 10fd47: 89 f0 mov %esi,%eax 10fd49: 8d 65 f4 lea -0xc(%ebp),%esp 10fd4c: 5b pop %ebx 10fd4d: 5e pop %esi 10fd4e: 5f pop %edi 10fd4f: c9 leave 10fd50: c3 ret =============================================================================== 0010a544 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10a544: 55 push %ebp 10a545: 89 e5 mov %esp,%ebp 10a547: 57 push %edi 10a548: 56 push %esi 10a549: 53 push %ebx 10a54a: 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; 10a54d: 8b 3d 40 22 12 00 mov 0x122240,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10a553: 8b 15 3c 22 12 00 mov 0x12223c,%edx if ( !user_threads || maximum == 0 ) 10a559: 85 d2 test %edx,%edx 10a55b: 74 54 je 10a5b1 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a55d: 85 ff test %edi,%edi 10a55f: 74 50 je 10a5b1 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a561: 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 ); 10a563: 8d 75 a4 lea -0x5c(%ebp),%esi 10a566: 83 ec 0c sub $0xc,%esp 10a569: 56 push %esi 10a56a: 89 55 94 mov %edx,-0x6c(%ebp) 10a56d: e8 e2 57 00 00 call 10fd54 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10a572: 5a pop %edx 10a573: 59 pop %ecx 10a574: 6a 02 push $0x2 10a576: 56 push %esi 10a577: e8 00 58 00 00 call 10fd7c (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10a57c: 59 pop %ecx 10a57d: 58 pop %eax 10a57e: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10a582: 56 push %esi 10a583: e8 20 58 00 00 call 10fda8 status = pthread_create( 10a588: 6a 00 push $0x0 10a58a: ff 34 df pushl (%edi,%ebx,8) 10a58d: 56 push %esi 10a58e: 8d 45 e4 lea -0x1c(%ebp),%eax 10a591: 50 push %eax 10a592: e8 e5 fc ff ff call 10a27c &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10a597: 83 c4 20 add $0x20,%esp 10a59a: 85 c0 test %eax,%eax 10a59c: 8b 55 94 mov -0x6c(%ebp),%edx 10a59f: 74 0b je 10a5ac <_POSIX_Threads_Initialize_user_threads_body+0x68> _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 10a5a1: 52 push %edx 10a5a2: 50 push %eax 10a5a3: 6a 01 push $0x1 10a5a5: 6a 02 push $0x2 10a5a7: e8 e8 1b 00 00 call 10c194 <_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++ ) { 10a5ac: 43 inc %ebx 10a5ad: 39 d3 cmp %edx,%ebx 10a5af: 72 b5 jb 10a566 <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); } } 10a5b1: 8d 65 f4 lea -0xc(%ebp),%esp 10a5b4: 5b pop %ebx 10a5b5: 5e pop %esi 10a5b6: 5f pop %edi 10a5b7: c9 leave 10a5b8: c3 ret =============================================================================== 0010edcf <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 10edcf: 55 push %ebp 10edd0: 89 e5 mov %esp,%ebp 10edd2: 56 push %esi 10edd3: 53 push %ebx 10edd4: 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 ]; 10edd7: 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 ); 10eddd: 83 ec 0c sub $0xc,%esp 10ede0: 8d 86 98 00 00 00 lea 0x98(%esi),%eax 10ede6: 50 push %eax 10ede7: e8 88 0d 00 00 call 10fb74 <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 10edec: 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); 10edef: 0f b6 05 24 12 12 00 movzbl 0x121224,%eax 10edf6: 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; 10edfc: 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 ) { 10edff: 83 c4 10 add $0x10,%esp 10ee02: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10ee06: 75 12 jne 10ee1a <_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 ) { 10ee08: 39 43 14 cmp %eax,0x14(%ebx) 10ee0b: 76 0d jbe 10ee1a <_POSIX_Threads_Sporadic_budget_TSR+0x4b> _Thread_Change_priority( the_thread, new_priority, true ); 10ee0d: 52 push %edx 10ee0e: 6a 01 push $0x1 10ee10: 50 push %eax 10ee11: 53 push %ebx 10ee12: e8 0d d0 ff ff call 10be24 <_Thread_Change_priority> 10ee17: 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 ); 10ee1a: 83 ec 0c sub $0xc,%esp 10ee1d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax 10ee23: 50 push %eax 10ee24: e8 4b 0d 00 00 call 10fb74 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10ee29: 89 86 b4 00 00 00 mov %eax,0xb4(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10ee2f: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 10ee32: 81 c6 a8 00 00 00 add $0xa8,%esi 10ee38: 89 75 0c mov %esi,0xc(%ebp) 10ee3b: c7 45 08 04 54 12 00 movl $0x125404,0x8(%ebp) } 10ee42: 8d 65 f8 lea -0x8(%ebp),%esp 10ee45: 5b pop %ebx 10ee46: 5e pop %esi 10ee47: c9 leave 10ee48: e9 c3 df ff ff jmp 10ce10 <_Watchdog_Insert> =============================================================================== 0010ee4d <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10ee4d: 55 push %ebp 10ee4e: 89 e5 mov %esp,%ebp 10ee50: 83 ec 08 sub $0x8,%esp 10ee53: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ee56: 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 */ 10ee5c: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 10ee63: 0f b6 15 24 12 12 00 movzbl 0x121224,%edx 10ee6a: 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; 10ee70: 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 ) { 10ee73: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10ee77: 75 12 jne 10ee8b <_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 ) { 10ee79: 39 50 14 cmp %edx,0x14(%eax) 10ee7c: 73 0d jae 10ee8b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN _Thread_Change_priority( the_thread, new_priority, true ); 10ee7e: 51 push %ecx 10ee7f: 6a 01 push $0x1 10ee81: 52 push %edx 10ee82: 50 push %eax 10ee83: e8 9c cf ff ff call 10be24 <_Thread_Change_priority> 10ee88: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 10ee8b: c9 leave 10ee8c: c3 ret =============================================================================== 0010a304 <_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) { 10a304: 55 push %ebp 10a305: 89 e5 mov %esp,%ebp 10a307: 53 push %ebx 10a308: 83 ec 04 sub $0x4,%esp 10a30b: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a30e: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a311: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 10a315: 75 06 jne 10a31d <_POSIX_Timer_TSR+0x19> 10a317: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10a31b: 74 34 je 10a351 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10a31d: 83 ec 0c sub $0xc,%esp 10a320: 53 push %ebx 10a321: 68 04 a3 10 00 push $0x10a304 10a326: ff 73 08 pushl 0x8(%ebx) 10a329: ff 73 64 pushl 0x64(%ebx) 10a32c: 8d 43 10 lea 0x10(%ebx),%eax 10a32f: 50 push %eax 10a330: e8 e7 56 00 00 call 10fa1c <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a335: 83 c4 20 add $0x20,%esp 10a338: 84 c0 test %al,%al 10a33a: 74 30 je 10a36c <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a33c: 83 ec 0c sub $0xc,%esp 10a33f: 8d 43 6c lea 0x6c(%ebx),%eax 10a342: 50 push %eax 10a343: e8 5c 14 00 00 call 10b7a4 <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a348: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10a34c: 83 c4 10 add $0x10,%esp 10a34f: eb 04 jmp 10a355 <_POSIX_Timer_TSR+0x51> } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a351: 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 ) ) { 10a355: 50 push %eax 10a356: 50 push %eax 10a357: ff 73 44 pushl 0x44(%ebx) 10a35a: ff 73 38 pushl 0x38(%ebx) 10a35d: e8 92 52 00 00 call 10f5f4 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a362: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10a369: 83 c4 10 add $0x10,%esp } 10a36c: 8b 5d fc mov -0x4(%ebp),%ebx 10a36f: c9 leave 10a370: c3 ret =============================================================================== 00110b54 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 110b54: 55 push %ebp 110b55: 89 e5 mov %esp,%ebp 110b57: 57 push %edi 110b58: 56 push %esi 110b59: 53 push %ebx 110b5a: 83 ec 68 sub $0x68,%esp 110b5d: 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, 110b60: 6a 01 push $0x1 110b62: 0f b6 45 10 movzbl 0x10(%ebp),%eax 110b66: 50 push %eax 110b67: 8d 45 dc lea -0x24(%ebp),%eax 110b6a: 50 push %eax 110b6b: 53 push %ebx 110b6c: ff 75 08 pushl 0x8(%ebp) 110b6f: e8 8c 00 00 00 call 110c00 <_POSIX_signals_Clear_signals> 110b74: 83 c4 20 add $0x20,%esp is_global, true ) ) return false; 110b77: 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, 110b79: 84 c0 test %al,%al 110b7b: 74 78 je 110bf5 <_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 ) 110b7d: 6b d3 0c imul $0xc,%ebx,%edx 110b80: 8b 82 a4 58 12 00 mov 0x1258a4(%edx),%eax 110b86: 83 f8 01 cmp $0x1,%eax 110b89: 74 6a je 110bf5 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 110b8b: 8b 4d 08 mov 0x8(%ebp),%ecx 110b8e: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 110b94: 89 4d a4 mov %ecx,-0x5c(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 110b97: 0b 8a a0 58 12 00 or 0x1258a0(%edx),%ecx 110b9d: 8b 75 08 mov 0x8(%ebp),%esi 110ba0: 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, 110ba6: 8d 7d b4 lea -0x4c(%ebp),%edi 110ba9: 8b 35 68 58 12 00 mov 0x125868,%esi 110baf: 83 c6 20 add $0x20,%esi 110bb2: b9 0a 00 00 00 mov $0xa,%ecx 110bb7: 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 ) { 110bb9: 83 ba 9c 58 12 00 02 cmpl $0x2,0x12589c(%edx) 110bc0: 75 09 jne 110bcb <_POSIX_signals_Check_signal+0x77> case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 110bc2: 52 push %edx 110bc3: 6a 00 push $0x0 110bc5: 8d 55 dc lea -0x24(%ebp),%edx 110bc8: 52 push %edx 110bc9: eb 03 jmp 110bce <_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 ); 110bcb: 83 ec 0c sub $0xc,%esp 110bce: 53 push %ebx 110bcf: ff d0 call *%eax break; 110bd1: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 110bd4: 8b 3d 68 58 12 00 mov 0x125868,%edi 110bda: 83 c7 20 add $0x20,%edi 110bdd: 8d 75 b4 lea -0x4c(%ebp),%esi 110be0: b9 0a 00 00 00 mov $0xa,%ecx 110be5: 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; 110be7: 8b 75 a4 mov -0x5c(%ebp),%esi 110bea: 8b 4d 08 mov 0x8(%ebp),%ecx 110bed: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx) return true; 110bf3: b1 01 mov $0x1,%cl } 110bf5: 88 c8 mov %cl,%al 110bf7: 8d 65 f4 lea -0xc(%ebp),%esp 110bfa: 5b pop %ebx 110bfb: 5e pop %esi 110bfc: 5f pop %edi 110bfd: c9 leave 110bfe: c3 ret =============================================================================== 001110e8 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 1110e8: 55 push %ebp 1110e9: 89 e5 mov %esp,%ebp 1110eb: 53 push %ebx 1110ec: 8b 4d 08 mov 0x8(%ebp),%ecx clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 1110ef: 9c pushf 1110f0: fa cli 1110f1: 5a pop %edx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 1110f2: 6b c1 0c imul $0xc,%ecx,%eax 1110f5: 83 b8 9c 58 12 00 02 cmpl $0x2,0x12589c(%eax) 1110fc: 75 0e jne 11110c <_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 ); 1110fe: 8d 98 98 5a 12 00 lea 0x125a98(%eax),%ebx if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 111104: 39 98 94 5a 12 00 cmp %ebx,0x125a94(%eax) 11110a: 75 0e jne 11111a <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN 11110c: 49 dec %ecx 11110d: b8 fe ff ff ff mov $0xfffffffe,%eax clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 111112: d3 c0 rol %cl,%eax 111114: 21 05 90 5a 12 00 and %eax,0x125a90 } _ISR_Enable( level ); 11111a: 52 push %edx 11111b: 9d popf } 11111c: 5b pop %ebx 11111d: c9 leave 11111e: c3 ret =============================================================================== 0010aba8 <_POSIX_signals_Get_lowest>: #include int _POSIX_signals_Get_lowest( sigset_t set ) { 10aba8: 55 push %ebp 10aba9: 89 e5 mov %esp,%ebp 10abab: 56 push %esi 10abac: 53 push %ebx 10abad: 8b 55 08 mov 0x8(%ebp),%edx int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10abb0: b8 1b 00 00 00 mov $0x1b,%eax 10abb5: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10abba: 8d 48 ff lea -0x1(%eax),%ecx 10abbd: 89 de mov %ebx,%esi 10abbf: d3 e6 shl %cl,%esi ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10abc1: 85 d6 test %edx,%esi 10abc3: 75 1e jne 10abe3 <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10abc5: 40 inc %eax 10abc6: 83 f8 20 cmp $0x20,%eax 10abc9: 75 ef jne 10abba <_POSIX_signals_Get_lowest+0x12> 10abcb: b0 01 mov $0x1,%al 10abcd: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10abd2: 8d 48 ff lea -0x1(%eax),%ecx 10abd5: 89 de mov %ebx,%esi 10abd7: 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 ) ) { 10abd9: 85 d6 test %edx,%esi 10abdb: 75 06 jne 10abe3 <_POSIX_signals_Get_lowest+0x3b> */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10abdd: 40 inc %eax 10abde: 83 f8 1b cmp $0x1b,%eax 10abe1: 75 ef jne 10abd2 <_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; } 10abe3: 5b pop %ebx 10abe4: 5e pop %esi 10abe5: c9 leave 10abe6: c3 ret =============================================================================== 001221a0 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 1221a0: 55 push %ebp 1221a1: 89 e5 mov %esp,%ebp 1221a3: 57 push %edi 1221a4: 56 push %esi 1221a5: 53 push %ebx 1221a6: 83 ec 0c sub $0xc,%esp 1221a9: 8b 5d 08 mov 0x8(%ebp),%ebx 1221ac: 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 ]; 1221af: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 1221b5: 8d 4e ff lea -0x1(%esi),%ecx 1221b8: ba 01 00 00 00 mov $0x1,%edx 1221bd: d3 e2 shl %cl,%edx /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 1221bf: 8b 4b 10 mov 0x10(%ebx),%ecx 1221c2: 89 cf mov %ecx,%edi 1221c4: 81 e7 00 80 00 10 and $0x10008000,%edi 1221ca: 81 ff 00 80 00 10 cmp $0x10008000,%edi 1221d0: 75 58 jne 12222a <_POSIX_signals_Unblock_thread+0x8a> if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 1221d2: 85 53 30 test %edx,0x30(%ebx) 1221d5: 75 12 jne 1221e9 <_POSIX_signals_Unblock_thread+0x49> 1221d7: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 1221dd: f7 d0 not %eax /* * This should only be reached via pthread_kill(). */ return false; 1221df: 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) ) { 1221e1: 85 c2 test %eax,%edx 1221e3: 0f 84 b0 00 00 00 je 122299 <_POSIX_signals_Unblock_thread+0xf9> the_thread->Wait.return_code = EINTR; 1221e9: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 1221f0: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 1221f3: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 1221f7: 75 12 jne 12220b <_POSIX_signals_Unblock_thread+0x6b> the_info->si_signo = signo; 1221f9: 89 30 mov %esi,(%eax) the_info->si_code = SI_USER; 1221fb: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 122202: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 122209: eb 0c jmp 122217 <_POSIX_signals_Unblock_thread+0x77> } else { *the_info = *info; 12220b: b9 03 00 00 00 mov $0x3,%ecx 122210: 89 c7 mov %eax,%edi 122212: 8b 75 10 mov 0x10(%ebp),%esi 122215: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 122217: 83 ec 0c sub $0xc,%esp 12221a: 53 push %ebx 12221b: e8 c0 ed fe ff call 110fe0 <_Thread_queue_Extract_with_proxy> return true; 122220: 83 c4 10 add $0x10,%esp 122223: bf 01 00 00 00 mov $0x1,%edi 122228: eb 6f jmp 122299 <_POSIX_signals_Unblock_thread+0xf9> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 12222a: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 122230: 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; 122232: 31 ff xor %edi,%edi } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 122234: 85 c2 test %eax,%edx 122236: 74 61 je 122299 <_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 ) ) { 122238: f7 c1 00 00 00 10 test $0x10000000,%ecx 12223e: 74 3d je 12227d <_POSIX_signals_Unblock_thread+0xdd> the_thread->Wait.return_code = EINTR; 122240: 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) ) 122247: f7 c1 e0 be 03 00 test $0x3bee0,%ecx 12224d: 74 0b je 12225a <_POSIX_signals_Unblock_thread+0xba> _Thread_queue_Extract_with_proxy( the_thread ); 12224f: 83 ec 0c sub $0xc,%esp 122252: 53 push %ebx 122253: e8 88 ed fe ff call 110fe0 <_Thread_queue_Extract_with_proxy> 122258: eb 1e jmp 122278 <_POSIX_signals_Unblock_thread+0xd8> else if ( _States_Is_delaying(the_thread->current_state) ) { 12225a: 80 e1 08 and $0x8,%cl 12225d: 74 3a je 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 12225f: 83 ec 0c sub $0xc,%esp 122262: 8d 43 48 lea 0x48(%ebx),%eax 122265: 50 push %eax 122266: e8 85 f4 fe ff call 1116f0 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 12226b: 58 pop %eax 12226c: 5a pop %edx 12226d: 68 f8 ff 03 10 push $0x1003fff8 122272: 53 push %ebx 122273: e8 2c e4 fe ff call 1106a4 <_Thread_Clear_state> 122278: 83 c4 10 add $0x10,%esp 12227b: eb 1c jmp 122299 <_POSIX_signals_Unblock_thread+0xf9> _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 12227d: 85 c9 test %ecx,%ecx 12227f: 75 18 jne 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 122281: 83 3d d8 b9 12 00 00 cmpl $0x0,0x12b9d8 122288: 74 0f je 122299 <_POSIX_signals_Unblock_thread+0xf9> 12228a: 3b 1d dc b9 12 00 cmp 0x12b9dc,%ebx 122290: 75 07 jne 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN _Thread_Dispatch_necessary = true; 122292: c6 05 e8 b9 12 00 01 movb $0x1,0x12b9e8 } } return false; } 122299: 89 f8 mov %edi,%eax 12229b: 8d 65 f4 lea -0xc(%ebp),%esp 12229e: 5b pop %ebx 12229f: 5e pop %esi 1222a0: 5f pop %edi 1222a1: c9 leave 1222a2: c3 ret =============================================================================== 0010efb0 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10efb0: 55 push %ebp 10efb1: 89 e5 mov %esp,%ebp 10efb3: 57 push %edi 10efb4: 56 push %esi 10efb5: 53 push %ebx 10efb6: 83 ec 1c sub $0x1c,%esp 10efb9: 8b 5d 08 mov 0x8(%ebp),%ebx 10efbc: 8b 75 0c mov 0xc(%ebp),%esi 10efbf: 8b 7d 10 mov 0x10(%ebp),%edi * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { 10efc2: a1 6c bc 12 00 mov 0x12bc6c,%eax 10efc7: 85 c0 test %eax,%eax 10efc9: 75 3c jne 10f007 <_Protected_heap_Walk+0x57><== NEVER TAKEN _RTEMS_Lock_allocator(); 10efcb: 83 ec 0c sub $0xc,%esp 10efce: ff 35 10 bd 12 00 pushl 0x12bd10 10efd4: e8 93 e6 ff ff call 10d66c <_API_Mutex_Lock> status = _Heap_Walk( the_heap, source, do_dump ); 10efd9: 83 c4 0c add $0xc,%esp 10efdc: 81 e7 ff 00 00 00 and $0xff,%edi 10efe2: 57 push %edi 10efe3: 56 push %esi 10efe4: 53 push %ebx 10efe5: e8 a4 f3 ff ff call 10e38e <_Heap_Walk> _RTEMS_Unlock_allocator(); 10efea: 5a pop %edx 10efeb: ff 35 10 bd 12 00 pushl 0x12bd10 10eff1: 88 45 e4 mov %al,-0x1c(%ebp) 10eff4: e8 bb e6 ff ff call 10d6b4 <_API_Mutex_Unlock> 10eff9: 83 c4 10 add $0x10,%esp } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 10effc: 8a 45 e4 mov -0x1c(%ebp),%al 10efff: 8d 65 f4 lea -0xc(%ebp),%esp 10f002: 5b pop %ebx 10f003: 5e pop %esi 10f004: 5f pop %edi 10f005: c9 leave 10f006: c3 ret if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 10f007: 81 e7 ff 00 00 00 and $0xff,%edi 10f00d: 89 7d 10 mov %edi,0x10(%ebp) 10f010: 89 75 0c mov %esi,0xc(%ebp) 10f013: 89 5d 08 mov %ebx,0x8(%ebp) } return status; } 10f016: 8d 65 f4 lea -0xc(%ebp),%esp 10f019: 5b pop %ebx 10f01a: 5e pop %esi 10f01b: 5f pop %edi 10f01c: c9 leave if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 10f01d: e9 6c f3 ff ff jmp 10e38e <_Heap_Walk> =============================================================================== 0010b3fc <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10b3fc: 55 push %ebp 10b3fd: 89 e5 mov %esp,%ebp 10b3ff: 53 push %ebx 10b400: 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 ); 10b403: 8d 45 f4 lea -0xc(%ebp),%eax 10b406: 50 push %eax 10b407: ff 75 08 pushl 0x8(%ebp) 10b40a: 68 74 83 12 00 push $0x128374 10b40f: e8 c8 1a 00 00 call 10cedc <_Objects_Get> 10b414: 89 c3 mov %eax,%ebx switch ( location ) { 10b416: 83 c4 10 add $0x10,%esp 10b419: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10b41d: 75 64 jne 10b483 <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10b41f: 8b 40 40 mov 0x40(%eax),%eax if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b422: f6 40 11 40 testb $0x40,0x11(%eax) 10b426: 74 18 je 10b440 <_Rate_monotonic_Timeout+0x44> 10b428: 8b 53 08 mov 0x8(%ebx),%edx 10b42b: 39 50 20 cmp %edx,0x20(%eax) 10b42e: 75 10 jne 10b440 <_Rate_monotonic_Timeout+0x44> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10b430: 52 push %edx 10b431: 52 push %edx 10b432: 68 f8 ff 03 10 push $0x1003fff8 10b437: 50 push %eax 10b438: e8 3b 22 00 00 call 10d678 <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10b43d: 59 pop %ecx 10b43e: eb 10 jmp 10b450 <_Rate_monotonic_Timeout+0x54> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10b440: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 10b444: 75 2b jne 10b471 <_Rate_monotonic_Timeout+0x75> the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10b446: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) _Rate_monotonic_Initiate_statistics( the_period ); 10b44d: 83 ec 0c sub $0xc,%esp 10b450: 53 push %ebx 10b451: e8 ec fa ff ff call 10af42 <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b456: 8b 43 3c mov 0x3c(%ebx),%eax 10b459: 89 43 1c mov %eax,0x1c(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b45c: 58 pop %eax 10b45d: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 10b45e: 83 c3 10 add $0x10,%ebx 10b461: 53 push %ebx 10b462: 68 28 85 12 00 push $0x128528 10b467: e8 34 32 00 00 call 10e6a0 <_Watchdog_Insert> 10b46c: 83 c4 10 add $0x10,%esp 10b46f: eb 07 jmp 10b478 <_Rate_monotonic_Timeout+0x7c> } else the_period->state = RATE_MONOTONIC_EXPIRED; 10b471: 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; 10b478: a1 64 84 12 00 mov 0x128464,%eax 10b47d: 48 dec %eax 10b47e: a3 64 84 12 00 mov %eax,0x128464 case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b483: 8b 5d fc mov -0x4(%ebp),%ebx 10b486: c9 leave 10b487: c3 ret =============================================================================== 0010ba6c <_Scheduler_priority_Block>: #include void _Scheduler_priority_Block( Thread_Control *the_thread ) { 10ba6c: 55 push %ebp 10ba6d: 89 e5 mov %esp,%ebp 10ba6f: 56 push %esi 10ba70: 53 push %ebx 10ba71: 8b 55 08 mov 0x8(%ebp),%edx ) { Scheduler_priority_Per_thread *sched_info; Chain_Control *ready; sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info; 10ba74: 8b 8a 8c 00 00 00 mov 0x8c(%edx),%ecx ready = sched_info->ready_chain; 10ba7a: 8b 01 mov (%ecx),%eax if ( _Chain_Has_only_one_node( ready ) ) { 10ba7c: 8b 58 08 mov 0x8(%eax),%ebx 10ba7f: 39 18 cmp %ebx,(%eax) 10ba81: 75 32 jne 10bab5 <_Scheduler_priority_Block+0x49> Chain_Node *tail = _Chain_Tail( the_chain ); 10ba83: 8d 58 04 lea 0x4(%eax),%ebx 10ba86: 89 18 mov %ebx,(%eax) head->next = tail; head->previous = NULL; 10ba88: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) tail->previous = head; 10ba8f: 89 40 08 mov %eax,0x8(%eax) RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor &= the_priority_map->block_minor; 10ba92: 8b 59 04 mov 0x4(%ecx),%ebx 10ba95: 66 8b 03 mov (%ebx),%ax 10ba98: 66 23 41 0e and 0xe(%ecx),%ax 10ba9c: 66 89 03 mov %ax,(%ebx) if ( *the_priority_map->minor == 0 ) 10ba9f: 66 85 c0 test %ax,%ax 10baa2: 75 1b jne 10babf <_Scheduler_priority_Block+0x53> _Priority_Major_bit_map &= the_priority_map->block_major; 10baa4: 66 a1 78 58 12 00 mov 0x125878,%ax 10baaa: 23 41 0c and 0xc(%ecx),%eax 10baad: 66 a3 78 58 12 00 mov %ax,0x125878 10bab3: eb 0a jmp 10babf <_Scheduler_priority_Block+0x53> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10bab5: 8b 0a mov (%edx),%ecx previous = the_node->previous; 10bab7: 8b 42 04 mov 0x4(%edx),%eax next->previous = previous; 10baba: 89 41 04 mov %eax,0x4(%ecx) previous->next = next; 10babd: 89 08 mov %ecx,(%eax) _Scheduler_priority_Ready_queue_extract( the_thread ); /* TODO: flash critical section? */ if ( _Thread_Is_heir( the_thread ) ) 10babf: 3b 15 6c 58 12 00 cmp 0x12586c,%edx 10bac5: 75 43 jne 10bb0a <_Scheduler_priority_Block+0x9e> 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 ); 10bac7: 66 8b 35 78 58 12 00 mov 0x125878,%si 10bace: 31 c9 xor %ecx,%ecx 10bad0: 89 cb mov %ecx,%ebx 10bad2: 66 0f bc de bsf %si,%bx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10bad6: 0f b7 db movzwl %bx,%ebx 10bad9: 66 8b b4 1b 7c 58 12 mov 0x12587c(%ebx,%ebx,1),%si 10bae0: 00 10bae1: 66 0f bc ce bsf %si,%cx return (_Priority_Bits_index( major ) << 4) + 10bae5: c1 e3 04 shl $0x4,%ebx 10bae8: 0f b7 c9 movzwl %cx,%ecx 10baeb: 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 ] ) ) 10baee: 6b c0 0c imul $0xc,%eax,%eax 10baf1: 03 05 50 11 12 00 add 0x121150,%eax _Scheduler_priority_Schedule_body(); if ( _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } 10baf7: 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 ); 10baf9: 83 c0 04 add $0x4,%eax return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10bafc: 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 ] ) ) 10bafe: 39 c3 cmp %eax,%ebx 10bb00: 74 02 je 10bb04 <_Scheduler_priority_Block+0x98><== NEVER TAKEN return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); 10bb02: 89 d9 mov %ebx,%ecx * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10bb04: 89 0d 6c 58 12 00 mov %ecx,0x12586c /* TODO: flash critical section? */ if ( _Thread_Is_heir( the_thread ) ) _Scheduler_priority_Schedule_body(); if ( _Thread_Is_executing( the_thread ) ) 10bb0a: 3b 15 68 58 12 00 cmp 0x125868,%edx 10bb10: 75 07 jne 10bb19 <_Scheduler_priority_Block+0xad> _Thread_Dispatch_necessary = true; 10bb12: c6 05 74 58 12 00 01 movb $0x1,0x125874 } 10bb19: 5b pop %ebx 10bb1a: 5e pop %esi 10bb1b: c9 leave 10bb1c: c3 ret =============================================================================== 0010bc6c <_Scheduler_priority_Schedule>: #include #include #include void _Scheduler_priority_Schedule(void) { 10bc6c: 55 push %ebp 10bc6d: 89 e5 mov %esp,%ebp 10bc6f: 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 ); 10bc70: 66 8b 1d 78 58 12 00 mov 0x125878,%bx 10bc77: 31 d2 xor %edx,%edx 10bc79: 89 d1 mov %edx,%ecx 10bc7b: 66 0f bc cb bsf %bx,%cx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10bc7f: 0f b7 c9 movzwl %cx,%ecx 10bc82: 66 8b 9c 09 7c 58 12 mov 0x12587c(%ecx,%ecx,1),%bx 10bc89: 00 10bc8a: 66 0f bc d3 bsf %bx,%dx return (_Priority_Bits_index( major ) << 4) + 10bc8e: c1 e1 04 shl $0x4,%ecx 10bc91: 0f b7 d2 movzwl %dx,%edx 10bc94: 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 ] ) ) 10bc97: 6b c0 0c imul $0xc,%eax,%eax 10bc9a: 03 05 50 11 12 00 add 0x121150,%eax _Scheduler_priority_Schedule_body(); } 10bca0: 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 ); 10bca2: 83 c0 04 add $0x4,%eax return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10bca5: 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 ] ) ) 10bca7: 39 c1 cmp %eax,%ecx 10bca9: 74 02 je 10bcad <_Scheduler_priority_Schedule+0x41><== NEVER TAKEN return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); 10bcab: 89 ca mov %ecx,%edx * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10bcad: 89 15 6c 58 12 00 mov %edx,0x12586c 10bcb3: 5b pop %ebx 10bcb4: c9 leave 10bcb5: c3 ret =============================================================================== 0010ad28 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10ad28: 55 push %ebp 10ad29: 89 e5 mov %esp,%ebp 10ad2b: 56 push %esi 10ad2c: 53 push %ebx 10ad2d: 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(); 10ad30: 8b 35 94 4b 12 00 mov 0x124b94,%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; 10ad36: 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) || 10ad38: 85 c9 test %ecx,%ecx 10ad3a: 74 57 je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10ad3c: b8 40 42 0f 00 mov $0xf4240,%eax 10ad41: 31 d2 xor %edx,%edx 10ad43: f7 f6 div %esi rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10ad45: 39 41 18 cmp %eax,0x18(%ecx) 10ad48: 73 49 jae 10ad93 <_TOD_Validate+0x6b> (the_tod->ticks >= ticks_per_second) || 10ad4a: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10ad4e: 77 43 ja 10ad93 <_TOD_Validate+0x6b> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10ad50: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10ad54: 77 3d ja 10ad93 <_TOD_Validate+0x6b> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10ad56: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10ad5a: 77 37 ja 10ad93 <_TOD_Validate+0x6b> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10ad5c: 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) || 10ad5f: 85 c0 test %eax,%eax 10ad61: 74 30 je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->month == 0) || 10ad63: 83 f8 0c cmp $0xc,%eax 10ad66: 77 2b ja 10ad93 <_TOD_Validate+0x6b> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10ad68: 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) || 10ad6a: 81 fe c3 07 00 00 cmp $0x7c3,%esi 10ad70: 76 21 jbe 10ad93 <_TOD_Validate+0x6b> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10ad72: 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) || 10ad75: 85 d2 test %edx,%edx 10ad77: 74 1a je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10ad79: 83 e6 03 and $0x3,%esi 10ad7c: 75 09 jne 10ad87 <_TOD_Validate+0x5f> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10ad7e: 8b 04 85 90 1d 12 00 mov 0x121d90(,%eax,4),%eax 10ad85: eb 07 jmp 10ad8e <_TOD_Validate+0x66> else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad87: 8b 04 85 5c 1d 12 00 mov 0x121d5c(,%eax,4),%eax * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 10ad8e: 39 c2 cmp %eax,%edx 10ad90: 0f 96 c3 setbe %bl if ( the_tod->day > days_in_month ) return false; return true; } 10ad93: 88 d8 mov %bl,%al 10ad95: 5b pop %ebx 10ad96: 5e pop %esi 10ad97: c9 leave 10ad98: c3 ret =============================================================================== 0010be24 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10be24: 55 push %ebp 10be25: 89 e5 mov %esp,%ebp 10be27: 57 push %edi 10be28: 56 push %esi 10be29: 53 push %ebx 10be2a: 83 ec 28 sub $0x28,%esp 10be2d: 8b 5d 08 mov 0x8(%ebp),%ebx 10be30: 8b 75 0c mov 0xc(%ebp),%esi 10be33: 8a 45 10 mov 0x10(%ebp),%al 10be36: 88 45 e7 mov %al,-0x19(%ebp) States_Control state, original_state; /* * Save original state */ original_state = the_thread->current_state; 10be39: 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 ); 10be3c: 53 push %ebx 10be3d: e8 62 0b 00 00 call 10c9a4 <_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 ) 10be42: 83 c4 10 add $0x10,%esp 10be45: 39 73 14 cmp %esi,0x14(%ebx) 10be48: 74 0c je 10be56 <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10be4a: 50 push %eax 10be4b: 50 push %eax 10be4c: 56 push %esi 10be4d: 53 push %ebx 10be4e: e8 01 0b 00 00 call 10c954 <_Thread_Set_priority> 10be53: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10be56: 9c pushf 10be57: fa cli 10be58: 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; 10be59: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10be5c: 83 f8 04 cmp $0x4,%eax 10be5f: 74 2b je 10be8c <_Thread_Change_priority+0x68> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10be61: 83 e7 04 and $0x4,%edi 10be64: 75 08 jne 10be6e <_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); 10be66: 89 c2 mov %eax,%edx 10be68: 83 e2 fb and $0xfffffffb,%edx 10be6b: 89 53 10 mov %edx,0x10(%ebx) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10be6e: 56 push %esi 10be6f: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10be70: a9 e0 be 03 00 test $0x3bee0,%eax 10be75: 74 65 je 10bedc <_Thread_Change_priority+0xb8> _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10be77: 89 5d 0c mov %ebx,0xc(%ebp) 10be7a: 8b 43 44 mov 0x44(%ebx),%eax 10be7d: 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 ); } 10be80: 8d 65 f4 lea -0xc(%ebp),%esp 10be83: 5b pop %ebx 10be84: 5e pop %esi 10be85: 5f pop %edi 10be86: 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 ); 10be87: e9 40 0a 00 00 jmp 10c8cc <_Thread_queue_Requeue> } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10be8c: 83 e7 04 and $0x4,%edi 10be8f: 75 26 jne 10beb7 <_Thread_Change_priority+0x93><== NEVER TAKEN * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10be91: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( prepend_it ) 10be98: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10be9c: 74 0c je 10beaa <_Thread_Change_priority+0x86> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue_first( the_thread ); 10be9e: 83 ec 0c sub $0xc,%esp 10bea1: 53 push %ebx 10bea2: ff 15 78 11 12 00 call *0x121178 10bea8: eb 0a jmp 10beb4 <_Thread_Change_priority+0x90> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue( the_thread ); 10beaa: 83 ec 0c sub $0xc,%esp 10bead: 53 push %ebx 10beae: ff 15 74 11 12 00 call *0x121174 10beb4: 83 c4 10 add $0x10,%esp _Scheduler_Enqueue_first( the_thread ); else _Scheduler_Enqueue( the_thread ); } _ISR_Flash( level ); 10beb7: 56 push %esi 10beb8: 9d popf 10beb9: fa cli * This kernel routine implements the scheduling decision logic for * the scheduler. It does NOT dispatch. */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void ) { _Scheduler.Operations.schedule(); 10beba: ff 15 58 11 12 00 call *0x121158 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10bec0: a1 68 58 12 00 mov 0x125868,%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(); if ( !_Thread_Is_executing_also_the_heir() && 10bec5: 3b 05 6c 58 12 00 cmp 0x12586c,%eax 10becb: 74 0d je 10beda <_Thread_Change_priority+0xb6> 10becd: 80 78 74 00 cmpb $0x0,0x74(%eax) 10bed1: 74 07 je 10beda <_Thread_Change_priority+0xb6> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10bed3: c6 05 74 58 12 00 01 movb $0x1,0x125874 _ISR_Enable( level ); 10beda: 56 push %esi 10bedb: 9d popf } 10bedc: 8d 65 f4 lea -0xc(%ebp),%esp 10bedf: 5b pop %ebx 10bee0: 5e pop %esi 10bee1: 5f pop %edi 10bee2: c9 leave 10bee3: c3 ret =============================================================================== 0010c088 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c088: 55 push %ebp 10c089: 89 e5 mov %esp,%ebp 10c08b: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c08e: 8d 45 f4 lea -0xc(%ebp),%eax 10c091: 50 push %eax 10c092: ff 75 08 pushl 0x8(%ebp) 10c095: e8 82 01 00 00 call 10c21c <_Thread_Get> switch ( location ) { 10c09a: 83 c4 10 add $0x10,%esp 10c09d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c0a1: 75 1b jne 10c0be <_Thread_Delay_ended+0x36><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10c0a3: 52 push %edx 10c0a4: 52 push %edx 10c0a5: 68 18 00 00 10 push $0x10000018 10c0aa: 50 push %eax 10c0ab: e8 34 fe ff ff call 10bee4 <_Thread_Clear_state> 10c0b0: a1 40 53 12 00 mov 0x125340,%eax 10c0b5: 48 dec %eax 10c0b6: a3 40 53 12 00 mov %eax,0x125340 10c0bb: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10c0be: c9 leave 10c0bf: c3 ret =============================================================================== 0010c0c0 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10c0c0: 55 push %ebp 10c0c1: 89 e5 mov %esp,%ebp 10c0c3: 57 push %edi 10c0c4: 56 push %esi 10c0c5: 53 push %ebx 10c0c6: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10c0c9: 8b 1d 68 58 12 00 mov 0x125868,%ebx _ISR_Disable( level ); 10c0cf: 9c pushf 10c0d0: fa cli 10c0d1: 58 pop %eax #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); _Timestamp_Subtract( 10c0d2: 8d 7d d8 lea -0x28(%ebp),%edi Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10c0d5: e9 f9 00 00 00 jmp 10c1d3 <_Thread_Dispatch+0x113> heir = _Thread_Heir; 10c0da: 8b 35 6c 58 12 00 mov 0x12586c,%esi _Thread_Dispatch_disable_level = 1; 10c0e0: c7 05 40 53 12 00 01 movl $0x1,0x125340 10c0e7: 00 00 00 _Thread_Dispatch_necessary = false; 10c0ea: c6 05 74 58 12 00 00 movb $0x0,0x125874 _Thread_Executing = heir; 10c0f1: 89 35 68 58 12 00 mov %esi,0x125868 /* * 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 ) 10c0f7: 39 de cmp %ebx,%esi 10c0f9: 0f 84 e2 00 00 00 je 10c1e1 <_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 ) 10c0ff: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10c103: 75 09 jne 10c10e <_Thread_Dispatch+0x4e> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c105: 8b 15 10 53 12 00 mov 0x125310,%edx 10c10b: 89 56 78 mov %edx,0x78(%esi) _ISR_Enable( level ); 10c10e: 50 push %eax 10c10f: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10c110: 83 ec 0c sub $0xc,%esp 10c113: 8d 45 e0 lea -0x20(%ebp),%eax 10c116: 50 push %eax 10c117: e8 5c 34 00 00 call 10f578 <_TOD_Get_uptime> _Timestamp_Subtract( 10c11c: 83 c4 0c add $0xc,%esp 10c11f: 57 push %edi 10c120: 8d 45 e0 lea -0x20(%ebp),%eax 10c123: 50 push %eax 10c124: 68 f0 53 12 00 push $0x1253f0 10c129: e8 76 0a 00 00 call 10cba4 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10c12e: 58 pop %eax 10c12f: 5a pop %edx 10c130: 57 push %edi 10c131: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10c137: 50 push %eax 10c138: e8 37 0a 00 00 call 10cb74 <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10c13d: 8b 45 e0 mov -0x20(%ebp),%eax 10c140: 8b 55 e4 mov -0x1c(%ebp),%edx 10c143: a3 f0 53 12 00 mov %eax,0x1253f0 10c148: 89 15 f4 53 12 00 mov %edx,0x1253f4 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10c14e: a1 c8 53 12 00 mov 0x1253c8,%eax 10c153: 83 c4 10 add $0x10,%esp 10c156: 85 c0 test %eax,%eax 10c158: 74 10 je 10c16a <_Thread_Dispatch+0xaa> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10c15a: 8b 10 mov (%eax),%edx 10c15c: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx) *_Thread_libc_reent = heir->libc_reent; 10c162: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx 10c168: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10c16a: 51 push %ecx 10c16b: 51 push %ecx 10c16c: 56 push %esi 10c16d: 53 push %ebx 10c16e: e8 69 0c 00 00 call 10cddc <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10c173: 58 pop %eax 10c174: 5a pop %edx 10c175: 81 c6 c8 00 00 00 add $0xc8,%esi 10c17b: 56 push %esi 10c17c: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10c182: 50 push %eax 10c183: e8 28 0f 00 00 call 10d0b0 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10c188: 83 c4 10 add $0x10,%esp 10c18b: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx) 10c192: 74 36 je 10c1ca <_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 ); 10c194: a1 c4 53 12 00 mov 0x1253c4,%eax 10c199: 39 c3 cmp %eax,%ebx 10c19b: 74 2d je 10c1ca <_Thread_Dispatch+0x10a> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10c19d: 85 c0 test %eax,%eax 10c19f: 74 11 je 10c1b2 <_Thread_Dispatch+0xf2> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10c1a1: 83 ec 0c sub $0xc,%esp 10c1a4: 05 e0 00 00 00 add $0xe0,%eax 10c1a9: 50 push %eax 10c1aa: e8 35 0f 00 00 call 10d0e4 <_CPU_Context_save_fp> 10c1af: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10c1b2: 83 ec 0c sub $0xc,%esp 10c1b5: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax 10c1bb: 50 push %eax 10c1bc: e8 2d 0f 00 00 call 10d0ee <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10c1c1: 89 1d c4 53 12 00 mov %ebx,0x1253c4 10c1c7: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10c1ca: 8b 1d 68 58 12 00 mov 0x125868,%ebx _ISR_Disable( level ); 10c1d0: 9c pushf 10c1d1: fa cli 10c1d2: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10c1d3: 8a 15 74 58 12 00 mov 0x125874,%dl 10c1d9: 84 d2 test %dl,%dl 10c1db: 0f 85 f9 fe ff ff jne 10c0da <_Thread_Dispatch+0x1a> _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10c1e1: c7 05 40 53 12 00 00 movl $0x0,0x125340 10c1e8: 00 00 00 _ISR_Enable( level ); 10c1eb: 50 push %eax 10c1ec: 9d popf _API_extensions_Run_postswitch(); 10c1ed: e8 3d e7 ff ff call 10a92f <_API_extensions_Run_postswitch> } 10c1f2: 8d 65 f4 lea -0xc(%ebp),%esp 10c1f5: 5b pop %ebx 10c1f6: 5e pop %esi 10c1f7: 5f pop %edi 10c1f8: c9 leave 10c1f9: c3 ret =============================================================================== 00110f9c <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 110f9c: 55 push %ebp 110f9d: 89 e5 mov %esp,%ebp 110f9f: 53 push %ebx 110fa0: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 110fa3: 8b 1d 68 58 12 00 mov 0x125868,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110fa9: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax _ISR_Set_level(level); 110faf: 85 c0 test %eax,%eax 110fb1: 74 03 je 110fb6 <_Thread_Handler+0x1a> 110fb3: fa cli 110fb4: eb 01 jmp 110fb7 <_Thread_Handler+0x1b> 110fb6: fb sti #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 110fb7: a0 00 50 12 00 mov 0x125000,%al 110fbc: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 110fbf: c6 05 00 50 12 00 01 movb $0x1,0x125000 #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 110fc6: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx) 110fcd: 74 24 je 110ff3 <_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 ); 110fcf: a1 c4 53 12 00 mov 0x1253c4,%eax 110fd4: 39 c3 cmp %eax,%ebx 110fd6: 74 1b je 110ff3 <_Thread_Handler+0x57> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 110fd8: 85 c0 test %eax,%eax 110fda: 74 11 je 110fed <_Thread_Handler+0x51> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110fdc: 83 ec 0c sub $0xc,%esp 110fdf: 05 e0 00 00 00 add $0xe0,%eax 110fe4: 50 push %eax 110fe5: e8 fa c0 ff ff call 10d0e4 <_CPU_Context_save_fp> 110fea: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 110fed: 89 1d c4 53 12 00 mov %ebx,0x1253c4 /* * 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 ); 110ff3: 83 ec 0c sub $0xc,%esp 110ff6: 53 push %ebx 110ff7: e8 90 bc ff ff call 10cc8c <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 110ffc: e8 f9 b1 ff ff call 10c1fa <_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) */ { 111001: 83 c4 10 add $0x10,%esp 111004: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 111008: 75 05 jne 11100f <_Thread_Handler+0x73> INIT_NAME (); 11100a: e8 31 c7 00 00 call 11d740 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 11100f: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 111015: 85 c0 test %eax,%eax 111017: 75 0b jne 111024 <_Thread_Handler+0x88> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 111019: 83 ec 0c sub $0xc,%esp 11101c: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 111022: eb 0c jmp 111030 <_Thread_Handler+0x94> executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 111024: 48 dec %eax 111025: 75 15 jne 11103c <_Thread_Handler+0xa0> <== NEVER TAKEN executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 111027: 83 ec 0c sub $0xc,%esp 11102a: ff b3 98 00 00 00 pushl 0x98(%ebx) 111030: 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 = 111036: 89 43 28 mov %eax,0x28(%ebx) 111039: 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 ); 11103c: 83 ec 0c sub $0xc,%esp 11103f: 53 push %ebx 111040: e8 78 bc ff ff call 10ccbd <_User_extensions_Thread_exitted> _Internal_error_Occurred( 111045: 83 c4 0c add $0xc,%esp 111048: 6a 05 push $0x5 11104a: 6a 01 push $0x1 11104c: 6a 00 push $0x0 11104e: e8 39 a2 ff ff call 10b28c <_Internal_error_Occurred> =============================================================================== 0010c290 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10c290: 55 push %ebp 10c291: 89 e5 mov %esp,%ebp 10c293: 57 push %edi 10c294: 56 push %esi 10c295: 53 push %ebx 10c296: 83 ec 1c sub $0x1c,%esp 10c299: 8b 5d 0c mov 0xc(%ebp),%ebx 10c29c: 8b 4d 10 mov 0x10(%ebp),%ecx 10c29f: 8b 75 14 mov 0x14(%ebp),%esi 10c2a2: 8a 55 18 mov 0x18(%ebp),%dl 10c2a5: 8a 45 20 mov 0x20(%ebp),%al 10c2a8: 88 45 e7 mov %al,-0x19(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10c2ab: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10c2b2: 00 00 00 10c2b5: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx) 10c2bc: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10c2bf: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10c2c6: 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 ) { 10c2c9: 85 c9 test %ecx,%ecx 10c2cb: 75 31 jne 10c2fe <_Thread_Initialize+0x6e> actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10c2cd: 57 push %edi 10c2ce: 57 push %edi 10c2cf: 56 push %esi 10c2d0: 53 push %ebx 10c2d1: 88 55 e0 mov %dl,-0x20(%ebp) 10c2d4: e8 fb 06 00 00 call 10c9d4 <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10c2d9: 83 c4 10 add $0x10,%esp 10c2dc: 39 f0 cmp %esi,%eax 10c2de: 8a 55 e0 mov -0x20(%ebp),%dl 10c2e1: 0f 82 bf 01 00 00 jb 10c4a6 <_Thread_Initialize+0x216> 10c2e7: 85 c0 test %eax,%eax 10c2e9: 0f 84 b7 01 00 00 je 10c4a6 <_Thread_Initialize+0x216><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10c2ef: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10c2f5: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx) 10c2fc: eb 09 jmp 10c307 <_Thread_Initialize+0x77> } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 10c2fe: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx) 10c305: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10c307: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx) the_stack->size = size; 10c30d: 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; 10c313: 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 ) { 10c315: 84 d2 test %dl,%dl 10c317: 74 17 je 10c330 <_Thread_Initialize+0xa0> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10c319: 83 ec 0c sub $0xc,%esp 10c31c: 6a 6c push $0x6c 10c31e: e8 27 0d 00 00 call 10d04a <_Workspace_Allocate> 10c323: 89 c7 mov %eax,%edi if ( !fp_area ) 10c325: 83 c4 10 add $0x10,%esp 10c328: 85 c0 test %eax,%eax 10c32a: 0f 84 23 01 00 00 je 10c453 <_Thread_Initialize+0x1c3> goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10c330: 89 bb e0 00 00 00 mov %edi,0xe0(%ebx) the_thread->Start.fp_context = fp_area; 10c336: 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; 10c33c: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10c343: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10c34a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10c351: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c358: a1 d4 53 12 00 mov 0x1253d4,%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; 10c35d: 31 f6 xor %esi,%esi #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c35f: 85 c0 test %eax,%eax 10c361: 74 1d je 10c380 <_Thread_Initialize+0xf0> extensions_area = _Workspace_Allocate( 10c363: 83 ec 0c sub $0xc,%esp 10c366: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10c36d: 50 push %eax 10c36e: e8 d7 0c 00 00 call 10d04a <_Workspace_Allocate> 10c373: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10c375: 83 c4 10 add $0x10,%esp 10c378: 85 c0 test %eax,%eax 10c37a: 0f 84 d5 00 00 00 je 10c455 <_Thread_Initialize+0x1c5> goto failed; } the_thread->extensions = (void **) extensions_area; 10c380: 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 ) { 10c386: 85 f6 test %esi,%esi 10c388: 74 16 je 10c3a0 <_Thread_Initialize+0x110> for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10c38a: 8b 15 d4 53 12 00 mov 0x1253d4,%edx 10c390: 31 c0 xor %eax,%eax 10c392: eb 08 jmp 10c39c <_Thread_Initialize+0x10c> the_thread->extensions[i] = NULL; 10c394: 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++ ) 10c39b: 40 inc %eax 10c39c: 39 d0 cmp %edx,%eax 10c39e: 76 f4 jbe 10c394 <_Thread_Initialize+0x104> /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c3a0: 8a 45 e7 mov -0x19(%ebp),%al 10c3a3: 88 83 a0 00 00 00 mov %al,0xa0(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10c3a9: 8b 45 24 mov 0x24(%ebp),%eax 10c3ac: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.budget_callout = budget_callout; 10c3b2: 8b 45 28 mov 0x28(%ebp),%eax 10c3b5: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) switch ( budget_algorithm ) { 10c3bb: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10c3bf: 75 08 jne 10c3c9 <_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; 10c3c1: a1 10 53 12 00 mov 0x125310,%eax 10c3c6: 89 43 78 mov %eax,0x78(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10c3c9: 8b 45 2c mov 0x2c(%ebp),%eax 10c3cc: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) the_thread->current_state = STATES_DORMANT; 10c3d2: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10c3d9: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10c3e0: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10c3e7: 8b 45 1c mov 0x1c(%ebp),%eax 10c3ea: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10c3ed: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) */ RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate( Thread_Control *the_thread ) { return _Scheduler.Operations.allocate( the_thread ); 10c3f3: 83 ec 0c sub $0xc,%esp 10c3f6: 53 push %ebx 10c3f7: ff 15 68 11 12 00 call *0x121168 10c3fd: 89 c2 mov %eax,%edx sched =_Scheduler_Allocate( the_thread ); if ( !sched ) 10c3ff: 83 c4 10 add $0x10,%esp 10c402: 85 c0 test %eax,%eax 10c404: 74 51 je 10c457 <_Thread_Initialize+0x1c7> goto failed; _Thread_Set_priority( the_thread, priority ); 10c406: 51 push %ecx 10c407: 51 push %ecx 10c408: ff 75 1c pushl 0x1c(%ebp) 10c40b: 53 push %ebx 10c40c: 89 45 e0 mov %eax,-0x20(%ebp) 10c40f: e8 40 05 00 00 call 10c954 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10c414: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10c41b: 00 00 00 10c41e: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10c425: 00 00 00 _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10c428: 8b 45 08 mov 0x8(%ebp),%eax 10c42b: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c42e: 0f b7 4b 08 movzwl 0x8(%ebx),%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c432: 89 1c 88 mov %ebx,(%eax,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c435: 8b 45 30 mov 0x30(%ebp),%eax 10c438: 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 ); 10c43b: 89 1c 24 mov %ebx,(%esp) 10c43e: e8 e9 08 00 00 call 10cd2c <_User_extensions_Thread_create> 10c443: 88 c1 mov %al,%cl if ( extension_status ) 10c445: 83 c4 10 add $0x10,%esp return true; 10c448: 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 ) 10c44a: 84 c9 test %cl,%cl 10c44c: 8b 55 e0 mov -0x20(%ebp),%edx 10c44f: 74 06 je 10c457 <_Thread_Initialize+0x1c7> 10c451: eb 55 jmp 10c4a8 <_Thread_Initialize+0x218> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c453: 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; 10c455: 31 d2 xor %edx,%edx extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; failed: _Workspace_Free( the_thread->libc_reent ); 10c457: 83 ec 0c sub $0xc,%esp 10c45a: ff b3 e4 00 00 00 pushl 0xe4(%ebx) 10c460: 89 55 e0 mov %edx,-0x20(%ebp) 10c463: e8 fb 0b 00 00 call 10d063 <_Workspace_Free> for ( i=0 ; i <= THREAD_API_LAST ; i++ ) _Workspace_Free( the_thread->API_Extensions[i] ); 10c468: 5a pop %edx 10c469: ff b3 e8 00 00 00 pushl 0xe8(%ebx) 10c46f: e8 ef 0b 00 00 call 10d063 <_Workspace_Free> 10c474: 58 pop %eax 10c475: ff b3 ec 00 00 00 pushl 0xec(%ebx) 10c47b: e8 e3 0b 00 00 call 10d063 <_Workspace_Free> _Workspace_Free( extensions_area ); 10c480: 89 34 24 mov %esi,(%esp) 10c483: e8 db 0b 00 00 call 10d063 <_Workspace_Free> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Workspace_Free( fp_area ); 10c488: 89 3c 24 mov %edi,(%esp) 10c48b: e8 d3 0b 00 00 call 10d063 <_Workspace_Free> #endif _Workspace_Free( sched ); 10c490: 8b 55 e0 mov -0x20(%ebp),%edx 10c493: 89 14 24 mov %edx,(%esp) 10c496: e8 c8 0b 00 00 call 10d063 <_Workspace_Free> _Thread_Stack_Free( the_thread ); 10c49b: 89 1c 24 mov %ebx,(%esp) 10c49e: e8 81 05 00 00 call 10ca24 <_Thread_Stack_Free> return false; 10c4a3: 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 */ 10c4a6: 31 c0 xor %eax,%eax _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10c4a8: 8d 65 f4 lea -0xc(%ebp),%esp 10c4ab: 5b pop %ebx 10c4ac: 5e pop %esi 10c4ad: 5f pop %edi 10c4ae: c9 leave 10c4af: c3 ret =============================================================================== 0010f6dc <_Thread_Resume>: */ void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10f6dc: 55 push %ebp 10f6dd: 89 e5 mov %esp,%ebp 10f6df: 53 push %ebx 10f6e0: 83 ec 04 sub $0x4,%esp 10f6e3: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10f6e6: 9c pushf 10f6e7: fa cli 10f6e8: 5b pop %ebx current_state = the_thread->current_state; 10f6e9: 8b 50 10 mov 0x10(%eax),%edx if ( current_state & STATES_SUSPENDED ) { 10f6ec: f6 c2 02 test $0x2,%dl 10f6ef: 74 17 je 10f708 <_Thread_Resume+0x2c> <== NEVER TAKEN 10f6f1: 83 e2 fd and $0xfffffffd,%edx current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); 10f6f4: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 10f6f7: 85 d2 test %edx,%edx 10f6f9: 75 0d jne 10f708 <_Thread_Resume+0x2c> */ RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Thread_Control *the_thread ) { _Scheduler.Operations.unblock( the_thread ); 10f6fb: 83 ec 0c sub $0xc,%esp 10f6fe: 50 push %eax 10f6ff: ff 15 64 41 12 00 call *0x124164 10f705: 83 c4 10 add $0x10,%esp _Scheduler_Unblock( the_thread ); } } _ISR_Enable( level ); 10f708: 53 push %ebx 10f709: 9d popf } 10f70a: 8b 5d fc mov -0x4(%ebp),%ebx 10f70d: c9 leave 10f70e: c3 ret =============================================================================== 0010cb0c <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10cb0c: 55 push %ebp 10cb0d: 89 e5 mov %esp,%ebp 10cb0f: 53 push %ebx 10cb10: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10cb13: 8b 1d 68 58 12 00 mov 0x125868,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10cb19: 80 7b 74 00 cmpb $0x0,0x74(%ebx) 10cb1d: 74 4d je 10cb6c <_Thread_Tickle_timeslice+0x60> return; if ( !_States_Is_ready( executing->current_state ) ) 10cb1f: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10cb23: 75 47 jne 10cb6c <_Thread_Tickle_timeslice+0x60> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10cb25: 8b 43 7c mov 0x7c(%ebx),%eax 10cb28: 83 f8 01 cmp $0x1,%eax 10cb2b: 72 3f jb 10cb6c <_Thread_Tickle_timeslice+0x60> 10cb2d: 83 f8 02 cmp $0x2,%eax 10cb30: 76 07 jbe 10cb39 <_Thread_Tickle_timeslice+0x2d> 10cb32: 83 f8 03 cmp $0x3,%eax 10cb35: 75 35 jne 10cb6c <_Thread_Tickle_timeslice+0x60><== NEVER TAKEN 10cb37: eb 1b jmp 10cb54 <_Thread_Tickle_timeslice+0x48> 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 ) { 10cb39: 8b 43 78 mov 0x78(%ebx),%eax 10cb3c: 48 dec %eax 10cb3d: 89 43 78 mov %eax,0x78(%ebx) 10cb40: 85 c0 test %eax,%eax 10cb42: 7f 28 jg 10cb6c <_Thread_Tickle_timeslice+0x60> * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield(); 10cb44: ff 15 5c 11 12 00 call *0x12115c * 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; 10cb4a: a1 10 53 12 00 mov 0x125310,%eax 10cb4f: 89 43 78 mov %eax,0x78(%ebx) 10cb52: eb 18 jmp 10cb6c <_Thread_Tickle_timeslice+0x60> } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10cb54: 8b 43 78 mov 0x78(%ebx),%eax 10cb57: 48 dec %eax 10cb58: 89 43 78 mov %eax,0x78(%ebx) 10cb5b: 85 c0 test %eax,%eax 10cb5d: 75 0d jne 10cb6c <_Thread_Tickle_timeslice+0x60> (*executing->budget_callout)( executing ); 10cb5f: 83 ec 0c sub $0xc,%esp 10cb62: 53 push %ebx 10cb63: ff 93 80 00 00 00 call *0x80(%ebx) 10cb69: 83 c4 10 add $0x10,%esp break; #endif } } 10cb6c: 8b 5d fc mov -0x4(%ebp),%ebx 10cb6f: c9 leave 10cb70: c3 ret =============================================================================== 0010c8cc <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10c8cc: 55 push %ebp 10c8cd: 89 e5 mov %esp,%ebp 10c8cf: 57 push %edi 10c8d0: 56 push %esi 10c8d1: 53 push %ebx 10c8d2: 83 ec 1c sub $0x1c,%esp 10c8d5: 8b 75 08 mov 0x8(%ebp),%esi 10c8d8: 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 ) 10c8db: 85 f6 test %esi,%esi 10c8dd: 74 36 je 10c915 <_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 ) { 10c8df: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10c8e3: 75 30 jne 10c915 <_Thread_queue_Requeue+0x49><== NEVER TAKEN Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10c8e5: 9c pushf 10c8e6: fa cli 10c8e7: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10c8e8: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10c8ef: 74 22 je 10c913 <_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; 10c8f1: 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 ); 10c8f8: 50 push %eax 10c8f9: 6a 01 push $0x1 10c8fb: 57 push %edi 10c8fc: 56 push %esi 10c8fd: e8 12 31 00 00 call 10fa14 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10c902: 83 c4 0c add $0xc,%esp 10c905: 8d 45 e4 lea -0x1c(%ebp),%eax 10c908: 50 push %eax 10c909: 57 push %edi 10c90a: 56 push %esi 10c90b: e8 c0 fd ff ff call 10c6d0 <_Thread_queue_Enqueue_priority> 10c910: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10c913: 53 push %ebx 10c914: 9d popf } } 10c915: 8d 65 f4 lea -0xc(%ebp),%esp 10c918: 5b pop %ebx 10c919: 5e pop %esi 10c91a: 5f pop %edi 10c91b: c9 leave 10c91c: c3 ret =============================================================================== 0010c920 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c920: 55 push %ebp 10c921: 89 e5 mov %esp,%ebp 10c923: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c926: 8d 45 f4 lea -0xc(%ebp),%eax 10c929: 50 push %eax 10c92a: ff 75 08 pushl 0x8(%ebp) 10c92d: e8 ea f8 ff ff call 10c21c <_Thread_Get> switch ( location ) { 10c932: 83 c4 10 add $0x10,%esp 10c935: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c939: 75 17 jne 10c952 <_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 ); 10c93b: 83 ec 0c sub $0xc,%esp 10c93e: 50 push %eax 10c93f: e8 88 31 00 00 call 10facc <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10c944: a1 40 53 12 00 mov 0x125340,%eax 10c949: 48 dec %eax 10c94a: a3 40 53 12 00 mov %eax,0x125340 10c94f: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10c952: c9 leave 10c953: c3 ret =============================================================================== 00116a64 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 116a64: 55 push %ebp 116a65: 89 e5 mov %esp,%ebp 116a67: 57 push %edi 116a68: 56 push %esi 116a69: 53 push %ebx 116a6a: 83 ec 4c sub $0x4c,%esp 116a6d: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116a70: 8d 55 dc lea -0x24(%ebp),%edx 116a73: 8d 45 e0 lea -0x20(%ebp),%eax 116a76: 89 45 dc mov %eax,-0x24(%ebp) head->previous = NULL; 116a79: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 116a80: 89 55 e4 mov %edx,-0x1c(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116a83: 8d 7d d0 lea -0x30(%ebp),%edi 116a86: 8d 4d d4 lea -0x2c(%ebp),%ecx 116a89: 89 4d d0 mov %ecx,-0x30(%ebp) head->previous = NULL; 116a8c: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 116a93: 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 ); 116a96: 8d 53 30 lea 0x30(%ebx),%edx 116a99: 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 ); 116a9c: 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; 116a9f: 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; 116aa2: 8d 4d dc lea -0x24(%ebp),%ecx 116aa5: 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; 116aa8: a1 e8 f1 13 00 mov 0x13f1e8,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 116aad: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 116ab0: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 116ab3: 51 push %ecx 116ab4: 57 push %edi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 116ab5: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 116ab7: 50 push %eax 116ab8: ff 75 c0 pushl -0x40(%ebp) 116abb: e8 d4 39 00 00 call 11a494 <_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(); 116ac0: a1 60 f1 13 00 mov 0x13f160,%eax 116ac5: 89 45 c4 mov %eax,-0x3c(%ebp) Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 116ac8: 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 ) { 116acb: 83 c4 10 add $0x10,%esp 116ace: 39 45 c4 cmp %eax,-0x3c(%ebp) 116ad1: 76 10 jbe 116ae3 <_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 ); 116ad3: 52 push %edx 116ad4: 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; 116ad5: 8b 55 c4 mov -0x3c(%ebp),%edx 116ad8: 29 c2 sub %eax,%edx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 116ada: 52 push %edx 116adb: 56 push %esi 116adc: e8 b3 39 00 00 call 11a494 <_Watchdog_Adjust_to_chain> 116ae1: eb 0f jmp 116af2 <_Timer_server_Body+0x8e> } else if ( snapshot < last_snapshot ) { 116ae3: 73 10 jae 116af5 <_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 ); 116ae5: 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; 116ae6: 2b 45 c4 sub -0x3c(%ebp),%eax _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 116ae9: 50 push %eax 116aea: 6a 01 push $0x1 116aec: 56 push %esi 116aed: e8 36 39 00 00 call 11a428 <_Watchdog_Adjust> 116af2: 83 c4 10 add $0x10,%esp } watchdogs->last_snapshot = snapshot; 116af5: 8b 4d c4 mov -0x3c(%ebp),%ecx 116af8: 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 ); 116afb: 8b 43 78 mov 0x78(%ebx),%eax 116afe: 83 ec 0c sub $0xc,%esp 116b01: 50 push %eax 116b02: e8 fd 08 00 00 call 117404 <_Chain_Get> if ( timer == NULL ) { 116b07: 83 c4 10 add $0x10,%esp 116b0a: 85 c0 test %eax,%eax 116b0c: 74 29 je 116b37 <_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 ) { 116b0e: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 116b11: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 116b14: 75 0b jne 116b21 <_Timer_server_Body+0xbd><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116b16: 52 push %edx <== NOT EXECUTED 116b17: 52 push %edx <== NOT EXECUTED 116b18: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 116b1b: 50 push %eax <== NOT EXECUTED 116b1c: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 116b1f: eb 0c jmp 116b2d <_Timer_server_Body+0xc9><== NOT EXECUTED } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116b21: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 116b24: 75 d5 jne 116afb <_Timer_server_Body+0x97><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116b26: 51 push %ecx <== NOT EXECUTED 116b27: 51 push %ecx <== NOT EXECUTED 116b28: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 116b2b: 50 push %eax <== NOT EXECUTED 116b2c: 56 push %esi <== NOT EXECUTED 116b2d: e8 ea 39 00 00 call 11a51c <_Watchdog_Insert> <== NOT EXECUTED 116b32: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116b35: eb c4 jmp 116afb <_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 ); 116b37: 9c pushf 116b38: fa cli 116b39: 5a pop %edx tmp = ts->insert_chain; 116b3a: 8b 43 78 mov 0x78(%ebx),%eax if ( _Chain_Is_empty( insert_chain ) ) { 116b3d: b0 01 mov $0x1,%al 116b3f: 8b 4d b4 mov -0x4c(%ebp),%ecx 116b42: 39 4d dc cmp %ecx,-0x24(%ebp) 116b45: 75 09 jne 116b50 <_Timer_server_Body+0xec><== NEVER TAKEN ts->insert_chain = NULL; 116b47: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) do_loop = false; 116b4e: 31 c0 xor %eax,%eax } _ISR_Enable( level ); 116b50: 52 push %edx 116b51: 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 ) { 116b52: 84 c0 test %al,%al 116b54: 0f 85 4e ff ff ff jne 116aa8 <_Timer_server_Body+0x44><== NEVER TAKEN 116b5a: 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 ) ) { 116b5d: 39 45 d0 cmp %eax,-0x30(%ebp) 116b60: 74 3a je 116b9c <_Timer_server_Body+0x138> 116b62: 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 ); 116b65: 9c pushf 116b66: fa cli 116b67: 59 pop %ecx initialized = false; } #endif return status; } 116b68: 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)) 116b6b: 3b 45 b0 cmp -0x50(%ebp),%eax 116b6e: 74 25 je 116b95 <_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; 116b70: 8b 10 mov (%eax),%edx head->next = new_first; 116b72: 89 55 d0 mov %edx,-0x30(%ebp) new_first->previous = head; 116b75: 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 ) { 116b78: 85 c0 test %eax,%eax 116b7a: 74 19 je 116b95 <_Timer_server_Body+0x131><== NEVER TAKEN watchdog->state = WATCHDOG_INACTIVE; 116b7c: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 116b83: 51 push %ecx 116b84: 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 ); 116b85: 52 push %edx 116b86: 52 push %edx 116b87: ff 70 24 pushl 0x24(%eax) 116b8a: ff 70 20 pushl 0x20(%eax) 116b8d: ff 50 1c call *0x1c(%eax) } 116b90: 83 c4 10 add $0x10,%esp 116b93: eb d0 jmp 116b65 <_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 ); 116b95: 51 push %ecx 116b96: 9d popf 116b97: e9 06 ff ff ff jmp 116aa2 <_Timer_server_Body+0x3e> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 116b9c: c6 43 7c 00 movb $0x0,0x7c(%ebx) /* * Block until there is something to do. */ _Thread_Disable_dispatch(); 116ba0: e8 23 fe ff ff call 1169c8 <_Thread_Disable_dispatch> _Thread_Set_state( ts->thread, STATES_DELAYING ); 116ba5: 51 push %ecx 116ba6: 51 push %ecx 116ba7: 6a 08 push $0x8 116ba9: ff 33 pushl (%ebx) 116bab: e8 18 33 00 00 call 119ec8 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 116bb0: 89 d8 mov %ebx,%eax 116bb2: e8 21 fe ff ff call 1169d8 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 116bb7: 89 d8 mov %ebx,%eax 116bb9: e8 60 fe ff ff call 116a1e <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 116bbe: e8 db 2a 00 00 call 11969e <_Thread_Enable_dispatch> ts->active = true; 116bc3: 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 ); 116bc7: 8d 43 08 lea 0x8(%ebx),%eax 116bca: 89 04 24 mov %eax,(%esp) 116bcd: e8 6a 3a 00 00 call 11a63c <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 116bd2: 8d 43 40 lea 0x40(%ebx),%eax 116bd5: 89 04 24 mov %eax,(%esp) 116bd8: e8 5f 3a 00 00 call 11a63c <_Watchdog_Remove> 116bdd: 83 c4 10 add $0x10,%esp 116be0: e9 bd fe ff ff jmp 116aa2 <_Timer_server_Body+0x3e> =============================================================================== 00116be5 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 116be5: 55 push %ebp 116be6: 89 e5 mov %esp,%ebp 116be8: 57 push %edi 116be9: 56 push %esi 116bea: 53 push %ebx 116beb: 83 ec 2c sub $0x2c,%esp 116bee: 8b 5d 08 mov 0x8(%ebp),%ebx 116bf1: 8b 75 0c mov 0xc(%ebp),%esi if ( ts->insert_chain == NULL ) { 116bf4: 8b 43 78 mov 0x78(%ebx),%eax 116bf7: 85 c0 test %eax,%eax 116bf9: 0f 85 de 00 00 00 jne 116cdd <_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(); 116bff: e8 c4 fd ff ff call 1169c8 <_Thread_Disable_dispatch> if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116c04: 8b 46 38 mov 0x38(%esi),%eax 116c07: 83 f8 01 cmp $0x1,%eax 116c0a: 75 5a jne 116c66 <_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 ); 116c0c: 9c pushf 116c0d: fa cli 116c0e: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116c11: 8b 15 e8 f1 13 00 mov 0x13f1e8,%edx last_snapshot = ts->Interval_watchdogs.last_snapshot; 116c17: 8b 4b 3c mov 0x3c(%ebx),%ecx initialized = false; } #endif return status; } 116c1a: 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 ); 116c1d: 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 ) ) { 116c20: 39 f8 cmp %edi,%eax 116c22: 74 19 je 116c3d <_Timer_server_Schedule_operation_method+0x58> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116c24: 89 d7 mov %edx,%edi 116c26: 29 cf sub %ecx,%edi 116c28: 89 7d e4 mov %edi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 116c2b: 8b 78 10 mov 0x10(%eax),%edi if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116c2e: 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) { 116c30: 3b 7d e4 cmp -0x1c(%ebp),%edi 116c33: 76 05 jbe 116c3a <_Timer_server_Schedule_operation_method+0x55> delta_interval -= delta; 116c35: 89 f9 mov %edi,%ecx 116c37: 2b 4d e4 sub -0x1c(%ebp),%ecx } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 116c3a: 89 48 10 mov %ecx,0x10(%eax) } ts->Interval_watchdogs.last_snapshot = snapshot; 116c3d: 89 53 3c mov %edx,0x3c(%ebx) _ISR_Enable( level ); 116c40: ff 75 e0 pushl -0x20(%ebp) 116c43: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116c44: 50 push %eax 116c45: 50 push %eax 116c46: 83 c6 10 add $0x10,%esi 116c49: 56 push %esi 116c4a: 8d 43 30 lea 0x30(%ebx),%eax 116c4d: 50 push %eax 116c4e: e8 c9 38 00 00 call 11a51c <_Watchdog_Insert> if ( !ts->active ) { 116c53: 8a 43 7c mov 0x7c(%ebx),%al 116c56: 83 c4 10 add $0x10,%esp 116c59: 84 c0 test %al,%al 116c5b: 75 74 jne 116cd1 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_interval_system_watchdog( ts ); 116c5d: 89 d8 mov %ebx,%eax 116c5f: e8 74 fd ff ff call 1169d8 <_Timer_server_Reset_interval_system_watchdog> 116c64: eb 6b jmp 116cd1 <_Timer_server_Schedule_operation_method+0xec> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116c66: 83 f8 03 cmp $0x3,%eax 116c69: 75 66 jne 116cd1 <_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 ); 116c6b: 9c pushf 116c6c: fa cli 116c6d: 8f 45 e0 popl -0x20(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 116c70: 8b 15 60 f1 13 00 mov 0x13f160,%edx last_snapshot = ts->TOD_watchdogs.last_snapshot; 116c76: 8b 43 74 mov 0x74(%ebx),%eax initialized = false; } #endif return status; } 116c79: 8b 4b 68 mov 0x68(%ebx),%ecx 116c7c: 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 ) ) { 116c7f: 39 f9 cmp %edi,%ecx 116c81: 74 27 je 116caa <_Timer_server_Schedule_operation_method+0xc5> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 116c83: 8b 79 10 mov 0x10(%ecx),%edi 116c86: 89 7d d4 mov %edi,-0x2c(%ebp) if ( snapshot > last_snapshot ) { 116c89: 39 c2 cmp %eax,%edx 116c8b: 76 15 jbe 116ca2 <_Timer_server_Schedule_operation_method+0xbd> /* * We advanced in time. */ delta = snapshot - last_snapshot; 116c8d: 89 d7 mov %edx,%edi 116c8f: 29 c7 sub %eax,%edi 116c91: 89 7d e4 mov %edi,-0x1c(%ebp) if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116c94: 31 c0 xor %eax,%eax if ( snapshot > last_snapshot ) { /* * We advanced in time. */ delta = snapshot - last_snapshot; if (delta_interval > delta) { 116c96: 39 7d d4 cmp %edi,-0x2c(%ebp) 116c99: 76 0c jbe 116ca7 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN delta_interval -= delta; 116c9b: 8b 45 d4 mov -0x2c(%ebp),%eax 116c9e: 29 f8 sub %edi,%eax 116ca0: eb 05 jmp 116ca7 <_Timer_server_Schedule_operation_method+0xc2> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 116ca2: 03 45 d4 add -0x2c(%ebp),%eax delta_interval += delta; 116ca5: 29 d0 sub %edx,%eax } first_watchdog->delta_interval = delta_interval; 116ca7: 89 41 10 mov %eax,0x10(%ecx) } ts->TOD_watchdogs.last_snapshot = snapshot; 116caa: 89 53 74 mov %edx,0x74(%ebx) _ISR_Enable( level ); 116cad: ff 75 e0 pushl -0x20(%ebp) 116cb0: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116cb1: 57 push %edi 116cb2: 57 push %edi 116cb3: 83 c6 10 add $0x10,%esi 116cb6: 56 push %esi 116cb7: 8d 43 68 lea 0x68(%ebx),%eax 116cba: 50 push %eax 116cbb: e8 5c 38 00 00 call 11a51c <_Watchdog_Insert> if ( !ts->active ) { 116cc0: 8a 43 7c mov 0x7c(%ebx),%al 116cc3: 83 c4 10 add $0x10,%esp 116cc6: 84 c0 test %al,%al 116cc8: 75 07 jne 116cd1 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_tod_system_watchdog( ts ); 116cca: 89 d8 mov %ebx,%eax 116ccc: e8 4d fd ff ff call 116a1e <_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 ); } } 116cd1: 8d 65 f4 lea -0xc(%ebp),%esp 116cd4: 5b pop %ebx 116cd5: 5e pop %esi 116cd6: 5f pop %edi 116cd7: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 116cd8: e9 c1 29 00 00 jmp 11969e <_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 ); 116cdd: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 116ce0: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 116ce3: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } 116ce6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116ce9: 5b pop %ebx <== NOT EXECUTED 116cea: 5e pop %esi <== NOT EXECUTED 116ceb: 5f pop %edi <== NOT EXECUTED 116cec: 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 ); 116ced: e9 d6 06 00 00 jmp 1173c8 <_Chain_Append> <== NOT EXECUTED =============================================================================== 0010ccef <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10ccef: 55 push %ebp 10ccf0: 89 e5 mov %esp,%ebp 10ccf2: 57 push %edi 10ccf3: 56 push %esi 10ccf4: 53 push %ebx 10ccf5: 83 ec 0c sub $0xc,%esp 10ccf8: 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 ); } } 10ccfb: 8b 1d 14 55 12 00 mov 0x125514,%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 ); 10cd01: 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 ); 10cd05: eb 15 jmp 10cd1c <_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 ) 10cd07: 8b 43 30 mov 0x30(%ebx),%eax 10cd0a: 85 c0 test %eax,%eax 10cd0c: 74 0b je 10cd19 <_User_extensions_Fatal+0x2a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10cd0e: 52 push %edx 10cd0f: 57 push %edi 10cd10: 56 push %esi 10cd11: ff 75 08 pushl 0x8(%ebp) 10cd14: ff d0 call *%eax 10cd16: 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 ) { 10cd19: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10cd1c: 81 fb 0c 55 12 00 cmp $0x12550c,%ebx 10cd22: 75 e3 jne 10cd07 <_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 ); } } 10cd24: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cd27: 5b pop %ebx <== NOT EXECUTED 10cd28: 5e pop %esi <== NOT EXECUTED 10cd29: 5f pop %edi <== NOT EXECUTED 10cd2a: c9 leave <== NOT EXECUTED 10cd2b: c3 ret <== NOT EXECUTED =============================================================================== 0010cbd8 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10cbd8: 55 push %ebp 10cbd9: 89 e5 mov %esp,%ebp 10cbdb: 57 push %edi 10cbdc: 56 push %esi 10cbdd: 53 push %ebx 10cbde: 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; 10cbe1: a1 60 12 12 00 mov 0x121260,%eax 10cbe6: 89 45 e4 mov %eax,-0x1c(%ebp) initial_extensions = Configuration.User_extension_table; 10cbe9: 8b 35 64 12 12 00 mov 0x121264,%esi ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10cbef: c7 05 0c 55 12 00 10 movl $0x125510,0x12550c 10cbf6: 55 12 00 head->previous = NULL; 10cbf9: c7 05 10 55 12 00 00 movl $0x0,0x125510 10cc00: 00 00 00 tail->previous = head; 10cc03: c7 05 14 55 12 00 0c movl $0x12550c,0x125514 10cc0a: 55 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10cc0d: c7 05 44 53 12 00 48 movl $0x125348,0x125344 10cc14: 53 12 00 head->previous = NULL; 10cc17: c7 05 48 53 12 00 00 movl $0x0,0x125348 10cc1e: 00 00 00 tail->previous = head; 10cc21: c7 05 4c 53 12 00 44 movl $0x125344,0x12534c 10cc28: 53 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10cc2b: 85 f6 test %esi,%esi 10cc2d: 74 53 je 10cc82 <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10cc2f: 6b c8 34 imul $0x34,%eax,%ecx 10cc32: 83 ec 0c sub $0xc,%esp 10cc35: 51 push %ecx 10cc36: 89 4d e0 mov %ecx,-0x20(%ebp) 10cc39: e8 3d 04 00 00 call 10d07b <_Workspace_Allocate_or_fatal_error> 10cc3e: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10cc40: 31 c0 xor %eax,%eax 10cc42: 8b 4d e0 mov -0x20(%ebp),%ecx 10cc45: 89 df mov %ebx,%edi 10cc47: f3 aa rep stos %al,%es:(%edi) 10cc49: 89 f0 mov %esi,%eax extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cc4b: 83 c4 10 add $0x10,%esp 10cc4e: 31 d2 xor %edx,%edx 10cc50: eb 2b jmp 10cc7d <_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; 10cc52: 8d 7b 14 lea 0x14(%ebx),%edi 10cc55: 89 c6 mov %eax,%esi 10cc57: b9 08 00 00 00 mov $0x8,%ecx 10cc5c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10cc5e: 83 ec 0c sub $0xc,%esp 10cc61: 53 push %ebx 10cc62: 89 45 dc mov %eax,-0x24(%ebp) 10cc65: 89 55 e0 mov %edx,-0x20(%ebp) 10cc68: e8 47 2f 00 00 call 10fbb4 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10cc6d: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cc70: 8b 55 e0 mov -0x20(%ebp),%edx 10cc73: 42 inc %edx 10cc74: 8b 45 dc mov -0x24(%ebp),%eax 10cc77: 83 c0 20 add $0x20,%eax 10cc7a: 83 c4 10 add $0x10,%esp 10cc7d: 3b 55 e4 cmp -0x1c(%ebp),%edx 10cc80: 72 d0 jb 10cc52 <_User_extensions_Handler_initialization+0x7a> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10cc82: 8d 65 f4 lea -0xc(%ebp),%esp 10cc85: 5b pop %ebx 10cc86: 5e pop %esi 10cc87: 5f pop %edi 10cc88: c9 leave 10cc89: c3 ret =============================================================================== 0010e54c <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10e54c: 55 push %ebp 10e54d: 89 e5 mov %esp,%ebp 10e54f: 57 push %edi 10e550: 56 push %esi 10e551: 53 push %ebx 10e552: 83 ec 1c sub $0x1c,%esp 10e555: 8b 75 08 mov 0x8(%ebp),%esi 10e558: 8b 7d 0c mov 0xc(%ebp),%edi 10e55b: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10e55e: 9c pushf 10e55f: fa cli 10e560: 58 pop %eax } } _ISR_Enable( level ); } 10e561: 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 ); 10e563: 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 ) ) { 10e566: 39 ca cmp %ecx,%edx 10e568: 74 44 je 10e5ae <_Watchdog_Adjust+0x62> switch ( direction ) { 10e56a: 85 ff test %edi,%edi 10e56c: 74 3c je 10e5aa <_Watchdog_Adjust+0x5e> 10e56e: 4f dec %edi 10e56f: 75 3d jne 10e5ae <_Watchdog_Adjust+0x62> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10e571: 01 5a 10 add %ebx,0x10(%edx) break; 10e574: eb 38 jmp 10e5ae <_Watchdog_Adjust+0x62> RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 10e576: 8b 16 mov (%esi),%edx case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10e578: 8b 7a 10 mov 0x10(%edx),%edi 10e57b: 39 fb cmp %edi,%ebx 10e57d: 73 07 jae 10e586 <_Watchdog_Adjust+0x3a> _Watchdog_First( header )->delta_interval -= units; 10e57f: 29 df sub %ebx,%edi 10e581: 89 7a 10 mov %edi,0x10(%edx) break; 10e584: eb 28 jmp 10e5ae <_Watchdog_Adjust+0x62> } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10e586: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 10e58d: 50 push %eax 10e58e: 9d popf _Watchdog_Tickle( header ); 10e58f: 83 ec 0c sub $0xc,%esp 10e592: 56 push %esi 10e593: 89 4d e4 mov %ecx,-0x1c(%ebp) 10e596: e8 a5 01 00 00 call 10e740 <_Watchdog_Tickle> _ISR_Disable( level ); 10e59b: 9c pushf 10e59c: fa cli 10e59d: 58 pop %eax if ( _Chain_Is_empty( header ) ) 10e59e: 83 c4 10 add $0x10,%esp 10e5a1: 8b 4d e4 mov -0x1c(%ebp),%ecx 10e5a4: 39 0e cmp %ecx,(%esi) 10e5a6: 74 06 je 10e5ae <_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; 10e5a8: 29 fb sub %edi,%ebx switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e5aa: 85 db test %ebx,%ebx 10e5ac: 75 c8 jne 10e576 <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN } break; } } _ISR_Enable( level ); 10e5ae: 50 push %eax 10e5af: 9d popf } 10e5b0: 8d 65 f4 lea -0xc(%ebp),%esp 10e5b3: 5b pop %ebx 10e5b4: 5e pop %esi 10e5b5: 5f pop %edi 10e5b6: c9 leave 10e5b7: c3 ret =============================================================================== 0010cf30 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10cf30: 55 push %ebp 10cf31: 89 e5 mov %esp,%ebp 10cf33: 56 push %esi 10cf34: 53 push %ebx 10cf35: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10cf38: 9c pushf 10cf39: fa cli 10cf3a: 5e pop %esi previous_state = the_watchdog->state; 10cf3b: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10cf3e: 83 f8 01 cmp $0x1,%eax 10cf41: 74 09 je 10cf4c <_Watchdog_Remove+0x1c> 10cf43: 72 42 jb 10cf87 <_Watchdog_Remove+0x57> 10cf45: 83 f8 03 cmp $0x3,%eax 10cf48: 77 3d ja 10cf87 <_Watchdog_Remove+0x57> <== NEVER TAKEN 10cf4a: eb 09 jmp 10cf55 <_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; 10cf4c: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10cf53: eb 32 jmp 10cf87 <_Watchdog_Remove+0x57> case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10cf55: 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 ); } 10cf5c: 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) ) 10cf5e: 83 39 00 cmpl $0x0,(%ecx) 10cf61: 74 06 je 10cf69 <_Watchdog_Remove+0x39> next_watchdog->delta_interval += the_watchdog->delta_interval; 10cf63: 8b 5a 10 mov 0x10(%edx),%ebx 10cf66: 01 59 10 add %ebx,0x10(%ecx) if ( _Watchdog_Sync_count ) 10cf69: 8b 1d 50 54 12 00 mov 0x125450,%ebx 10cf6f: 85 db test %ebx,%ebx 10cf71: 74 0c je 10cf7f <_Watchdog_Remove+0x4f> _Watchdog_Sync_level = _ISR_Nest_level; 10cf73: 8b 1d 64 58 12 00 mov 0x125864,%ebx 10cf79: 89 1d e8 53 12 00 mov %ebx,0x1253e8 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10cf7f: 8b 5a 04 mov 0x4(%edx),%ebx next->previous = previous; 10cf82: 89 59 04 mov %ebx,0x4(%ecx) previous->next = next; 10cf85: 89 0b mov %ecx,(%ebx) _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10cf87: 8b 0d 54 54 12 00 mov 0x125454,%ecx 10cf8d: 89 4a 18 mov %ecx,0x18(%edx) _ISR_Enable( level ); 10cf90: 56 push %esi 10cf91: 9d popf return( previous_state ); } 10cf92: 5b pop %ebx 10cf93: 5e pop %esi 10cf94: c9 leave 10cf95: c3 ret =============================================================================== 0010e0bc <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10e0bc: 55 push %ebp 10e0bd: 89 e5 mov %esp,%ebp 10e0bf: 57 push %edi 10e0c0: 56 push %esi 10e0c1: 53 push %ebx 10e0c2: 83 ec 20 sub $0x20,%esp 10e0c5: 8b 7d 08 mov 0x8(%ebp),%edi 10e0c8: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10e0cb: 9c pushf 10e0cc: fa cli 10e0cd: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10e0d0: 56 push %esi 10e0d1: 57 push %edi 10e0d2: 68 9c 18 12 00 push $0x12189c 10e0d7: e8 50 aa ff ff call 108b2c printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); } 10e0dc: 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 ); 10e0de: 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 ) ) { 10e0e1: 83 c4 10 add $0x10,%esp 10e0e4: 39 f3 cmp %esi,%ebx 10e0e6: 74 1d je 10e105 <_Watchdog_Report_chain+0x49> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10e0e8: 52 push %edx 10e0e9: 52 push %edx 10e0ea: 53 push %ebx 10e0eb: 6a 00 push $0x0 10e0ed: e8 32 00 00 00 call 10e124 <_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 ) 10e0f2: 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 ) ; 10e0f4: 83 c4 10 add $0x10,%esp 10e0f7: 39 f3 cmp %esi,%ebx 10e0f9: 75 ed jne 10e0e8 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10e0fb: 50 push %eax 10e0fc: 50 push %eax 10e0fd: 57 push %edi 10e0fe: 68 b3 18 12 00 push $0x1218b3 10e103: eb 08 jmp 10e10d <_Watchdog_Report_chain+0x51> } else { printk( "Chain is empty\n" ); 10e105: 83 ec 0c sub $0xc,%esp 10e108: 68 c2 18 12 00 push $0x1218c2 10e10d: e8 1a aa ff ff call 108b2c 10e112: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10e115: ff 75 e4 pushl -0x1c(%ebp) 10e118: 9d popf } 10e119: 8d 65 f4 lea -0xc(%ebp),%esp 10e11c: 5b pop %ebx 10e11d: 5e pop %esi 10e11e: 5f pop %edi 10e11f: c9 leave 10e120: c3 ret =============================================================================== 0010a818 : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 10a818: 55 push %ebp 10a819: 89 e5 mov %esp,%ebp 10a81b: 57 push %edi 10a81c: 56 push %esi 10a81d: 53 push %ebx 10a81e: 83 ec 18 sub $0x18,%esp 10a821: 8b 75 08 mov 0x8(%ebp),%esi 10a824: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 10a827: 68 d8 72 12 00 push $0x1272d8 10a82c: e8 2f 10 00 00 call 10b860 if (fcntl (fildes, F_GETFD) < 0) { 10a831: 5f pop %edi 10a832: 58 pop %eax 10a833: 6a 01 push $0x1 10a835: 56 push %esi 10a836: e8 f1 60 00 00 call 11092c 10a83b: 83 c4 10 add $0x10,%esp 10a83e: 85 c0 test %eax,%eax 10a840: 79 1d jns 10a85f pthread_mutex_unlock(&aio_request_queue.mutex); 10a842: 83 ec 0c sub $0xc,%esp 10a845: 68 d8 72 12 00 push $0x1272d8 10a84a: e8 91 10 00 00 call 10b8e0 rtems_set_errno_and_return_minus_one (EBADF); 10a84f: e8 94 8e 00 00 call 1136e8 <__errno> 10a854: c7 00 09 00 00 00 movl $0x9,(%eax) 10a85a: e9 e3 00 00 00 jmp 10a942 } /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { 10a85f: 85 db test %ebx,%ebx 10a861: 0f 85 bd 00 00 00 jne 10a924 AIO_printf ("Cancel all requests\n"); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10a867: 51 push %ecx 10a868: 6a 00 push $0x0 10a86a: 56 push %esi 10a86b: 68 20 73 12 00 push $0x127320 10a870: e8 27 03 00 00 call 10ab9c 10a875: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10a877: 83 c4 10 add $0x10,%esp 10a87a: 85 c0 test %eax,%eax 10a87c: 75 6c jne 10a8ea AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10a87e: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c 10a885: 73 12 00 10a888: 0f 84 07 01 00 00 je 10a995 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10a88e: 52 push %edx 10a88f: 6a 00 push $0x0 10a891: 56 push %esi 10a892: 68 2c 73 12 00 push $0x12732c 10a897: e8 00 03 00 00 call 10ab9c 10a89c: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10a89e: 83 c4 10 add $0x10,%esp 10a8a1: 85 c0 test %eax,%eax 10a8a3: 75 17 jne 10a8bc pthread_mutex_unlock(&aio_request_queue.mutex); 10a8a5: 83 ec 0c sub $0xc,%esp 10a8a8: 68 d8 72 12 00 push $0x1272d8 10a8ad: e8 2e 10 00 00 call 10b8e0 return AIO_ALLDONE; 10a8b2: 83 c4 10 add $0x10,%esp 10a8b5: b3 02 mov $0x2,%bl 10a8b7: e9 21 01 00 00 jmp 10a9dd */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10a8bc: 83 ec 0c sub $0xc,%esp 10a8bf: 50 push %eax 10a8c0: e8 fb 26 00 00 call 10cfc0 <_Chain_Extract> } AIO_printf ("Request chain on [IQ]\n"); rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a8c5: 89 1c 24 mov %ebx,(%esp) 10a8c8: e8 12 06 00 00 call 10aedf pthread_mutex_destroy (&r_chain->mutex); 10a8cd: 8d 73 1c lea 0x1c(%ebx),%esi 10a8d0: 89 34 24 mov %esi,(%esp) 10a8d3: e8 68 0d 00 00 call 10b640 pthread_cond_destroy (&r_chain->mutex); 10a8d8: 89 34 24 mov %esi,(%esp) 10a8db: e8 6c 0a 00 00 call 10b34c free (r_chain); 10a8e0: 89 1c 24 mov %ebx,(%esp) 10a8e3: e8 88 d4 ff ff call 107d70 10a8e8: eb 24 jmp 10a90e return AIO_ALLDONE; } AIO_printf ("Request chain on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10a8ea: 8d 70 1c lea 0x1c(%eax),%esi 10a8ed: 83 ec 0c sub $0xc,%esp 10a8f0: 56 push %esi 10a8f1: e8 6a 0f 00 00 call 10b860 10a8f6: 89 1c 24 mov %ebx,(%esp) 10a8f9: e8 c2 26 00 00 call 10cfc0 <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a8fe: 89 1c 24 mov %ebx,(%esp) 10a901: e8 d9 05 00 00 call 10aedf pthread_mutex_unlock (&r_chain->mutex); 10a906: 89 34 24 mov %esi,(%esp) 10a909: e8 d2 0f 00 00 call 10b8e0 pthread_mutex_unlock (&aio_request_queue.mutex); 10a90e: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp) 10a915: e8 c6 0f 00 00 call 10b8e0 return AIO_CANCELED; 10a91a: 83 c4 10 add $0x10,%esp 10a91d: 31 db xor %ebx,%ebx 10a91f: e9 b9 00 00 00 jmp 10a9dd } else { AIO_printf ("Cancel request\n"); if (aiocbp->aio_fildes != fildes) { 10a924: 8b 3b mov (%ebx),%edi 10a926: 39 f7 cmp %esi,%edi 10a928: 74 23 je 10a94d pthread_mutex_unlock (&aio_request_queue.mutex); 10a92a: 83 ec 0c sub $0xc,%esp 10a92d: 68 d8 72 12 00 push $0x1272d8 10a932: e8 a9 0f 00 00 call 10b8e0 rtems_set_errno_and_return_minus_one (EINVAL); 10a937: e8 ac 8d 00 00 call 1136e8 <__errno> 10a93c: c7 00 16 00 00 00 movl $0x16,(%eax) 10a942: 83 c4 10 add $0x10,%esp 10a945: 83 cb ff or $0xffffffff,%ebx 10a948: e9 90 00 00 00 jmp 10a9dd } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10a94d: 50 push %eax 10a94e: 6a 00 push $0x0 10a950: 57 push %edi 10a951: 68 20 73 12 00 push $0x127320 10a956: e8 41 02 00 00 call 10ab9c 10a95b: 89 c6 mov %eax,%esi if (r_chain == NULL) { 10a95d: 83 c4 10 add $0x10,%esp 10a960: 85 c0 test %eax,%eax 10a962: 75 48 jne 10a9ac if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10a964: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c 10a96b: 73 12 00 10a96e: 74 25 je 10a995 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10a970: 56 push %esi 10a971: 6a 00 push $0x0 10a973: 57 push %edi 10a974: 68 2c 73 12 00 push $0x12732c 10a979: e8 1e 02 00 00 call 10ab9c if (r_chain == NULL) { 10a97e: 83 c4 10 add $0x10,%esp 10a981: 85 c0 test %eax,%eax 10a983: 74 a5 je 10a92a rtems_set_errno_and_return_minus_one (EINVAL); } AIO_printf ("Request on [IQ]\n"); result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10a985: 51 push %ecx 10a986: 51 push %ecx 10a987: 53 push %ebx 10a988: 83 c0 08 add $0x8,%eax 10a98b: 50 push %eax 10a98c: e8 97 05 00 00 call 10af28 10a991: 89 c3 mov %eax,%ebx 10a993: eb 39 jmp 10a9ce pthread_mutex_unlock (&aio_request_queue.mutex); return result; } else { pthread_mutex_unlock (&aio_request_queue.mutex); 10a995: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a998: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED 10a99d: e8 3e 0f 00 00 call 10b8e0 <== NOT EXECUTED return AIO_ALLDONE; 10a9a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a9a5: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10a9aa: eb 31 jmp 10a9dd <== NOT EXECUTED } } AIO_printf ("Request on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10a9ac: 8d 78 1c lea 0x1c(%eax),%edi 10a9af: 83 ec 0c sub $0xc,%esp 10a9b2: 57 push %edi 10a9b3: e8 a8 0e 00 00 call 10b860 result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10a9b8: 58 pop %eax 10a9b9: 5a pop %edx 10a9ba: 53 push %ebx 10a9bb: 83 c6 08 add $0x8,%esi 10a9be: 56 push %esi 10a9bf: e8 64 05 00 00 call 10af28 10a9c4: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&r_chain->mutex); 10a9c6: 89 3c 24 mov %edi,(%esp) 10a9c9: e8 12 0f 00 00 call 10b8e0 pthread_mutex_unlock (&aio_request_queue.mutex); 10a9ce: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp) 10a9d5: e8 06 0f 00 00 call 10b8e0 return result; 10a9da: 83 c4 10 add $0x10,%esp } return AIO_ALLDONE; } 10a9dd: 89 d8 mov %ebx,%eax 10a9df: 8d 65 f4 lea -0xc(%ebp),%esp 10a9e2: 5b pop %ebx 10a9e3: 5e pop %esi 10a9e4: 5f pop %edi 10a9e5: c9 leave 10a9e6: c3 ret =============================================================================== 0010a9f4 : int aio_fsync( int op, struct aiocb *aiocbp ) { 10a9f4: 55 push %ebp 10a9f5: 89 e5 mov %esp,%ebp 10a9f7: 53 push %ebx 10a9f8: 83 ec 04 sub $0x4,%esp 10a9fb: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 10a9fe: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 10aa05: 74 1b je 10aa22 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10aa07: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10aa0e: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10aa15: e8 ce 8c 00 00 call 1136e8 <__errno> 10aa1a: c7 00 16 00 00 00 movl $0x16,(%eax) 10aa20: eb 74 jmp 10aa96 mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10aa22: 50 push %eax 10aa23: 50 push %eax 10aa24: 6a 03 push $0x3 10aa26: ff 33 pushl (%ebx) 10aa28: e8 ff 5e 00 00 call 11092c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10aa2d: 83 e0 03 and $0x3,%eax 10aa30: 48 dec %eax 10aa31: 83 c4 10 add $0x10,%esp 10aa34: 83 f8 01 cmp $0x1,%eax 10aa37: 76 1b jbe 10aa54 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10aa39: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10aa40: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10aa47: e8 9c 8c 00 00 call 1136e8 <__errno> 10aa4c: c7 00 09 00 00 00 movl $0x9,(%eax) 10aa52: eb 42 jmp 10aa96 req = malloc (sizeof (rtems_aio_request)); 10aa54: 83 ec 0c sub $0xc,%esp 10aa57: 6a 18 push $0x18 10aa59: e8 96 d7 ff ff call 1081f4 if (req == NULL) 10aa5e: 83 c4 10 add $0x10,%esp 10aa61: 85 c0 test %eax,%eax 10aa63: 75 1b jne 10aa80 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10aa65: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10aa6c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10aa73: e8 70 8c 00 00 call 1136e8 <__errno> <== NOT EXECUTED 10aa78: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10aa7e: eb 16 jmp 10aa96 <== NOT EXECUTED req->aiocbp = aiocbp; 10aa80: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_SYNC; 10aa83: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) return rtems_aio_enqueue (req); 10aa8a: 89 45 08 mov %eax,0x8(%ebp) } 10aa8d: 8b 5d fc mov -0x4(%ebp),%ebx 10aa90: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); 10aa91: e9 ef 04 00 00 jmp 10af85 } 10aa96: 83 c8 ff or $0xffffffff,%eax 10aa99: 8b 5d fc mov -0x4(%ebp),%ebx 10aa9c: c9 leave 10aa9d: c3 ret =============================================================================== 0010b188 : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10b188: 55 push %ebp 10b189: 89 e5 mov %esp,%ebp 10b18b: 53 push %ebx 10b18c: 83 ec 0c sub $0xc,%esp 10b18f: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b192: 6a 03 push $0x3 10b194: ff 33 pushl (%ebx) 10b196: e8 91 57 00 00 call 11092c if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b19b: 83 e0 03 and $0x3,%eax 10b19e: 83 c4 10 add $0x10,%esp 10b1a1: 83 f8 02 cmp $0x2,%eax 10b1a4: 74 1f je 10b1c5 10b1a6: 85 c0 test %eax,%eax 10b1a8: 74 1b je 10b1c5 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b1aa: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b1b1: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b1b8: e8 2b 85 00 00 call 1136e8 <__errno> 10b1bd: c7 00 09 00 00 00 movl $0x9,(%eax) 10b1c3: eb 69 jmp 10b22e if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b1c5: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b1c9: 75 06 jne 10b1d1 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b1cb: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b1cf: 79 1b jns 10b1ec rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b1d1: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b1d8: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b1df: e8 04 85 00 00 call 1136e8 <__errno> 10b1e4: c7 00 16 00 00 00 movl $0x16,(%eax) 10b1ea: eb 42 jmp 10b22e req = malloc (sizeof (rtems_aio_request)); 10b1ec: 83 ec 0c sub $0xc,%esp 10b1ef: 6a 18 push $0x18 10b1f1: e8 fe cf ff ff call 1081f4 if (req == NULL) 10b1f6: 83 c4 10 add $0x10,%esp 10b1f9: 85 c0 test %eax,%eax 10b1fb: 75 1b jne 10b218 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b1fd: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b204: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b20b: e8 d8 84 00 00 call 1136e8 <__errno> <== NOT EXECUTED 10b210: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b216: eb 16 jmp 10b22e <== NOT EXECUTED req->aiocbp = aiocbp; 10b218: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10b21b: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10b222: 89 45 08 mov %eax,0x8(%ebp) } 10b225: 8b 5d fc mov -0x4(%ebp),%ebx 10b228: 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); 10b229: e9 57 fd ff ff jmp 10af85 } 10b22e: 83 c8 ff or $0xffffffff,%eax 10b231: 8b 5d fc mov -0x4(%ebp),%ebx 10b234: c9 leave 10b235: c3 ret =============================================================================== 0010b244 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10b244: 55 push %ebp 10b245: 89 e5 mov %esp,%ebp 10b247: 53 push %ebx 10b248: 83 ec 0c sub $0xc,%esp 10b24b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b24e: 6a 03 push $0x3 10b250: ff 33 pushl (%ebx) 10b252: e8 d5 56 00 00 call 11092c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b257: 83 e0 03 and $0x3,%eax 10b25a: 48 dec %eax 10b25b: 83 c4 10 add $0x10,%esp 10b25e: 83 f8 01 cmp $0x1,%eax 10b261: 76 1b jbe 10b27e rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b263: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b26a: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b271: e8 72 84 00 00 call 1136e8 <__errno> 10b276: c7 00 09 00 00 00 movl $0x9,(%eax) 10b27c: eb 69 jmp 10b2e7 if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b27e: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b282: 75 06 jne 10b28a rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b284: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b288: 79 1b jns 10b2a5 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b28a: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b291: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b298: e8 4b 84 00 00 call 1136e8 <__errno> 10b29d: c7 00 16 00 00 00 movl $0x16,(%eax) 10b2a3: eb 42 jmp 10b2e7 req = malloc (sizeof (rtems_aio_request)); 10b2a5: 83 ec 0c sub $0xc,%esp 10b2a8: 6a 18 push $0x18 10b2aa: e8 45 cf ff ff call 1081f4 if (req == NULL) 10b2af: 83 c4 10 add $0x10,%esp 10b2b2: 85 c0 test %eax,%eax 10b2b4: 75 1b jne 10b2d1 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b2b6: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b2bd: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b2c4: e8 1f 84 00 00 call 1136e8 <__errno> <== NOT EXECUTED 10b2c9: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b2cf: eb 16 jmp 10b2e7 <== NOT EXECUTED req->aiocbp = aiocbp; 10b2d1: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10b2d4: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10b2db: 89 45 08 mov %eax,0x8(%ebp) } 10b2de: 8b 5d fc mov -0x4(%ebp),%ebx 10b2e1: 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); 10b2e2: e9 9e fc ff ff jmp 10af85 } 10b2e7: 83 c8 ff or $0xffffffff,%eax 10b2ea: 8b 5d fc mov -0x4(%ebp),%ebx 10b2ed: c9 leave 10b2ee: c3 ret =============================================================================== 00109fec : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 109fec: 55 push %ebp 109fed: 89 e5 mov %esp,%ebp 109fef: 83 ec 08 sub $0x8,%esp 109ff2: 8b 45 08 mov 0x8(%ebp),%eax 109ff5: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109ff8: 85 d2 test %edx,%edx 109ffa: 74 3c je 10a038 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 109ffc: 83 f8 01 cmp $0x1,%eax 109fff: 75 0b jne 10a00c _TOD_Get(tp); 10a001: 83 ec 0c sub $0xc,%esp 10a004: 52 push %edx 10a005: e8 a6 1b 00 00 call 10bbb0 <_TOD_Get> 10a00a: eb 13 jmp 10a01f return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 10a00c: 83 f8 04 cmp $0x4,%eax 10a00f: 74 05 je 10a016 <== NEVER TAKEN return 0; } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { 10a011: 83 f8 02 cmp $0x2,%eax 10a014: 75 10 jne 10a026 _TOD_Get_uptime_as_timespec( tp ); 10a016: 83 ec 0c sub $0xc,%esp 10a019: 52 push %edx 10a01a: e8 e5 1b 00 00 call 10bc04 <_TOD_Get_uptime_as_timespec> return 0; 10a01f: 83 c4 10 add $0x10,%esp 10a022: 31 c0 xor %eax,%eax 10a024: eb 20 jmp 10a046 } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) 10a026: 83 f8 03 cmp $0x3,%eax 10a029: 75 0d jne 10a038 rtems_set_errno_and_return_minus_one( ENOSYS ); 10a02b: e8 9c 7f 00 00 call 111fcc <__errno> 10a030: c7 00 58 00 00 00 movl $0x58,(%eax) 10a036: eb 0b jmp 10a043 #endif rtems_set_errno_and_return_minus_one( EINVAL ); 10a038: e8 8f 7f 00 00 call 111fcc <__errno> 10a03d: c7 00 16 00 00 00 movl $0x16,(%eax) 10a043: 83 c8 ff or $0xffffffff,%eax return 0; } 10a046: c9 leave 10a047: c3 ret =============================================================================== 0010a048 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 10a048: 55 push %ebp 10a049: 89 e5 mov %esp,%ebp 10a04b: 83 ec 08 sub $0x8,%esp 10a04e: 8b 45 08 mov 0x8(%ebp),%eax 10a051: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 10a054: 85 d2 test %edx,%edx 10a056: 74 44 je 10a09c <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10a058: 83 f8 01 cmp $0x1,%eax 10a05b: 75 28 jne 10a085 if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 10a05d: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) 10a063: 76 37 jbe 10a09c rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a065: a1 a0 73 12 00 mov 0x1273a0,%eax 10a06a: 40 inc %eax 10a06b: a3 a0 73 12 00 mov %eax,0x1273a0 rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 10a070: 83 ec 0c sub $0xc,%esp 10a073: 52 push %edx 10a074: e8 e3 1b 00 00 call 10bc5c <_TOD_Set> _Thread_Enable_dispatch(); 10a079: e8 38 2f 00 00 call 10cfb6 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 10a07e: 83 c4 10 add $0x10,%esp 10a081: 31 c0 xor %eax,%eax 10a083: eb 25 jmp 10a0aa _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10a085: 83 f8 02 cmp $0x2,%eax 10a088: 74 05 je 10a08f rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10a08a: 83 f8 03 cmp $0x3,%eax 10a08d: 75 0d jne 10a09c rtems_set_errno_and_return_minus_one( ENOSYS ); 10a08f: e8 38 7f 00 00 call 111fcc <__errno> 10a094: c7 00 58 00 00 00 movl $0x58,(%eax) 10a09a: eb 0b jmp 10a0a7 #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10a09c: e8 2b 7f 00 00 call 111fcc <__errno> 10a0a1: c7 00 16 00 00 00 movl $0x16,(%eax) 10a0a7: 83 c8 ff or $0xffffffff,%eax return 0; } 10a0aa: c9 leave 10a0ab: c3 ret =============================================================================== 00121f58 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 121f58: 55 push %ebp 121f59: 89 e5 mov %esp,%ebp 121f5b: 57 push %edi 121f5c: 56 push %esi 121f5d: 53 push %ebx 121f5e: 83 ec 4c sub $0x4c,%esp 121f61: 8b 5d 0c mov 0xc(%ebp),%ebx 121f64: 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() ) 121f67: e8 64 fd ff ff call 121cd0 121f6c: 39 45 08 cmp %eax,0x8(%ebp) 121f6f: 74 0d je 121f7e rtems_set_errno_and_return_minus_one( ESRCH ); 121f71: e8 5a 3a ff ff call 1159d0 <__errno> 121f76: c7 00 03 00 00 00 movl $0x3,(%eax) 121f7c: eb 0f jmp 121f8d /* * Validate the signal passed. */ if ( !sig ) 121f7e: 85 db test %ebx,%ebx 121f80: 75 13 jne 121f95 rtems_set_errno_and_return_minus_one( EINVAL ); 121f82: e8 49 3a ff ff call 1159d0 <__errno> 121f87: c7 00 16 00 00 00 movl $0x16,(%eax) 121f8d: 83 c8 ff or $0xffffffff,%eax 121f90: e9 ef 01 00 00 jmp 122184 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 121f95: 8d 4b ff lea -0x1(%ebx),%ecx if ( !is_valid_signo(sig) ) 121f98: 83 f9 1f cmp $0x1f,%ecx 121f9b: 77 e5 ja 121f82 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 ) 121f9d: 6b d3 0c imul $0xc,%ebx,%edx return 0; 121fa0: 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 ) 121fa2: 83 ba 18 ba 12 00 01 cmpl $0x1,0x12ba18(%edx) 121fa9: 0f 84 d5 01 00 00 je 122184 /* * 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 ) ) 121faf: 83 fb 04 cmp $0x4,%ebx 121fb2: 74 0a je 121fbe 121fb4: 83 fb 08 cmp $0x8,%ebx 121fb7: 74 05 je 121fbe 121fb9: 83 fb 0b cmp $0xb,%ebx 121fbc: 75 16 jne 121fd4 return pthread_kill( pthread_self(), sig ); 121fbe: e8 85 03 00 00 call 122348 121fc3: 56 push %esi 121fc4: 56 push %esi 121fc5: 53 push %ebx 121fc6: 50 push %eax 121fc7: e8 d8 02 00 00 call 1222a4 121fcc: 83 c4 10 add $0x10,%esp 121fcf: e9 b0 01 00 00 jmp 122184 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 121fd4: be 01 00 00 00 mov $0x1,%esi 121fd9: d3 e6 shl %cl,%esi /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 121fdb: 89 5d dc mov %ebx,-0x24(%ebp) siginfo->si_code = SI_USER; 121fde: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 121fe5: 85 ff test %edi,%edi 121fe7: 75 09 jne 121ff2 siginfo->si_value.sival_int = 0; 121fe9: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 121ff0: eb 05 jmp 121ff7 } else { siginfo->si_value = *value; 121ff2: 8b 07 mov (%edi),%eax 121ff4: 89 45 e4 mov %eax,-0x1c(%ebp) 121ff7: a1 b4 b4 12 00 mov 0x12b4b4,%eax 121ffc: 40 inc %eax 121ffd: a3 b4 b4 12 00 mov %eax,0x12b4b4 /* * 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; 122002: a1 dc b9 12 00 mov 0x12b9dc,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 122007: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx 12200d: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 122013: f7 d2 not %edx 122015: 85 d6 test %edx,%esi 122017: 0f 85 ed 00 00 00 jne 12210a } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 12201d: 8b 15 9c bb 12 00 mov 0x12bb9c,%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 ); 122023: eb 23 jmp 122048 !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 122025: 89 d0 mov %edx,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 122027: 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) 12202d: 85 72 30 test %esi,0x30(%edx) 122030: 0f 85 d4 00 00 00 jne 12210a /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 122036: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 12203c: f7 d1 not %ecx 12203e: 85 ce test %ecx,%esi 122040: 0f 85 c4 00 00 00 jne 12210a 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 ) { 122046: 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 ); 122048: 81 fa a0 bb 12 00 cmp $0x12bba0,%edx 12204e: 75 d5 jne 122025 * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 122050: 0f b6 0d 24 72 12 00 movzbl 0x127224,%ecx 122057: 41 inc %ecx * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 122058: 31 c0 xor %eax,%eax interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 12205a: 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 ] ) 122061: 8b 7d cc mov -0x34(%ebp),%edi 122064: 8b 14 bd 8c b4 12 00 mov 0x12b48c(,%edi,4),%edx 12206b: 85 d2 test %edx,%edx 12206d: 0f 84 86 00 00 00 je 1220f9 <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 122073: 8b 52 04 mov 0x4(%edx),%edx */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 122076: 0f b7 7a 10 movzwl 0x10(%edx),%edi 12207a: 89 7d c4 mov %edi,-0x3c(%ebp) object_table = the_info->local_table; 12207d: 8b 52 1c mov 0x1c(%edx),%edx 122080: 89 55 c0 mov %edx,-0x40(%ebp) for ( index = 1 ; index <= maximum ; index++ ) { 122083: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) 12208a: 89 5d b4 mov %ebx,-0x4c(%ebp) 12208d: eb 5f jmp 1220ee the_thread = (Thread_Control *) object_table[ index ]; 12208f: 8b 5d d0 mov -0x30(%ebp),%ebx 122092: 8b 7d c0 mov -0x40(%ebp),%edi 122095: 8b 14 9f mov (%edi,%ebx,4),%edx if ( !the_thread ) 122098: 85 d2 test %edx,%edx 12209a: 74 4f je 1220eb /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 12209c: 8b 5a 14 mov 0x14(%edx),%ebx 12209f: 89 5d d4 mov %ebx,-0x2c(%ebp) 1220a2: 39 cb cmp %ecx,%ebx 1220a4: 77 45 ja 1220eb #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 1220a6: 8b ba ec 00 00 00 mov 0xec(%edx),%edi 1220ac: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi 1220b2: f7 d7 not %edi 1220b4: 85 fe test %edi,%esi 1220b6: 74 33 je 1220eb * * 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 ) { 1220b8: 39 cb cmp %ecx,%ebx 1220ba: 72 2a jb 1220e6 * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 1220bc: 85 c0 test %eax,%eax 1220be: 74 2b je 1220eb <== NEVER TAKEN 1220c0: 8b 78 10 mov 0x10(%eax),%edi 1220c3: 89 7d c8 mov %edi,-0x38(%ebp) 1220c6: 85 ff test %edi,%edi 1220c8: 74 21 je 1220eb <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 1220ca: 8b 7a 10 mov 0x10(%edx),%edi 1220cd: 85 ff test %edi,%edi 1220cf: 74 15 je 1220e6 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 1220d1: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp) 1220d8: 75 11 jne 1220eb DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 1220da: 81 e7 00 00 00 10 and $0x10000000,%edi 1220e0: 74 09 je 1220eb 1220e2: 89 d9 mov %ebx,%ecx 1220e4: eb 03 jmp 1220e9 */ if ( interested && !_States_Is_ready( interested->current_state ) ) { /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 1220e6: 8b 4d d4 mov -0x2c(%ebp),%ecx 1220e9: 89 d0 mov %edx,%eax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 1220eb: ff 45 d0 incl -0x30(%ebp) 1220ee: 8b 55 c4 mov -0x3c(%ebp),%edx 1220f1: 39 55 d0 cmp %edx,-0x30(%ebp) 1220f4: 76 99 jbe 12208f 1220f6: 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++) { 1220f9: ff 45 cc incl -0x34(%ebp) 1220fc: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 122100: 0f 85 5b ff ff ff jne 122061 } } } } if ( interested ) { 122106: 85 c0 test %eax,%eax 122108: 74 13 je 12211d /* * 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 ) ) { 12210a: 51 push %ecx mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 12210b: 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 ) ) { 12210e: 52 push %edx 12210f: 53 push %ebx 122110: 50 push %eax 122111: e8 8a 00 00 00 call 1221a0 <_POSIX_signals_Unblock_thread> 122116: 83 c4 10 add $0x10,%esp 122119: 84 c0 test %al,%al 12211b: 75 60 jne 12217d /* * 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 ); 12211d: 83 ec 0c sub $0xc,%esp 122120: 56 push %esi 122121: e8 66 00 00 00 call 12218c <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 122126: 6b db 0c imul $0xc,%ebx,%ebx 122129: 83 c4 10 add $0x10,%esp 12212c: 83 bb 10 ba 12 00 02 cmpl $0x2,0x12ba10(%ebx) 122133: 75 48 jne 12217d psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); 122135: 83 ec 0c sub $0xc,%esp 122138: 68 90 bb 12 00 push $0x12bb90 12213d: e8 4e d0 fe ff call 10f190 <_Chain_Get> if ( !psiginfo ) { 122142: 83 c4 10 add $0x10,%esp 122145: 85 c0 test %eax,%eax 122147: 75 15 jne 12215e _Thread_Enable_dispatch(); 122149: e8 6c e8 fe ff call 1109ba <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 12214e: e8 7d 38 ff ff call 1159d0 <__errno> 122153: c7 00 0b 00 00 00 movl $0xb,(%eax) 122159: e9 2f fe ff ff jmp 121f8d } psiginfo->Info = *siginfo; 12215e: 8d 78 08 lea 0x8(%eax),%edi 122161: 8d 75 dc lea -0x24(%ebp),%esi 122164: b9 03 00 00 00 mov $0x3,%ecx 122169: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 12216b: 52 push %edx 12216c: 52 push %edx 12216d: 50 push %eax 12216e: 81 c3 08 bc 12 00 add $0x12bc08,%ebx 122174: 53 push %ebx 122175: e8 da cf fe ff call 10f154 <_Chain_Append> 12217a: 83 c4 10 add $0x10,%esp } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 12217d: e8 38 e8 fe ff call 1109ba <_Thread_Enable_dispatch> return 0; 122182: 31 c0 xor %eax,%eax } 122184: 8d 65 f4 lea -0xc(%ebp),%esp 122187: 5b pop %ebx 122188: 5e pop %esi 122189: 5f pop %edi 12218a: c9 leave 12218b: c3 ret =============================================================================== 0010efd8 : int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) { 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 || !detachstate ) return EINVAL; 10efe1: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) { if ( !attr || !attr->is_initialized || !detachstate ) 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; *detachstate = attr->detachstate; 10eff3: 8b 42 3c mov 0x3c(%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 *detachstate ) { if ( !attr || !attr->is_initialized || !detachstate ) return EINVAL; 10effc: b8 16 00 00 00 mov $0x16,%eax *detachstate = attr->detachstate; return 0; } 10f001: c9 leave 10f002: c3 ret =============================================================================== 0010f24c : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10f24c: 55 push %ebp 10f24d: 89 e5 mov %esp,%ebp 10f24f: 8b 55 08 mov 0x8(%ebp),%edx 10f252: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10f255: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { if ( !attr || !attr->is_initialized ) 10f25a: 85 d2 test %edx,%edx 10f25c: 74 1e je 10f27c 10f25e: 83 3a 00 cmpl $0x0,(%edx) 10f261: 74 19 je 10f27c return EINVAL; switch ( policy ) { 10f263: 83 f9 04 cmp $0x4,%ecx 10f266: 77 0f ja 10f277 10f268: b0 01 mov $0x1,%al 10f26a: d3 e0 shl %cl,%eax 10f26c: a8 17 test $0x17,%al 10f26e: 74 07 je 10f277 <== NEVER TAKEN case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10f270: 89 4a 14 mov %ecx,0x14(%edx) return 0; 10f273: 31 c0 xor %eax,%eax 10f275: eb 05 jmp 10f27c default: return ENOTSUP; 10f277: b8 86 00 00 00 mov $0x86,%eax } } 10f27c: c9 leave 10f27d: c3 ret =============================================================================== 0010a56c : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10a56c: 55 push %ebp 10a56d: 89 e5 mov %esp,%ebp 10a56f: 57 push %edi 10a570: 56 push %esi 10a571: 53 push %ebx 10a572: 83 ec 1c sub $0x1c,%esp 10a575: 8b 5d 08 mov 0x8(%ebp),%ebx 10a578: 8b 75 10 mov 0x10(%ebp),%esi /* * Error check parameters */ if ( !barrier ) return EINVAL; 10a57b: b8 16 00 00 00 mov $0x16,%eax const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10a580: 85 db test %ebx,%ebx 10a582: 0f 84 96 00 00 00 je 10a61e return EINVAL; if ( count == 0 ) 10a588: 85 f6 test %esi,%esi 10a58a: 0f 84 8e 00 00 00 je 10a61e return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10a590: 8b 7d 0c mov 0xc(%ebp),%edi 10a593: 85 ff test %edi,%edi 10a595: 75 0f jne 10a5a6 the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10a597: 83 ec 0c sub $0xc,%esp 10a59a: 8d 7d d8 lea -0x28(%ebp),%edi 10a59d: 57 push %edi 10a59e: e8 19 ff ff ff call 10a4bc 10a5a3: 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; 10a5a6: 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 ) 10a5ab: 83 3f 00 cmpl $0x0,(%edi) 10a5ae: 74 6e je 10a61e return EINVAL; switch ( the_attr->process_shared ) { 10a5b0: 83 7f 04 00 cmpl $0x0,0x4(%edi) 10a5b4: 75 68 jne 10a61e <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a5b6: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_attributes.maximum_count = count; 10a5bd: 89 75 e4 mov %esi,-0x1c(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a5c0: a1 50 63 12 00 mov 0x126350,%eax 10a5c5: 40 inc %eax 10a5c6: a3 50 63 12 00 mov %eax,0x126350 * 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 ); 10a5cb: 83 ec 0c sub $0xc,%esp 10a5ce: 68 f4 66 12 00 push $0x1266f4 10a5d3: e8 0c 1e 00 00 call 10c3e4 <_Objects_Allocate> 10a5d8: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10a5da: 83 c4 10 add $0x10,%esp 10a5dd: 85 c0 test %eax,%eax 10a5df: 75 0c jne 10a5ed _Thread_Enable_dispatch(); 10a5e1: e8 dc 2c 00 00 call 10d2c2 <_Thread_Enable_dispatch> return EAGAIN; 10a5e6: b8 0b 00 00 00 mov $0xb,%eax 10a5eb: eb 31 jmp 10a61e } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a5ed: 50 push %eax 10a5ee: 50 push %eax 10a5ef: 8d 45 e0 lea -0x20(%ebp),%eax 10a5f2: 50 push %eax 10a5f3: 8d 46 10 lea 0x10(%esi),%eax 10a5f6: 50 push %eax 10a5f7: e8 a8 14 00 00 call 10baa4 <_CORE_barrier_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a5fc: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a5ff: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a602: 8b 15 10 67 12 00 mov 0x126710,%edx 10a608: 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; 10a60b: 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; 10a612: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10a614: e8 a9 2c 00 00 call 10d2c2 <_Thread_Enable_dispatch> return 0; 10a619: 83 c4 10 add $0x10,%esp 10a61c: 31 c0 xor %eax,%eax } 10a61e: 8d 65 f4 lea -0xc(%ebp),%esp 10a621: 5b pop %ebx 10a622: 5e pop %esi 10a623: 5f pop %edi 10a624: c9 leave 10a625: c3 ret =============================================================================== 00109f20 : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 109f20: 55 push %ebp 109f21: 89 e5 mov %esp,%ebp 109f23: 56 push %esi 109f24: 53 push %ebx 109f25: 8b 5d 08 mov 0x8(%ebp),%ebx 109f28: 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 ) 109f2b: 85 db test %ebx,%ebx 109f2d: 74 4b je 109f7a rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 109f2f: a1 48 63 12 00 mov 0x126348,%eax 109f34: 40 inc %eax 109f35: a3 48 63 12 00 mov %eax,0x126348 return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 109f3a: 83 ec 0c sub $0xc,%esp 109f3d: 6a 10 push $0x10 109f3f: e8 3e 3c 00 00 call 10db82 <_Workspace_Allocate> if ( handler ) { 109f44: 83 c4 10 add $0x10,%esp 109f47: 85 c0 test %eax,%eax 109f49: 74 24 je 109f6f <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109f4b: 8b 15 70 68 12 00 mov 0x126870,%edx handler_stack = &thread_support->Cancellation_Handlers; 109f51: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx 109f57: 81 c2 e4 00 00 00 add $0xe4,%edx handler->routine = routine; 109f5d: 89 58 08 mov %ebx,0x8(%eax) handler->arg = arg; 109f60: 89 70 0c mov %esi,0xc(%eax) _Chain_Append( handler_stack, &handler->Node ); 109f63: 51 push %ecx 109f64: 51 push %ecx 109f65: 50 push %eax 109f66: 52 push %edx 109f67: e8 84 15 00 00 call 10b4f0 <_Chain_Append> 109f6c: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 109f6f: 8d 65 f8 lea -0x8(%ebp),%esp 109f72: 5b pop %ebx 109f73: 5e pop %esi 109f74: c9 leave handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 109f75: e9 3c 2d 00 00 jmp 10ccb6 <_Thread_Enable_dispatch> } 109f7a: 8d 65 f8 lea -0x8(%ebp),%esp 109f7d: 5b pop %ebx 109f7e: 5e pop %esi 109f7f: c9 leave 109f80: c3 ret =============================================================================== 0010ac94 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10ac94: 55 push %ebp 10ac95: 89 e5 mov %esp,%ebp 10ac97: 56 push %esi 10ac98: 53 push %ebx POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10ac99: 8b 5d 0c mov 0xc(%ebp),%ebx 10ac9c: 85 db test %ebx,%ebx 10ac9e: 75 05 jne 10aca5 else the_attr = &_POSIX_Condition_variables_Default_attributes; 10aca0: bb b4 15 12 00 mov $0x1215b4,%ebx /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return EINVAL; 10aca5: 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 ) 10acaa: 83 7b 04 01 cmpl $0x1,0x4(%ebx) 10acae: 74 76 je 10ad26 <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 10acb0: 83 3b 00 cmpl $0x0,(%ebx) 10acb3: 74 71 je 10ad26 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10acb5: a1 60 73 12 00 mov 0x127360,%eax 10acba: 40 inc %eax 10acbb: 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 ); 10acc0: 83 ec 0c sub $0xc,%esp 10acc3: 68 9c 77 12 00 push $0x12779c 10acc8: e8 f7 22 00 00 call 10cfc4 <_Objects_Allocate> 10accd: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10accf: 83 c4 10 add $0x10,%esp 10acd2: 85 c0 test %eax,%eax 10acd4: 75 0c jne 10ace2 _Thread_Enable_dispatch(); 10acd6: e8 c7 31 00 00 call 10dea2 <_Thread_Enable_dispatch> return ENOMEM; 10acdb: b8 0c 00 00 00 mov $0xc,%eax 10ace0: eb 44 jmp 10ad26 } the_cond->process_shared = the_attr->process_shared; 10ace2: 8b 43 04 mov 0x4(%ebx),%eax 10ace5: 89 46 10 mov %eax,0x10(%esi) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10ace8: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) _Thread_queue_Initialize( 10acef: 6a 74 push $0x74 10acf1: 68 00 08 00 10 push $0x10000800 10acf6: 6a 00 push $0x0 10acf8: 8d 46 18 lea 0x18(%esi),%eax 10acfb: 50 push %eax 10acfc: e8 5f 38 00 00 call 10e560 <_Thread_queue_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10ad01: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10ad04: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10ad07: 8b 15 b8 77 12 00 mov 0x1277b8,%edx 10ad0d: 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; 10ad10: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10ad17: 8b 55 08 mov 0x8(%ebp),%edx 10ad1a: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 10ad1c: e8 81 31 00 00 call 10dea2 <_Thread_Enable_dispatch> return 0; 10ad21: 83 c4 10 add $0x10,%esp 10ad24: 31 c0 xor %eax,%eax } 10ad26: 8d 65 f8 lea -0x8(%ebp),%esp 10ad29: 5b pop %ebx 10ad2a: 5e pop %esi 10ad2b: c9 leave 10ad2c: c3 ret =============================================================================== 0010ab48 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10ab48: 55 push %ebp 10ab49: 89 e5 mov %esp,%ebp 10ab4b: 8b 55 08 mov 0x8(%ebp),%edx if ( !attr || attr->is_initialized == false ) return EINVAL; 10ab4e: b8 16 00 00 00 mov $0x16,%eax int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == false ) 10ab53: 85 d2 test %edx,%edx 10ab55: 74 0d je 10ab64 10ab57: 83 3a 00 cmpl $0x0,(%edx) 10ab5a: 74 08 je 10ab64 <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 10ab5c: c7 02 00 00 00 00 movl $0x0,(%edx) return 0; 10ab62: 30 c0 xor %al,%al } 10ab64: c9 leave 10ab65: c3 ret =============================================================================== 0010a27c : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10a27c: 55 push %ebp 10a27d: 89 e5 mov %esp,%ebp 10a27f: 57 push %edi 10a280: 56 push %esi 10a281: 53 push %ebx 10a282: 83 ec 5c sub $0x5c,%esp struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) return EFAULT; 10a285: 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 ) 10a28c: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a290: 0f 84 0f 02 00 00 je 10a4a5 return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10a296: 8b 5d 0c mov 0xc(%ebp),%ebx 10a299: 85 db test %ebx,%ebx 10a29b: 75 05 jne 10a2a2 10a29d: bb 40 02 12 00 mov $0x120240,%ebx if ( !the_attr->is_initialized ) return EINVAL; 10a2a2: 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 ) 10a2a9: 83 3b 00 cmpl $0x0,(%ebx) 10a2ac: 0f 84 f3 01 00 00 je 10a4a5 * 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) ) 10a2b2: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a2b6: 74 0e je 10a2c6 10a2b8: a1 44 22 12 00 mov 0x122244,%eax 10a2bd: 39 43 08 cmp %eax,0x8(%ebx) 10a2c0: 0f 82 df 01 00 00 jb 10a4a5 * 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 ) { 10a2c6: 8b 43 10 mov 0x10(%ebx),%eax 10a2c9: 83 f8 01 cmp $0x1,%eax 10a2cc: 74 0b je 10a2d9 10a2ce: 83 f8 02 cmp $0x2,%eax 10a2d1: 0f 85 c7 01 00 00 jne 10a49e 10a2d7: eb 1f jmp 10a2f8 case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a2d9: a1 78 68 12 00 mov 0x126878,%eax 10a2de: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi schedpolicy = api->schedpolicy; 10a2e4: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10a2ea: 89 45 ac mov %eax,-0x54(%ebp) schedparam = api->schedparam; 10a2ed: 8d 7d c4 lea -0x3c(%ebp),%edi 10a2f0: 81 c6 88 00 00 00 add $0x88,%esi 10a2f6: eb 0c jmp 10a304 break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10a2f8: 8b 43 14 mov 0x14(%ebx),%eax 10a2fb: 89 45 ac mov %eax,-0x54(%ebp) schedparam = the_attr->schedparam; 10a2fe: 8d 7d c4 lea -0x3c(%ebp),%edi 10a301: 8d 73 18 lea 0x18(%ebx),%esi 10a304: b9 07 00 00 00 mov $0x7,%ecx 10a309: 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; 10a30b: 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 ) 10a312: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10a316: 0f 85 89 01 00 00 jne 10a4a5 return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10a31c: 83 ec 0c sub $0xc,%esp 10a31f: ff 75 c4 pushl -0x3c(%ebp) 10a322: e8 2d 59 00 00 call 10fc54 <_POSIX_Priority_Is_valid> 10a327: 83 c4 10 add $0x10,%esp return EINVAL; 10a32a: 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 ) ) 10a331: 84 c0 test %al,%al 10a333: 0f 84 6c 01 00 00 je 10a4a5 <== NEVER TAKEN return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 10a339: 8b 45 c4 mov -0x3c(%ebp),%eax 10a33c: 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); 10a33f: 0f b6 3d 48 22 12 00 movzbl 0x122248,%edi /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 10a346: 8d 45 e0 lea -0x20(%ebp),%eax 10a349: 50 push %eax 10a34a: 8d 45 e4 lea -0x1c(%ebp),%eax 10a34d: 50 push %eax 10a34e: 8d 45 c4 lea -0x3c(%ebp),%eax 10a351: 50 push %eax 10a352: ff 75 ac pushl -0x54(%ebp) 10a355: e8 1a 59 00 00 call 10fc74 <_POSIX_Thread_Translate_sched_param> 10a35a: 89 45 b4 mov %eax,-0x4c(%ebp) schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 10a35d: 83 c4 10 add $0x10,%esp 10a360: 85 c0 test %eax,%eax 10a362: 0f 85 3d 01 00 00 jne 10a4a5 #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10a368: 83 ec 0c sub $0xc,%esp 10a36b: ff 35 f4 63 12 00 pushl 0x1263f4 10a371: e8 4e 15 00 00 call 10b8c4 <_API_Mutex_Lock> * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 10a376: c7 04 24 74 65 12 00 movl $0x126574,(%esp) 10a37d: e8 a2 1e 00 00 call 10c224 <_Objects_Allocate> 10a382: 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 ) { 10a385: 83 c4 10 add $0x10,%esp 10a388: 85 c0 test %eax,%eax 10a38a: 75 05 jne 10a391 _RTEMS_Unlock_allocator(); 10a38c: 83 ec 0c sub $0xc,%esp 10a38f: eb 53 jmp 10a3e4 /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10a391: 8b 4d e0 mov -0x20(%ebp),%ecx 10a394: 8b 75 e4 mov -0x1c(%ebp),%esi 10a397: 8b 53 08 mov 0x8(%ebx),%edx 10a39a: a1 44 22 12 00 mov 0x122244,%eax 10a39f: d1 e0 shl %eax 10a3a1: 39 d0 cmp %edx,%eax 10a3a3: 73 02 jae 10a3a7 10a3a5: 89 d0 mov %edx,%eax 10a3a7: 52 push %edx 10a3a8: 6a 00 push $0x0 10a3aa: 6a 00 push $0x0 10a3ac: 51 push %ecx 10a3ad: 56 push %esi 10a3ae: 6a 01 push $0x1 10a3b0: 81 e7 ff 00 00 00 and $0xff,%edi 10a3b6: 2b 7d a8 sub -0x58(%ebp),%edi 10a3b9: 57 push %edi 10a3ba: 6a 01 push $0x1 10a3bc: 50 push %eax 10a3bd: ff 73 04 pushl 0x4(%ebx) 10a3c0: ff 75 b0 pushl -0x50(%ebp) 10a3c3: 68 74 65 12 00 push $0x126574 10a3c8: e8 cb 2d 00 00 call 10d198 <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10a3cd: 83 c4 30 add $0x30,%esp 10a3d0: 84 c0 test %al,%al 10a3d2: 75 2a jne 10a3fe RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 10a3d4: 56 push %esi 10a3d5: 56 push %esi 10a3d6: ff 75 b0 pushl -0x50(%ebp) 10a3d9: 68 74 65 12 00 push $0x126574 10a3de: e8 35 21 00 00 call 10c518 <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a3e3: 5b pop %ebx 10a3e4: ff 35 f4 63 12 00 pushl 0x1263f4 10a3ea: e8 1d 15 00 00 call 10b90c <_API_Mutex_Unlock> return EAGAIN; 10a3ef: 83 c4 10 add $0x10,%esp 10a3f2: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp) 10a3f9: e9 a7 00 00 00 jmp 10a4a5 } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10a3fe: 8b 45 b0 mov -0x50(%ebp),%eax 10a401: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx api->Attributes = *the_attr; 10a407: b9 10 00 00 00 mov $0x10,%ecx 10a40c: 89 d7 mov %edx,%edi 10a40e: 89 de mov %ebx,%esi 10a410: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 10a412: 8b 43 3c mov 0x3c(%ebx),%eax 10a415: 89 42 40 mov %eax,0x40(%edx) api->schedpolicy = schedpolicy; 10a418: 8b 45 ac mov -0x54(%ebp),%eax 10a41b: 89 82 84 00 00 00 mov %eax,0x84(%edx) api->schedparam = schedparam; 10a421: 8d ba 88 00 00 00 lea 0x88(%edx),%edi 10a427: 8d 75 c4 lea -0x3c(%ebp),%esi 10a42a: b1 07 mov $0x7,%cl 10a42c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10a42e: 83 ec 0c sub $0xc,%esp 10a431: 6a 00 push $0x0 10a433: ff 75 14 pushl 0x14(%ebp) 10a436: ff 75 10 pushl 0x10(%ebp) 10a439: 6a 01 push $0x1 10a43b: ff 75 b0 pushl -0x50(%ebp) 10a43e: 89 55 a4 mov %edx,-0x5c(%ebp) 10a441: e8 72 35 00 00 call 10d9b8 <_Thread_Start> _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 10a446: 83 c4 20 add $0x20,%esp 10a449: 83 7d ac 04 cmpl $0x4,-0x54(%ebp) 10a44d: 8b 55 a4 mov -0x5c(%ebp),%edx 10a450: 75 2e jne 10a480 _Watchdog_Insert_ticks( 10a452: 83 ec 0c sub $0xc,%esp &api->Sporadic_timer, _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ) 10a455: 8d 82 90 00 00 00 lea 0x90(%edx),%eax return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10a45b: 50 push %eax 10a45c: e8 a7 36 00 00 call 10db08 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a461: 8b 55 a4 mov -0x5c(%ebp),%edx 10a464: 89 82 b4 00 00 00 mov %eax,0xb4(%edx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a46a: 58 pop %eax 10a46b: 59 pop %ecx 10a46c: 81 c2 a8 00 00 00 add $0xa8,%edx 10a472: 52 push %edx 10a473: 68 14 64 12 00 push $0x126414 10a478: e8 3f 39 00 00 call 10ddbc <_Watchdog_Insert> 10a47d: 83 c4 10 add $0x10,%esp } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10a480: 8b 45 b0 mov -0x50(%ebp),%eax 10a483: 8b 50 08 mov 0x8(%eax),%edx 10a486: 8b 45 08 mov 0x8(%ebp),%eax 10a489: 89 10 mov %edx,(%eax) _RTEMS_Unlock_allocator(); 10a48b: 83 ec 0c sub $0xc,%esp 10a48e: ff 35 f4 63 12 00 pushl 0x1263f4 10a494: e8 73 14 00 00 call 10b90c <_API_Mutex_Unlock> return 0; 10a499: 83 c4 10 add $0x10,%esp 10a49c: eb 07 jmp 10a4a5 schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; break; default: return EINVAL; 10a49e: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10a4a5: 8b 45 b4 mov -0x4c(%ebp),%eax 10a4a8: 8d 65 f4 lea -0xc(%ebp),%esp 10a4ab: 5b pop %ebx 10a4ac: 5e pop %esi 10a4ad: 5f pop %edi 10a4ae: c9 leave 10a4af: c3 ret =============================================================================== 00110d4c : } void pthread_exit( void *value_ptr ) { 110d4c: 55 push %ebp 110d4d: 89 e5 mov %esp,%ebp 110d4f: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 110d52: ff 75 08 pushl 0x8(%ebp) 110d55: ff 35 68 58 12 00 pushl 0x125868 110d5b: e8 88 ff ff ff call 110ce8 <_POSIX_Thread_Exit> 110d60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110d63: c9 leave <== NOT EXECUTED 110d64: c3 ret <== NOT EXECUTED =============================================================================== 001222a4 : int pthread_kill( pthread_t thread, int sig ) { 1222a4: 55 push %ebp 1222a5: 89 e5 mov %esp,%ebp 1222a7: 57 push %edi 1222a8: 56 push %esi 1222a9: 53 push %ebx 1222aa: 83 ec 1c sub $0x1c,%esp 1222ad: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 1222b0: 85 db test %ebx,%ebx 1222b2: 74 08 je 1222bc static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 1222b4: 8d 7b ff lea -0x1(%ebx),%edi rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 1222b7: 83 ff 1f cmp $0x1f,%edi 1222ba: 76 0d jbe 1222c9 rtems_set_errno_and_return_minus_one( EINVAL ); 1222bc: e8 0f 37 ff ff call 1159d0 <__errno> 1222c1: c7 00 16 00 00 00 movl $0x16,(%eax) 1222c7: eb 73 jmp 12233c the_thread = _Thread_Get( thread, &location ); 1222c9: 52 push %edx 1222ca: 52 push %edx 1222cb: 8d 45 e4 lea -0x1c(%ebp),%eax 1222ce: 50 push %eax 1222cf: ff 75 08 pushl 0x8(%ebp) 1222d2: e8 05 e7 fe ff call 1109dc <_Thread_Get> 1222d7: 89 c6 mov %eax,%esi switch ( location ) { 1222d9: 83 c4 10 add $0x10,%esp 1222dc: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 1222e0: 75 4f jne 122331 <== NEVER TAKEN case OBJECTS_LOCAL: /* * If sig == 0 then just validate arguments */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1222e2: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 1222e8: 6b c3 0c imul $0xc,%ebx,%eax 1222eb: 83 b8 18 ba 12 00 01 cmpl $0x1,0x12ba18(%eax) 1222f2: 74 34 je 122328 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 1222f4: b8 01 00 00 00 mov $0x1,%eax 1222f9: 89 f9 mov %edi,%ecx 1222fb: d3 e0 shl %cl,%eax return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 1222fd: 09 82 d4 00 00 00 or %eax,0xd4(%edx) (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 122303: 50 push %eax 122304: 6a 00 push $0x0 122306: 53 push %ebx 122307: 56 push %esi 122308: e8 93 fe ff ff call 1221a0 <_POSIX_signals_Unblock_thread> if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 12230d: 83 c4 10 add $0x10,%esp 122310: 83 3d d8 b9 12 00 00 cmpl $0x0,0x12b9d8 122317: 74 0f je 122328 122319: 3b 35 dc b9 12 00 cmp 0x12b9dc,%esi 12231f: 75 07 jne 122328 _Thread_Dispatch_necessary = true; 122321: c6 05 e8 b9 12 00 01 movb $0x1,0x12b9e8 } _Thread_Enable_dispatch(); 122328: e8 8d e6 fe ff call 1109ba <_Thread_Enable_dispatch> return 0; 12232d: 31 c0 xor %eax,%eax 12232f: eb 0e jmp 12233f #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 122331: e8 9a 36 ff ff call 1159d0 <__errno> <== NOT EXECUTED 122336: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 12233c: 83 c8 ff or $0xffffffff,%eax } 12233f: 8d 65 f4 lea -0xc(%ebp),%esp 122342: 5b pop %ebx 122343: 5e pop %esi 122344: 5f pop %edi 122345: c9 leave 122346: c3 ret =============================================================================== 0010bf78 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10bf78: 55 push %ebp 10bf79: 89 e5 mov %esp,%ebp 10bf7b: 53 push %ebx 10bf7c: 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 ); 10bf7f: 8d 45 f4 lea -0xc(%ebp),%eax 10bf82: 50 push %eax 10bf83: ff 75 0c pushl 0xc(%ebp) 10bf86: e8 b9 00 00 00 call 10c044 <_POSIX_Absolute_timeout_to_ticks> 10bf8b: 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, 10bf8d: 83 c4 0c add $0xc,%esp 10bf90: 83 f8 03 cmp $0x3,%eax 10bf93: 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 ); 10bf96: ff 75 f4 pushl -0xc(%ebp) 10bf99: 0f b6 c2 movzbl %dl,%eax 10bf9c: 50 push %eax 10bf9d: ff 75 08 pushl 0x8(%ebp) 10bfa0: 88 55 e4 mov %dl,-0x1c(%ebp) 10bfa3: e8 e8 fe ff ff call 10be90 <_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) ) { 10bfa8: 83 c4 10 add $0x10,%esp 10bfab: 8a 55 e4 mov -0x1c(%ebp),%dl 10bfae: 84 d2 test %dl,%dl 10bfb0: 75 1d jne 10bfcf 10bfb2: 83 f8 10 cmp $0x10,%eax 10bfb5: 75 18 jne 10bfcf <== NEVER TAKEN if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10bfb7: 85 db test %ebx,%ebx 10bfb9: 74 08 je 10bfc3 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10bfbb: 4b dec %ebx 10bfbc: 83 fb 01 cmp $0x1,%ebx 10bfbf: 77 0e ja 10bfcf <== NEVER TAKEN 10bfc1: eb 07 jmp 10bfca * 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; 10bfc3: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10bfc8: eb 05 jmp 10bfcf <== NOT EXECUTED if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10bfca: b8 74 00 00 00 mov $0x74,%eax } return lock_status; } 10bfcf: 8b 5d fc mov -0x4(%ebp),%ebx 10bfd2: c9 leave 10bfd3: c3 ret =============================================================================== 0010bbf0 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10bbf0: 55 push %ebp 10bbf1: 89 e5 mov %esp,%ebp 10bbf3: 8b 55 08 mov 0x8(%ebp),%edx 10bbf6: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10bbf9: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { if ( !attr || !attr->is_initialized ) 10bbfe: 85 d2 test %edx,%edx 10bc00: 74 0f je 10bc11 10bc02: 83 3a 00 cmpl $0x0,(%edx) 10bc05: 74 0a je 10bc11 return EINVAL; switch ( pshared ) { 10bc07: 83 f9 01 cmp $0x1,%ecx 10bc0a: 77 05 ja 10bc11 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bc0c: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10bc0f: 30 c0 xor %al,%al default: return EINVAL; } } 10bc11: c9 leave 10bc12: c3 ret =============================================================================== 00109e18 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 109e18: 55 push %ebp 109e19: 89 e5 mov %esp,%ebp 109e1b: 8b 55 08 mov 0x8(%ebp),%edx 109e1e: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 109e21: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { if ( !attr || !attr->is_initialized ) 109e26: 85 d2 test %edx,%edx 109e28: 74 0f je 109e39 109e2a: 83 3a 00 cmpl $0x0,(%edx) 109e2d: 74 0a je 109e39 <== NEVER TAKEN return EINVAL; switch ( type ) { 109e2f: 83 f9 03 cmp $0x3,%ecx 109e32: 77 05 ja 109e39 case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 109e34: 89 4a 10 mov %ecx,0x10(%edx) return 0; 109e37: 30 c0 xor %al,%al default: return EINVAL; } } 109e39: c9 leave 109e3a: c3 ret =============================================================================== 0010a8c8 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10a8c8: 55 push %ebp 10a8c9: 89 e5 mov %esp,%ebp 10a8cb: 56 push %esi 10a8cc: 53 push %ebx 10a8cd: 83 ec 10 sub $0x10,%esp 10a8d0: 8b 5d 08 mov 0x8(%ebp),%ebx 10a8d3: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10a8d6: 85 f6 test %esi,%esi 10a8d8: 74 51 je 10a92b 10a8da: 85 db test %ebx,%ebx 10a8dc: 74 4d je 10a92b once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; 10a8de: 31 c0 xor %eax,%eax ) { if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { 10a8e0: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a8e4: 75 4a jne 10a930 rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10a8e6: 52 push %edx 10a8e7: 8d 45 f4 lea -0xc(%ebp),%eax 10a8ea: 50 push %eax 10a8eb: 68 00 01 00 00 push $0x100 10a8f0: 68 00 01 00 00 push $0x100 10a8f5: e8 9e 0a 00 00 call 10b398 if ( !once_control->init_executed ) { 10a8fa: 83 c4 10 add $0x10,%esp 10a8fd: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a901: 75 0f jne 10a912 <== NEVER TAKEN once_control->is_initialized = true; 10a903: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = true; 10a909: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10a910: ff d6 call *%esi } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10a912: 50 push %eax 10a913: 8d 45 f4 lea -0xc(%ebp),%eax 10a916: 50 push %eax 10a917: 68 00 01 00 00 push $0x100 10a91c: ff 75 f4 pushl -0xc(%ebp) 10a91f: e8 74 0a 00 00 call 10b398 10a924: 83 c4 10 add $0x10,%esp } return 0; 10a927: 31 c0 xor %eax,%eax 10a929: eb 05 jmp 10a930 pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) return EINVAL; 10a92b: b8 16 00 00 00 mov $0x16,%eax (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10a930: 8d 65 f8 lea -0x8(%ebp),%esp 10a933: 5b pop %ebx 10a934: 5e pop %esi 10a935: c9 leave 10a936: c3 ret =============================================================================== 0010b0f4 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10b0f4: 55 push %ebp 10b0f5: 89 e5 mov %esp,%ebp 10b0f7: 56 push %esi 10b0f8: 53 push %ebx 10b0f9: 83 ec 10 sub $0x10,%esp 10b0fc: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Error check parameters */ if ( !rwlock ) return EINVAL; 10b0ff: b8 16 00 00 00 mov $0x16,%eax const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10b104: 85 db test %ebx,%ebx 10b106: 0f 84 8b 00 00 00 je 10b197 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10b10c: 8b 75 0c mov 0xc(%ebp),%esi 10b10f: 85 f6 test %esi,%esi 10b111: 75 0f jne 10b122 the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10b113: 83 ec 0c sub $0xc,%esp 10b116: 8d 75 ec lea -0x14(%ebp),%esi 10b119: 56 push %esi 10b11a: e8 5d 09 00 00 call 10ba7c 10b11f: 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; 10b122: 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 ) 10b127: 83 3e 00 cmpl $0x0,(%esi) 10b12a: 74 6b je 10b197 <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 10b12c: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b130: 75 65 jne 10b197 <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 10b132: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b139: a1 50 83 12 00 mov 0x128350,%eax 10b13e: 40 inc %eax 10b13f: a3 50 83 12 00 mov %eax,0x128350 * 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 ); 10b144: 83 ec 0c sub $0xc,%esp 10b147: 68 34 85 12 00 push $0x128534 10b14c: e8 33 23 00 00 call 10d484 <_Objects_Allocate> 10b151: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10b153: 83 c4 10 add $0x10,%esp 10b156: 85 c0 test %eax,%eax 10b158: 75 0c jne 10b166 _Thread_Enable_dispatch(); 10b15a: e8 03 32 00 00 call 10e362 <_Thread_Enable_dispatch> return EAGAIN; 10b15f: b8 0b 00 00 00 mov $0xb,%eax 10b164: eb 31 jmp 10b197 } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10b166: 50 push %eax 10b167: 50 push %eax 10b168: 8d 45 f4 lea -0xc(%ebp),%eax 10b16b: 50 push %eax 10b16c: 8d 46 10 lea 0x10(%esi),%eax 10b16f: 50 push %eax 10b170: e8 7b 1b 00 00 call 10ccf0 <_CORE_RWLock_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b175: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b178: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b17b: 8b 15 50 85 12 00 mov 0x128550,%edx 10b181: 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; 10b184: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10b18b: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10b18d: e8 d0 31 00 00 call 10e362 <_Thread_Enable_dispatch> return 0; 10b192: 83 c4 10 add $0x10,%esp 10b195: 31 c0 xor %eax,%eax } 10b197: 8d 65 f8 lea -0x8(%ebp),%esp 10b19a: 5b pop %ebx 10b19b: 5e pop %esi 10b19c: c9 leave 10b19d: c3 ret =============================================================================== 0010b208 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b208: 55 push %ebp 10b209: 89 e5 mov %esp,%ebp 10b20b: 57 push %edi 10b20c: 56 push %esi 10b20d: 53 push %ebx 10b20e: 83 ec 2c sub $0x2c,%esp 10b211: 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; 10b214: 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 ) 10b219: 85 ff test %edi,%edi 10b21b: 0f 84 87 00 00 00 je 10b2a8 * * 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 ); 10b221: 50 push %eax 10b222: 50 push %eax 10b223: 8d 45 e0 lea -0x20(%ebp),%eax 10b226: 50 push %eax 10b227: ff 75 0c pushl 0xc(%ebp) 10b22a: e8 65 59 00 00 call 110b94 <_POSIX_Absolute_timeout_to_ticks> 10b22f: 89 c6 mov %eax,%esi 10b231: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b234: 8d 45 e4 lea -0x1c(%ebp),%eax 10b237: 50 push %eax 10b238: ff 37 pushl (%edi) 10b23a: 68 34 85 12 00 push $0x128534 10b23f: e8 6c 26 00 00 call 10d8b0 <_Objects_Get> switch ( location ) { 10b244: 83 c4 10 add $0x10,%esp 10b247: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b24b: 75 5b jne 10b2a8 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, 10b24d: 83 fe 03 cmp $0x3,%esi 10b250: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10b253: 83 ec 0c sub $0xc,%esp 10b256: 6a 00 push $0x0 10b258: ff 75 e0 pushl -0x20(%ebp) 10b25b: 0f b6 ca movzbl %dl,%ecx 10b25e: 51 push %ecx 10b25f: ff 37 pushl (%edi) 10b261: 83 c0 10 add $0x10,%eax 10b264: 50 push %eax 10b265: 88 55 d4 mov %dl,-0x2c(%ebp) 10b268: e8 b7 1a 00 00 call 10cd24 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b26d: 83 c4 20 add $0x20,%esp 10b270: e8 ed 30 00 00 call 10e362 <_Thread_Enable_dispatch> if ( !do_wait ) { 10b275: 8a 55 d4 mov -0x2c(%ebp),%dl 10b278: 84 d2 test %dl,%dl 10b27a: 75 17 jne 10b293 if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 10b27c: a1 78 88 12 00 mov 0x128878,%eax 10b281: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b285: 75 0c jne 10b293 if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b287: 85 f6 test %esi,%esi 10b289: 74 1d je 10b2a8 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b28b: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b28c: 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 || 10b28e: 83 fe 01 cmp $0x1,%esi 10b291: 76 15 jbe 10b2a8 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b293: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b296: a1 78 88 12 00 mov 0x128878,%eax status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b29b: ff 70 34 pushl 0x34(%eax) 10b29e: e8 bd 00 00 00 call 10b360 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b2a3: 89 c3 mov %eax,%ebx 10b2a5: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b2a8: 89 d8 mov %ebx,%eax 10b2aa: 8d 65 f4 lea -0xc(%ebp),%esp 10b2ad: 5b pop %ebx 10b2ae: 5e pop %esi 10b2af: 5f pop %edi 10b2b0: c9 leave 10b2b1: c3 ret =============================================================================== 0010b2b4 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b2b4: 55 push %ebp 10b2b5: 89 e5 mov %esp,%ebp 10b2b7: 57 push %edi 10b2b8: 56 push %esi 10b2b9: 53 push %ebx 10b2ba: 83 ec 2c sub $0x2c,%esp 10b2bd: 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; 10b2c0: 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 ) 10b2c5: 85 ff test %edi,%edi 10b2c7: 0f 84 87 00 00 00 je 10b354 * * 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 ); 10b2cd: 50 push %eax 10b2ce: 50 push %eax 10b2cf: 8d 45 e0 lea -0x20(%ebp),%eax 10b2d2: 50 push %eax 10b2d3: ff 75 0c pushl 0xc(%ebp) 10b2d6: e8 b9 58 00 00 call 110b94 <_POSIX_Absolute_timeout_to_ticks> 10b2db: 89 c6 mov %eax,%esi 10b2dd: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b2e0: 8d 45 e4 lea -0x1c(%ebp),%eax 10b2e3: 50 push %eax 10b2e4: ff 37 pushl (%edi) 10b2e6: 68 34 85 12 00 push $0x128534 10b2eb: e8 c0 25 00 00 call 10d8b0 <_Objects_Get> switch ( location ) { 10b2f0: 83 c4 10 add $0x10,%esp 10b2f3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b2f7: 75 5b jne 10b354 (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, 10b2f9: 83 fe 03 cmp $0x3,%esi 10b2fc: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10b2ff: 83 ec 0c sub $0xc,%esp 10b302: 6a 00 push $0x0 10b304: ff 75 e0 pushl -0x20(%ebp) 10b307: 0f b6 ca movzbl %dl,%ecx 10b30a: 51 push %ecx 10b30b: ff 37 pushl (%edi) 10b30d: 83 c0 10 add $0x10,%eax 10b310: 50 push %eax 10b311: 88 55 d4 mov %dl,-0x2c(%ebp) 10b314: e8 c3 1a 00 00 call 10cddc <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b319: 83 c4 20 add $0x20,%esp 10b31c: e8 41 30 00 00 call 10e362 <_Thread_Enable_dispatch> if ( !do_wait && 10b321: 8a 55 d4 mov -0x2c(%ebp),%dl 10b324: 84 d2 test %dl,%dl 10b326: 75 17 jne 10b33f (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 10b328: a1 78 88 12 00 mov 0x128878,%eax ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10b32d: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b331: 75 0c jne 10b33f (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b333: 85 f6 test %esi,%esi 10b335: 74 1d je 10b354 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b337: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b338: 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 || 10b33a: 83 fe 01 cmp $0x1,%esi 10b33d: 76 15 jbe 10b354 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b33f: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b342: a1 78 88 12 00 mov 0x128878,%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( 10b347: ff 70 34 pushl 0x34(%eax) 10b34a: e8 11 00 00 00 call 10b360 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b34f: 89 c3 mov %eax,%ebx 10b351: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b354: 89 d8 mov %ebx,%eax 10b356: 8d 65 f4 lea -0xc(%ebp),%esp 10b359: 5b pop %ebx 10b35a: 5e pop %esi 10b35b: 5f pop %edi 10b35c: c9 leave 10b35d: c3 ret =============================================================================== 0010ba9c : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10ba9c: 55 push %ebp 10ba9d: 89 e5 mov %esp,%ebp 10ba9f: 8b 55 08 mov 0x8(%ebp),%edx 10baa2: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr ) return EINVAL; 10baa5: b8 16 00 00 00 mov $0x16,%eax int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { if ( !attr ) 10baaa: 85 d2 test %edx,%edx 10baac: 74 0f je 10babd return EINVAL; if ( !attr->is_initialized ) 10baae: 83 3a 00 cmpl $0x0,(%edx) 10bab1: 74 0a je 10babd return EINVAL; switch ( pshared ) { 10bab3: 83 f9 01 cmp $0x1,%ecx 10bab6: 77 05 ja 10babd <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bab8: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10babb: 30 c0 xor %al,%al default: return EINVAL; } } 10babd: c9 leave 10babe: c3 ret =============================================================================== 0010c798 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10c798: 55 push %ebp 10c799: 89 e5 mov %esp,%ebp 10c79b: 57 push %edi 10c79c: 56 push %esi 10c79d: 53 push %ebx 10c79e: 83 ec 2c sub $0x2c,%esp 10c7a1: 8b 75 10 mov 0x10(%ebp),%esi /* * Check all the parameters */ if ( !param ) return EINVAL; 10c7a4: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp) int rc; /* * Check all the parameters */ if ( !param ) 10c7ab: 85 f6 test %esi,%esi 10c7ad: 0f 84 fc 00 00 00 je 10c8af return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 10c7b3: 8d 45 e0 lea -0x20(%ebp),%eax 10c7b6: 50 push %eax 10c7b7: 8d 45 e4 lea -0x1c(%ebp),%eax 10c7ba: 50 push %eax 10c7bb: 56 push %esi 10c7bc: ff 75 0c pushl 0xc(%ebp) 10c7bf: e8 20 53 00 00 call 111ae4 <_POSIX_Thread_Translate_sched_param> 10c7c4: 89 45 d4 mov %eax,-0x2c(%ebp) policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 10c7c7: 83 c4 10 add $0x10,%esp 10c7ca: 85 c0 test %eax,%eax 10c7cc: 0f 85 dd 00 00 00 jne 10c8af return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _Thread_Get( thread, &location ); 10c7d2: 53 push %ebx 10c7d3: 53 push %ebx 10c7d4: 8d 45 dc lea -0x24(%ebp),%eax 10c7d7: 50 push %eax 10c7d8: ff 75 08 pushl 0x8(%ebp) 10c7db: e8 54 27 00 00 call 10ef34 <_Thread_Get> 10c7e0: 89 c2 mov %eax,%edx switch ( location ) { 10c7e2: 83 c4 10 add $0x10,%esp 10c7e5: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) 10c7e9: 0f 85 b9 00 00 00 jne 10c8a8 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c7ef: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx if ( api->schedpolicy == SCHED_SPORADIC ) 10c7f5: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx) 10c7fc: 75 18 jne 10c816 (void) _Watchdog_Remove( &api->Sporadic_timer ); 10c7fe: 83 ec 0c sub $0xc,%esp 10c801: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax 10c807: 50 push %eax 10c808: 89 55 d0 mov %edx,-0x30(%ebp) 10c80b: e8 68 35 00 00 call 10fd78 <_Watchdog_Remove> 10c810: 83 c4 10 add $0x10,%esp 10c813: 8b 55 d0 mov -0x30(%ebp),%edx api->schedpolicy = policy; 10c816: 8b 45 0c mov 0xc(%ebp),%eax 10c819: 89 83 84 00 00 00 mov %eax,0x84(%ebx) api->schedparam = *param; 10c81f: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 10c825: b9 07 00 00 00 mov $0x7,%ecx 10c82a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10c82c: 8b 45 e4 mov -0x1c(%ebp),%eax 10c82f: 89 42 7c mov %eax,0x7c(%edx) the_thread->budget_callout = budget_callout; 10c832: 8b 45 e0 mov -0x20(%ebp),%eax 10c835: 89 82 80 00 00 00 mov %eax,0x80(%edx) switch ( api->schedpolicy ) { 10c83b: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10c83f: 78 60 js 10c8a1 <== NEVER TAKEN 10c841: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10c845: 7e 08 jle 10c84f 10c847: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10c84b: 75 54 jne 10c8a1 <== NEVER TAKEN 10c84d: eb 24 jmp 10c873 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c84f: a1 c0 a3 12 00 mov 0x12a3c0,%eax 10c854: 89 42 78 mov %eax,0x78(%edx) 10c857: 0f b6 05 88 62 12 00 movzbl 0x126288,%eax 10c85e: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax the_thread->real_priority = 10c864: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10c867: 51 push %ecx 10c868: 6a 01 push $0x1 10c86a: 50 push %eax 10c86b: 52 push %edx 10c86c: e8 cb 22 00 00 call 10eb3c <_Thread_Change_priority> 10c871: eb 2b jmp 10c89e true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10c873: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10c879: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) _Watchdog_Remove( &api->Sporadic_timer ); 10c87f: 83 ec 0c sub $0xc,%esp 10c882: 81 c3 a8 00 00 00 add $0xa8,%ebx 10c888: 53 push %ebx 10c889: 89 55 d0 mov %edx,-0x30(%ebp) 10c88c: e8 e7 34 00 00 call 10fd78 <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10c891: 58 pop %eax 10c892: 5a pop %edx 10c893: 8b 55 d0 mov -0x30(%ebp),%edx 10c896: 52 push %edx 10c897: 6a 00 push $0x0 10c899: e8 e5 fd ff ff call 10c683 <_POSIX_Threads_Sporadic_budget_TSR> break; 10c89e: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10c8a1: e8 6c 26 00 00 call 10ef12 <_Thread_Enable_dispatch> return 0; 10c8a6: eb 07 jmp 10c8af #endif case OBJECTS_ERROR: break; } return ESRCH; 10c8a8: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp) } 10c8af: 8b 45 d4 mov -0x2c(%ebp),%eax 10c8b2: 8d 65 f4 lea -0xc(%ebp),%esp 10c8b5: 5b pop %ebx 10c8b6: 5e pop %esi 10c8b7: 5f pop %edi 10c8b8: c9 leave 10c8b9: c3 ret =============================================================================== 0010a690 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a690: 55 push %ebp 10a691: 89 e5 mov %esp,%ebp 10a693: 53 push %ebx 10a694: 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() ) 10a697: 83 3d 6c 68 12 00 00 cmpl $0x0,0x12686c 10a69e: 75 48 jne 10a6e8 <== NEVER TAKEN return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a6a0: a1 70 68 12 00 mov 0x126870,%eax 10a6a5: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10a6ab: 8b 15 48 63 12 00 mov 0x126348,%edx 10a6b1: 42 inc %edx 10a6b2: 89 15 48 63 12 00 mov %edx,0x126348 */ void pthread_testcancel( void ) { POSIX_API_Control *thread_support; bool cancel = false; 10a6b8: 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 && 10a6ba: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10a6c1: 75 0a jne 10a6cd <== 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)); 10a6c3: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10a6ca: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a6cd: e8 e4 25 00 00 call 10ccb6 <_Thread_Enable_dispatch> if ( cancel ) 10a6d2: 84 db test %bl,%bl 10a6d4: 74 12 je 10a6e8 _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a6d6: 50 push %eax 10a6d7: 50 push %eax 10a6d8: 6a ff push $0xffffffff 10a6da: ff 35 70 68 12 00 pushl 0x126870 10a6e0: e8 bf 52 00 00 call 10f9a4 <_POSIX_Thread_Exit> 10a6e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a6e8: 8b 5d fc mov -0x4(%ebp),%ebx 10a6eb: c9 leave 10a6ec: c3 ret =============================================================================== 0010af85 : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10af85: 55 push %ebp 10af86: 89 e5 mov %esp,%ebp 10af88: 57 push %edi 10af89: 56 push %esi 10af8a: 53 push %ebx 10af8b: 83 ec 58 sub $0x58,%esp 10af8e: 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); 10af91: 68 d8 72 12 00 push $0x1272d8 10af96: e8 c5 08 00 00 call 10b860 10af9b: 89 45 b4 mov %eax,-0x4c(%ebp) if (result != 0) { 10af9e: 83 c4 10 add $0x10,%esp 10afa1: 85 c0 test %eax,%eax 10afa3: 74 0e je 10afb3 <== ALWAYS TAKEN free (req); 10afa5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10afa8: 53 push %ebx <== NOT EXECUTED 10afa9: e8 c2 cd ff ff call 107d70 <== NOT EXECUTED 10afae: e9 c6 01 00 00 jmp 10b179 <== 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); 10afb3: e8 a4 10 00 00 call 10c05c 10afb8: 57 push %edi 10afb9: 8d 55 c4 lea -0x3c(%ebp),%edx 10afbc: 52 push %edx 10afbd: 8d 55 e0 lea -0x20(%ebp),%edx 10afc0: 52 push %edx 10afc1: 50 push %eax 10afc2: e8 9d 0c 00 00 call 10bc64 req->caller_thread = pthread_self (); 10afc7: e8 90 10 00 00 call 10c05c 10afcc: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10afcf: 8b 43 14 mov 0x14(%ebx),%eax 10afd2: 8b 55 c4 mov -0x3c(%ebp),%edx 10afd5: 2b 50 14 sub 0x14(%eax),%edx 10afd8: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10afdb: 8b 55 e0 mov -0x20(%ebp),%edx 10afde: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10afe1: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10afe8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10afef: 83 c4 10 add $0x10,%esp 10aff2: 83 3d 40 73 12 00 00 cmpl $0x0,0x127340 10aff9: 0f 85 b7 00 00 00 jne 10b0b6 <== NEVER TAKEN 10afff: 83 3d 3c 73 12 00 04 cmpl $0x4,0x12733c 10b006: 0f 8f aa 00 00 00 jg 10b0b6 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); 10b00c: 56 push %esi 10b00d: 6a 01 push $0x1 10b00f: ff 30 pushl (%eax) 10b011: 68 20 73 12 00 push $0x127320 10b016: e8 81 fb ff ff call 10ab9c 10b01b: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10b01d: 83 c4 10 add $0x10,%esp 10b020: 83 78 18 01 cmpl $0x1,0x18(%eax) 10b024: 8d 50 08 lea 0x8(%eax),%edx 10b027: 8d 78 1c lea 0x1c(%eax),%edi 10b02a: 8d 40 20 lea 0x20(%eax),%eax 10b02d: 89 45 b0 mov %eax,-0x50(%ebp) 10b030: 75 66 jne 10b098 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10b032: 51 push %ecx 10b033: 51 push %ecx 10b034: 53 push %ebx 10b035: 52 push %edx 10b036: e8 c1 1f 00 00 call 10cffc <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10b03b: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10b042: 5b pop %ebx 10b043: 58 pop %eax 10b044: 6a 00 push $0x0 10b046: 57 push %edi 10b047: e8 f4 06 00 00 call 10b740 pthread_cond_init (&r_chain->cond, NULL); 10b04c: 5a pop %edx 10b04d: 59 pop %ecx 10b04e: 6a 00 push $0x0 10b050: ff 75 b0 pushl -0x50(%ebp) 10b053: e8 a8 03 00 00 call 10b400 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10b058: 56 push %esi 10b059: 68 78 ac 10 00 push $0x10ac78 10b05e: 68 e0 72 12 00 push $0x1272e0 10b063: 8d 45 e4 lea -0x1c(%ebp),%eax 10b066: 50 push %eax 10b067: e8 c4 09 00 00 call 10ba30 10b06c: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10b06e: 83 c4 20 add $0x20,%esp 10b071: 85 c0 test %eax,%eax 10b073: 74 18 je 10b08d <== ALWAYS TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10b075: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b078: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED 10b07d: e8 5e 08 00 00 call 10b8e0 <== NOT EXECUTED return result; 10b082: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b085: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED 10b088: e9 ef 00 00 00 jmp 10b17c <== NOT EXECUTED } ++aio_request_queue.active_threads; 10b08d: ff 05 3c 73 12 00 incl 0x12733c 10b093: e9 d4 00 00 00 jmp 10b16c } else { /* put request in the fd chain it belongs to */ pthread_mutex_lock (&r_chain->mutex); 10b098: 83 ec 0c sub $0xc,%esp 10b09b: 57 push %edi 10b09c: 89 55 ac mov %edx,-0x54(%ebp) 10b09f: e8 bc 07 00 00 call 10b860 rtems_aio_insert_prio (&r_chain->perfd, req); 10b0a4: 5e pop %esi 10b0a5: 58 pop %eax 10b0a6: 53 push %ebx 10b0a7: 8b 55 ac mov -0x54(%ebp),%edx 10b0aa: 52 push %edx 10b0ab: e8 ec fd ff ff call 10ae9c pthread_cond_signal (&r_chain->cond); 10b0b0: 5b pop %ebx 10b0b1: ff 75 b0 pushl -0x50(%ebp) 10b0b4: eb 36 jmp 10b0ec 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, 10b0b6: 51 push %ecx 10b0b7: 6a 00 push $0x0 10b0b9: ff 30 pushl (%eax) 10b0bb: 68 20 73 12 00 push $0x127320 10b0c0: e8 d7 fa ff ff call 10ab9c 10b0c5: 89 c6 mov %eax,%esi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10b0c7: 83 c4 10 add $0x10,%esp 10b0ca: 85 c0 test %eax,%eax 10b0cc: 74 2d je 10b0fb { pthread_mutex_lock (&r_chain->mutex); 10b0ce: 8d 78 1c lea 0x1c(%eax),%edi 10b0d1: 83 ec 0c sub $0xc,%esp 10b0d4: 57 push %edi 10b0d5: e8 86 07 00 00 call 10b860 rtems_aio_insert_prio (&r_chain->perfd, req); 10b0da: 58 pop %eax 10b0db: 5a pop %edx 10b0dc: 53 push %ebx 10b0dd: 8d 46 08 lea 0x8(%esi),%eax 10b0e0: 50 push %eax 10b0e1: e8 b6 fd ff ff call 10ae9c pthread_cond_signal (&r_chain->cond); 10b0e6: 83 c6 20 add $0x20,%esi 10b0e9: 89 34 24 mov %esi,(%esp) 10b0ec: e8 ab 03 00 00 call 10b49c pthread_mutex_unlock (&r_chain->mutex); 10b0f1: 89 3c 24 mov %edi,(%esp) 10b0f4: e8 e7 07 00 00 call 10b8e0 10b0f9: eb 6e jmp 10b169 } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10b0fb: 56 push %esi 10b0fc: 6a 01 push $0x1 10b0fe: 8b 43 14 mov 0x14(%ebx),%eax 10b101: ff 30 pushl (%eax) 10b103: 68 2c 73 12 00 push $0x12732c 10b108: e8 8f fa ff ff call 10ab9c 10b10d: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10b10f: 83 c4 10 add $0x10,%esp 10b112: 83 78 18 01 cmpl $0x1,0x18(%eax) 10b116: 8d 40 08 lea 0x8(%eax),%eax 10b119: 75 2c jne 10b147 10b11b: 51 push %ecx 10b11c: 51 push %ecx 10b11d: 53 push %ebx 10b11e: 50 push %eax 10b11f: e8 d8 1e 00 00 call 10cffc <_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; 10b124: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10b12b: 58 pop %eax 10b12c: 5a pop %edx 10b12d: 6a 00 push $0x0 10b12f: 8d 46 1c lea 0x1c(%esi),%eax 10b132: 50 push %eax 10b133: e8 08 06 00 00 call 10b740 pthread_cond_init (&r_chain->cond, NULL); 10b138: 5b pop %ebx 10b139: 5f pop %edi 10b13a: 6a 00 push $0x0 10b13c: 83 c6 20 add $0x20,%esi 10b13f: 56 push %esi 10b140: e8 bb 02 00 00 call 10b400 10b145: eb 09 jmp 10b150 } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10b147: 51 push %ecx 10b148: 51 push %ecx 10b149: 53 push %ebx 10b14a: 50 push %eax 10b14b: e8 4c fd ff ff call 10ae9c 10b150: 83 c4 10 add $0x10,%esp if (aio_request_queue.idle_threads > 0) 10b153: 83 3d 40 73 12 00 00 cmpl $0x0,0x127340 10b15a: 7e 10 jle 10b16c <== ALWAYS TAKEN pthread_cond_signal (&aio_request_queue.new_req); 10b15c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b15f: 68 dc 72 12 00 push $0x1272dc <== NOT EXECUTED 10b164: e8 33 03 00 00 call 10b49c <== NOT EXECUTED 10b169: 83 c4 10 add $0x10,%esp } } pthread_mutex_unlock (&aio_request_queue.mutex); 10b16c: 83 ec 0c sub $0xc,%esp 10b16f: 68 d8 72 12 00 push $0x1272d8 10b174: e8 67 07 00 00 call 10b8e0 return 0; 10b179: 83 c4 10 add $0x10,%esp } 10b17c: 8b 45 b4 mov -0x4c(%ebp),%eax 10b17f: 8d 65 f4 lea -0xc(%ebp),%esp 10b182: 5b pop %ebx 10b183: 5e pop %esi 10b184: 5f pop %edi 10b185: c9 leave 10b186: c3 ret =============================================================================== 0010ac78 : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10ac78: 55 push %ebp 10ac79: 89 e5 mov %esp,%ebp 10ac7b: 57 push %edi 10ac7c: 56 push %esi 10ac7d: 53 push %ebx 10ac7e: 83 ec 4c sub $0x4c,%esp rtems_aio_request_chain *r_chain = arg; 10ac81: 8b 5d 08 mov 0x8(%ebp),%ebx pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_lock (&aio_request_queue.mutex); if (rtems_chain_is_empty (chain)) { clock_gettime (CLOCK_REALTIME, &timeout); 10ac84: 8d 7d dc lea -0x24(%ebp),%edi /* 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); 10ac87: 8d 43 1c lea 0x1c(%ebx),%eax 10ac8a: 89 45 b4 mov %eax,-0x4c(%ebp) 10ac8d: 83 ec 0c sub $0xc,%esp 10ac90: 50 push %eax 10ac91: e8 ca 0b 00 00 call 10b860 if (result != 0) 10ac96: 83 c4 10 add $0x10,%esp 10ac99: 85 c0 test %eax,%eax 10ac9b: 0f 85 f1 01 00 00 jne 10ae92 <== NEVER TAKEN } } AIO_printf ("Thread finished\n"); return NULL; } 10aca1: 8b 73 08 mov 0x8(%ebx),%esi RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10aca4: 8d 43 0c lea 0xc(%ebx),%eax /* 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)) { 10aca7: 39 c6 cmp %eax,%esi 10aca9: 0f 84 cd 00 00 00 je 10ad7c 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); 10acaf: e8 a8 13 00 00 call 10c05c 10acb4: 52 push %edx 10acb5: 8d 55 c0 lea -0x40(%ebp),%edx 10acb8: 52 push %edx 10acb9: 8d 4d e4 lea -0x1c(%ebp),%ecx 10acbc: 51 push %ecx 10acbd: 50 push %eax 10acbe: e8 a1 0f 00 00 call 10bc64 param.sched_priority = req->priority; 10acc3: 8b 46 0c mov 0xc(%esi),%eax 10acc6: 89 45 c0 mov %eax,-0x40(%ebp) pthread_setschedparam (pthread_self(), req->policy, ¶m); 10acc9: 8b 56 08 mov 0x8(%esi),%edx 10accc: 89 55 b0 mov %edx,-0x50(%ebp) 10accf: e8 88 13 00 00 call 10c05c 10acd4: 83 c4 0c add $0xc,%esp 10acd7: 8d 4d c0 lea -0x40(%ebp),%ecx 10acda: 51 push %ecx 10acdb: 8b 55 b0 mov -0x50(%ebp),%edx 10acde: 52 push %edx 10acdf: 50 push %eax 10ace0: e8 87 13 00 00 call 10c06c */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10ace5: 89 34 24 mov %esi,(%esp) 10ace8: e8 d3 22 00 00 call 10cfc0 <_Chain_Extract> rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10aced: 59 pop %ecx 10acee: ff 75 b4 pushl -0x4c(%ebp) 10acf1: e8 ea 0b 00 00 call 10b8e0 switch (req->aiocbp->aio_lio_opcode) { 10acf6: 8b 46 14 mov 0x14(%esi),%eax 10acf9: 83 c4 10 add $0x10,%esp 10acfc: 8b 50 2c mov 0x2c(%eax),%edx 10acff: 83 fa 02 cmp $0x2,%edx 10ad02: 74 20 je 10ad24 10ad04: 83 fa 03 cmp $0x3,%edx 10ad07: 74 36 je 10ad3f <== NEVER TAKEN 10ad09: 4a dec %edx 10ad0a: 75 45 jne 10ad51 <== NEVER TAKEN case LIO_READ: AIO_printf ("read\n"); result = pread (req->aiocbp->aio_fildes, 10ad0c: 83 ec 0c sub $0xc,%esp 10ad0f: ff 70 08 pushl 0x8(%eax) 10ad12: ff 70 04 pushl 0x4(%eax) 10ad15: ff 70 10 pushl 0x10(%eax) 10ad18: ff 70 0c pushl 0xc(%eax) 10ad1b: ff 30 pushl (%eax) 10ad1d: e8 fe 93 00 00 call 114120 10ad22: eb 16 jmp 10ad3a req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: AIO_printf ("write\n"); result = pwrite (req->aiocbp->aio_fildes, 10ad24: 83 ec 0c sub $0xc,%esp 10ad27: ff 70 08 pushl 0x8(%eax) 10ad2a: ff 70 04 pushl 0x4(%eax) 10ad2d: ff 70 10 pushl 0x10(%eax) 10ad30: ff 70 0c pushl 0xc(%eax) 10ad33: ff 30 pushl (%eax) 10ad35: e8 9a 94 00 00 call 1141d4 (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10ad3a: 83 c4 20 add $0x20,%esp 10ad3d: eb 0d jmp 10ad4c case LIO_SYNC: AIO_printf ("sync\n"); result = fsync (req->aiocbp->aio_fildes); 10ad3f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad42: ff 30 pushl (%eax) <== NOT EXECUTED 10ad44: e8 33 5d 00 00 call 110a7c <== NOT EXECUTED break; 10ad49: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: result = -1; } if (result == -1) { 10ad4c: 83 f8 ff cmp $0xffffffff,%eax 10ad4f: 75 19 jne 10ad6a <== ALWAYS TAKEN req->aiocbp->return_value = -1; 10ad51: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10ad54: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10ad5b: e8 88 89 00 00 call 1136e8 <__errno> <== NOT EXECUTED 10ad60: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10ad62: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10ad65: e9 1d ff ff ff jmp 10ac87 <== NOT EXECUTED } else { req->aiocbp->return_value = result; 10ad6a: 8b 56 14 mov 0x14(%esi),%edx 10ad6d: 89 42 34 mov %eax,0x34(%edx) req->aiocbp->error_code = 0; 10ad70: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 10ad77: e9 0b ff ff ff jmp 10ac87 struct timespec timeout; AIO_printf ("Chain is empty [WQ], wait for work\n"); pthread_mutex_unlock (&r_chain->mutex); 10ad7c: 83 ec 0c sub $0xc,%esp 10ad7f: ff 75 b4 pushl -0x4c(%ebp) 10ad82: e8 59 0b 00 00 call 10b8e0 pthread_mutex_lock (&aio_request_queue.mutex); 10ad87: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp) 10ad8e: e8 cd 0a 00 00 call 10b860 if (rtems_chain_is_empty (chain)) 10ad93: 83 c4 10 add $0x10,%esp 10ad96: 39 73 08 cmp %esi,0x8(%ebx) 10ad99: 0f 85 de 00 00 00 jne 10ae7d <== NEVER TAKEN { clock_gettime (CLOCK_REALTIME, &timeout); 10ad9f: 52 push %edx 10ada0: 52 push %edx 10ada1: 57 push %edi 10ada2: 6a 01 push $0x1 10ada4: e8 47 05 00 00 call 10b2f0 timeout.tv_sec += 3; 10ada9: 83 45 dc 03 addl $0x3,-0x24(%ebp) timeout.tv_nsec = 0; 10adad: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) result = pthread_cond_timedwait (&r_chain->cond, 10adb4: 8d 73 20 lea 0x20(%ebx),%esi 10adb7: 83 c4 0c add $0xc,%esp 10adba: 57 push %edi 10adbb: 68 d8 72 12 00 push $0x1272d8 10adc0: 56 push %esi 10adc1: e8 46 07 00 00 call 10b50c &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) { 10adc6: 83 c4 10 add $0x10,%esp 10adc9: 83 f8 74 cmp $0x74,%eax 10adcc: 0f 85 ab 00 00 00 jne 10ae7d <== NEVER TAKEN 10add2: 83 ec 0c sub $0xc,%esp 10add5: 53 push %ebx 10add6: e8 e5 21 00 00 call 10cfc0 <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10addb: 58 pop %eax 10addc: ff 75 b4 pushl -0x4c(%ebp) 10addf: e8 5c 08 00 00 call 10b640 pthread_cond_destroy (&r_chain->cond); 10ade4: 89 34 24 mov %esi,(%esp) 10ade7: e8 60 05 00 00 call 10b34c free (r_chain); 10adec: 89 1c 24 mov %ebx,(%esp) 10adef: e8 7c cf ff ff call 107d70 /* 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)) { 10adf4: 83 c4 10 add $0x10,%esp 10adf7: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c 10adfe: 73 12 00 10ae01: 75 54 jne 10ae57 AIO_printf ("Chain is empty [IQ], wait for work\n"); ++aio_request_queue.idle_threads; 10ae03: ff 05 40 73 12 00 incl 0x127340 --aio_request_queue.active_threads; 10ae09: ff 0d 3c 73 12 00 decl 0x12733c clock_gettime (CLOCK_REALTIME, &timeout); 10ae0f: 53 push %ebx 10ae10: 53 push %ebx 10ae11: 57 push %edi 10ae12: 6a 01 push $0x1 10ae14: e8 d7 04 00 00 call 10b2f0 timeout.tv_sec += 3; 10ae19: 83 45 dc 03 addl $0x3,-0x24(%ebp) timeout.tv_nsec = 0; 10ae1d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) result = pthread_cond_timedwait (&aio_request_queue.new_req, 10ae24: 83 c4 0c add $0xc,%esp 10ae27: 57 push %edi 10ae28: 68 d8 72 12 00 push $0x1272d8 10ae2d: 68 dc 72 12 00 push $0x1272dc 10ae32: e8 d5 06 00 00 call 10b50c &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 10ae37: 83 c4 10 add $0x10,%esp 10ae3a: 83 f8 74 cmp $0x74,%eax 10ae3d: 75 18 jne 10ae57 <== NEVER TAKEN AIO_printf ("Etimeout\n"); --aio_request_queue.idle_threads; 10ae3f: ff 0d 40 73 12 00 decl 0x127340 pthread_mutex_unlock (&aio_request_queue.mutex); 10ae45: 83 ec 0c sub $0xc,%esp 10ae48: 68 d8 72 12 00 push $0x1272d8 10ae4d: e8 8e 0a 00 00 call 10b8e0 return NULL; 10ae52: 83 c4 10 add $0x10,%esp 10ae55: eb 3b jmp 10ae92 } } /* Otherwise move this chain to the working chain and start the loop all over again */ AIO_printf ("Work on idle\n"); --aio_request_queue.idle_threads; 10ae57: ff 0d 40 73 12 00 decl 0x127340 ++aio_request_queue.active_threads; 10ae5d: ff 05 3c 73 12 00 incl 0x12733c } } AIO_printf ("Thread finished\n"); return NULL; } 10ae63: 8b 1d 2c 73 12 00 mov 0x12732c,%ebx 10ae69: 83 ec 0c sub $0xc,%esp 10ae6c: 53 push %ebx 10ae6d: e8 4e 21 00 00 call 10cfc0 <_Chain_Extract> node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = (rtems_aio_request_chain *) node; rtems_aio_move_to_work (r_chain); 10ae72: 89 1c 24 mov %ebx,(%esp) 10ae75: e8 cd fd ff ff call 10ac47 10ae7a: 83 c4 10 add $0x10,%esp } } /* 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); 10ae7d: 83 ec 0c sub $0xc,%esp 10ae80: 68 d8 72 12 00 push $0x1272d8 10ae85: e8 56 0a 00 00 call 10b8e0 10ae8a: 83 c4 10 add $0x10,%esp 10ae8d: e9 f5 fd ff ff jmp 10ac87 } } AIO_printf ("Thread finished\n"); return NULL; } 10ae92: 31 c0 xor %eax,%eax 10ae94: 8d 65 f4 lea -0xc(%ebp),%esp 10ae97: 5b pop %ebx 10ae98: 5e pop %esi 10ae99: 5f pop %edi 10ae9a: c9 leave 10ae9b: c3 ret =============================================================================== 0010aaa0 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10aaa0: 55 push %ebp 10aaa1: 89 e5 mov %esp,%ebp 10aaa3: 53 push %ebx 10aaa4: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10aaa7: 68 e0 72 12 00 push $0x1272e0 10aaac: e8 33 0f 00 00 call 10b9e4 10aab1: 89 c3 mov %eax,%ebx if (result != 0) 10aab3: 83 c4 10 add $0x10,%esp 10aab6: 85 c0 test %eax,%eax 10aab8: 0f 85 d7 00 00 00 jne 10ab95 <== NEVER TAKEN return result; result = 10aabe: 51 push %ecx 10aabf: 51 push %ecx 10aac0: 6a 00 push $0x0 10aac2: 68 e0 72 12 00 push $0x1272e0 10aac7: e8 40 0f 00 00 call 10ba0c pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10aacc: 83 c4 10 add $0x10,%esp 10aacf: 85 c0 test %eax,%eax 10aad1: 74 10 je 10aae3 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aad3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aad6: 68 e0 72 12 00 push $0x1272e0 <== NOT EXECUTED 10aadb: e8 e4 0e 00 00 call 10b9c4 <== NOT EXECUTED 10aae0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10aae3: 52 push %edx 10aae4: 52 push %edx 10aae5: 6a 00 push $0x0 10aae7: 68 d8 72 12 00 push $0x1272d8 10aaec: e8 4f 0c 00 00 call 10b740 if (result != 0) 10aaf1: 83 c4 10 add $0x10,%esp 10aaf4: 85 c0 test %eax,%eax 10aaf6: 74 10 je 10ab08 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aaf8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aafb: 68 e0 72 12 00 push $0x1272e0 <== NOT EXECUTED 10ab00: e8 bf 0e 00 00 call 10b9c4 <== NOT EXECUTED 10ab05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10ab08: 50 push %eax 10ab09: 50 push %eax 10ab0a: 6a 00 push $0x0 10ab0c: 68 dc 72 12 00 push $0x1272dc 10ab11: e8 ea 08 00 00 call 10b400 10ab16: 89 c3 mov %eax,%ebx if (result != 0) { 10ab18: 83 c4 10 add $0x10,%esp 10ab1b: 85 c0 test %eax,%eax 10ab1d: 74 1c je 10ab3b <== ALWAYS TAKEN pthread_mutex_destroy (&aio_request_queue.mutex); 10ab1f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab22: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED 10ab27: e8 14 0b 00 00 call 10b640 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10ab2c: c7 04 24 e0 72 12 00 movl $0x1272e0,(%esp) <== NOT EXECUTED 10ab33: e8 8c 0e 00 00 call 10b9c4 <== NOT EXECUTED 10ab38: 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; 10ab3b: c7 05 20 73 12 00 24 movl $0x127324,0x127320 10ab42: 73 12 00 head->previous = NULL; 10ab45: c7 05 24 73 12 00 00 movl $0x0,0x127324 10ab4c: 00 00 00 tail->previous = head; 10ab4f: c7 05 28 73 12 00 20 movl $0x127320,0x127328 10ab56: 73 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10ab59: c7 05 2c 73 12 00 30 movl $0x127330,0x12732c 10ab60: 73 12 00 head->previous = NULL; 10ab63: c7 05 30 73 12 00 00 movl $0x0,0x127330 10ab6a: 00 00 00 tail->previous = head; 10ab6d: c7 05 34 73 12 00 2c movl $0x12732c,0x127334 10ab74: 73 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; 10ab77: c7 05 3c 73 12 00 00 movl $0x0,0x12733c 10ab7e: 00 00 00 aio_request_queue.idle_threads = 0; 10ab81: c7 05 40 73 12 00 00 movl $0x0,0x127340 10ab88: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10ab8b: c7 05 38 73 12 00 0b movl $0xb00b,0x127338 10ab92: b0 00 00 return result; } 10ab95: 89 d8 mov %ebx,%eax 10ab97: 8b 5d fc mov -0x4(%ebp),%ebx 10ab9a: c9 leave 10ab9b: c3 ret =============================================================================== 0010ae9c : * NONE */ void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10ae9c: 55 push %ebp 10ae9d: 89 e5 mov %esp,%ebp 10ae9f: 56 push %esi 10aea0: 53 push %ebx 10aea1: 8b 4d 08 mov 0x8(%ebp),%ecx 10aea4: 8b 55 0c mov 0xc(%ebp),%edx } } AIO_printf ("Thread finished\n"); return NULL; } 10aea7: 8b 01 mov (%ecx),%eax 10aea9: 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)) { 10aeac: 39 d8 cmp %ebx,%eax 10aeae: 74 27 je 10aed7 <== 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; 10aeb0: 8b 48 14 mov 0x14(%eax),%ecx 10aeb3: 8b 49 14 mov 0x14(%ecx),%ecx while (req->aiocbp->aio_reqprio > prio && 10aeb6: 8b 72 14 mov 0x14(%edx),%esi 10aeb9: 8b 76 14 mov 0x14(%esi),%esi 10aebc: eb 08 jmp 10aec6 } } AIO_printf ("Thread finished\n"); return NULL; } 10aebe: 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; 10aec0: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10aec3: 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 && 10aec6: 39 ce cmp %ecx,%esi 10aec8: 7e 04 jle 10aece <== ALWAYS TAKEN 10aeca: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10aecc: 75 f0 jne 10aebe <== 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 ); 10aece: 89 55 0c mov %edx,0xc(%ebp) 10aed1: 8b 40 04 mov 0x4(%eax),%eax 10aed4: 89 45 08 mov %eax,0x8(%ebp) } rtems_chain_insert (node->previous, &req->next_prio); } } 10aed7: 5b pop %ebx 10aed8: 5e pop %esi 10aed9: c9 leave 10aeda: e9 1d 21 00 00 jmp 10cffc <_Chain_Insert> =============================================================================== 0010ac47 : * NONE */ void rtems_aio_move_to_work (rtems_aio_request_chain *r_chain) { 10ac47: 55 push %ebp 10ac48: 89 e5 mov %esp,%ebp 10ac4a: 83 ec 08 sub $0x8,%esp 10ac4d: 8b 55 08 mov 0x8(%ebp),%edx } } AIO_printf ("Thread finished\n"); return NULL; } 10ac50: a1 20 73 12 00 mov 0x127320,%eax rtems_chain_node *node; node = rtems_chain_first (&aio_request_queue.work_req); temp = (rtems_aio_request_chain *) node; while (temp->fildes < r_chain->fildes && 10ac55: 8b 4a 14 mov 0x14(%edx),%ecx 10ac58: eb 02 jmp 10ac5c } } AIO_printf ("Thread finished\n"); return NULL; } 10ac5a: 8b 00 mov (%eax),%eax rtems_chain_node *node; node = rtems_chain_first (&aio_request_queue.work_req); temp = (rtems_aio_request_chain *) node; while (temp->fildes < r_chain->fildes && 10ac5c: 39 48 14 cmp %ecx,0x14(%eax) 10ac5f: 7d 07 jge 10ac68 10ac61: 3d 24 73 12 00 cmp $0x127324,%eax 10ac66: 75 f2 jne 10ac5a <== ALWAYS TAKEN 10ac68: 51 push %ecx 10ac69: 51 push %ecx 10ac6a: 52 push %edx 10ac6b: ff 70 04 pushl 0x4(%eax) 10ac6e: e8 89 23 00 00 call 10cffc <_Chain_Insert> 10ac73: 83 c4 10 add $0x10,%esp node = rtems_chain_next (node); temp = (rtems_aio_request_chain *) node; } rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd); } 10ac76: c9 leave 10ac77: c3 ret =============================================================================== 0010af28 : * 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) { 10af28: 55 push %ebp 10af29: 89 e5 mov %esp,%ebp 10af2b: 53 push %ebx 10af2c: 83 ec 04 sub $0x4,%esp 10af2f: 8b 55 08 mov 0x8(%ebp),%edx 10af32: 8b 4d 0c mov 0xc(%ebp),%ecx } } AIO_printf ("Thread finished\n"); return NULL; } 10af35: 8b 1a mov (%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 ); 10af37: 83 c2 04 add $0x4,%edx */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { if (rtems_chain_is_empty (chain)) return AIO_ALLDONE; 10af3a: b8 02 00 00 00 mov $0x2,%eax * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { if (rtems_chain_is_empty (chain)) 10af3f: 39 d3 cmp %edx,%ebx 10af41: 75 08 jne 10af4b 10af43: eb 3b jmp 10af80 } } AIO_printf ("Thread finished\n"); return NULL; } 10af45: 8b 18 mov (%eax),%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) { 10af47: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10af49: 74 30 je 10af7b <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; 10af4b: 89 d8 mov %ebx,%eax 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) { 10af4d: 39 4b 14 cmp %ecx,0x14(%ebx) 10af50: 75 f3 jne 10af45 <== NEVER TAKEN 10af52: 83 ec 0c sub $0xc,%esp 10af55: 53 push %ebx 10af56: e8 65 20 00 00 call 10cfc0 <_Chain_Extract> if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10af5b: 8b 43 14 mov 0x14(%ebx),%eax 10af5e: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) current->aiocbp->return_value = -1; 10af65: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (current); 10af6c: 89 1c 24 mov %ebx,(%esp) 10af6f: e8 fc cd ff ff call 107d70 } return AIO_CANCELED; 10af74: 83 c4 10 add $0x10,%esp 10af77: 31 c0 xor %eax,%eax 10af79: eb 05 jmp 10af80 node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10af7b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10af80: 8b 5d fc mov -0x4(%ebp),%ebx 10af83: c9 leave 10af84: c3 ret =============================================================================== 0010acc8 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10acc8: 55 push %ebp 10acc9: 89 e5 mov %esp,%ebp 10accb: 57 push %edi 10accc: 56 push %esi 10accd: 53 push %ebx 10acce: 83 ec 1c sub $0x1c,%esp 10acd1: 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( 10acd4: 8d 75 e4 lea -0x1c(%ebp),%esi 10acd7: eb 13 jmp 10acec 10acd9: 56 push %esi 10acda: ff 75 10 pushl 0x10(%ebp) 10acdd: 6a 00 push $0x0 10acdf: 57 push %edi 10ace0: e8 0f f5 ff ff call 10a1f4 ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10ace5: 83 c4 10 add $0x10,%esp 10ace8: 85 c0 test %eax,%eax 10acea: 75 16 jne 10ad02 <== ALWAYS TAKEN */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10acec: 83 ec 0c sub $0xc,%esp 10acef: ff 75 08 pushl 0x8(%ebp) 10acf2: e8 a5 04 00 00 call 10b19c <_Chain_Get> 10acf7: 89 c3 mov %eax,%ebx sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10acf9: 83 c4 10 add $0x10,%esp 10acfc: 85 c0 test %eax,%eax 10acfe: 74 d9 je 10acd9 10ad00: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10ad02: 8b 55 14 mov 0x14(%ebp),%edx 10ad05: 89 1a mov %ebx,(%edx) return sc; } 10ad07: 8d 65 f4 lea -0xc(%ebp),%esp 10ad0a: 5b pop %ebx 10ad0b: 5e pop %esi 10ad0c: 5f pop %edi 10ad0d: c9 leave 10ad0e: c3 ret =============================================================================== 0010c7b4 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c7b4: 55 push %ebp 10c7b5: 89 e5 mov %esp,%ebp 10c7b7: 57 push %edi 10c7b8: 56 push %esi 10c7b9: 53 push %ebx 10c7ba: 83 ec 0c sub $0xc,%esp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c7bd: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10c7c1: 74 3d je 10c800 <== NEVER TAKEN 10c7c3: 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 ]; 10c7c8: 8b 04 9d 9c 90 12 00 mov 0x12909c(,%ebx,4),%eax 10c7cf: 8b 78 04 mov 0x4(%eax),%edi if ( !information ) 10c7d2: be 01 00 00 00 mov $0x1,%esi 10c7d7: 85 ff test %edi,%edi 10c7d9: 75 17 jne 10c7f2 10c7db: eb 1d jmp 10c7fa continue; for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10c7dd: 8b 47 1c mov 0x1c(%edi),%eax 10c7e0: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !the_thread ) 10c7e3: 85 c0 test %eax,%eax 10c7e5: 74 0a je 10c7f1 <== NEVER TAKEN continue; (*routine)(the_thread); 10c7e7: 83 ec 0c sub $0xc,%esp 10c7ea: 50 push %eax 10c7eb: ff 55 08 call *0x8(%ebp) 10c7ee: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10c7f1: 46 inc %esi 10c7f2: 0f b7 47 10 movzwl 0x10(%edi),%eax 10c7f6: 39 c6 cmp %eax,%esi 10c7f8: 76 e3 jbe 10c7dd Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c7fa: 43 inc %ebx 10c7fb: 83 fb 04 cmp $0x4,%ebx 10c7fe: 75 c8 jne 10c7c8 (*routine)(the_thread); } } } 10c800: 8d 65 f4 lea -0xc(%ebp),%esp 10c803: 5b pop %ebx 10c804: 5e pop %esi 10c805: 5f pop %edi 10c806: c9 leave 10c807: c3 ret =============================================================================== 001148e0 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 1148e0: 55 push %ebp 1148e1: 89 e5 mov %esp,%ebp 1148e3: 57 push %edi 1148e4: 56 push %esi 1148e5: 53 push %ebx 1148e6: 83 ec 1c sub $0x1c,%esp 1148e9: 8b 75 0c mov 0xc(%ebp),%esi 1148ec: 8b 55 10 mov 0x10(%ebp),%edx 1148ef: 8b 7d 14 mov 0x14(%ebp),%edi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 1148f2: b8 03 00 00 00 mov $0x3,%eax rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 1148f7: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 1148fb: 0f 84 ce 00 00 00 je 1149cf return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 114901: b0 09 mov $0x9,%al register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) 114903: 85 f6 test %esi,%esi 114905: 0f 84 c4 00 00 00 je 1149cf return RTEMS_INVALID_ADDRESS; if ( !id ) 11490b: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 11490f: 0f 84 ba 00 00 00 je 1149cf <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 114915: 85 ff test %edi,%edi 114917: 0f 84 ad 00 00 00 je 1149ca 11491d: 85 d2 test %edx,%edx 11491f: 0f 84 a5 00 00 00 je 1149ca !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 114925: b0 08 mov $0x8,%al return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 114927: 39 fa cmp %edi,%edx 114929: 0f 82 a0 00 00 00 jb 1149cf 11492f: f7 c7 03 00 00 00 test $0x3,%edi 114935: 0f 85 94 00 00 00 jne 1149cf !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; 11493b: 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 ) ) 11493d: f7 c6 03 00 00 00 test $0x3,%esi 114943: 0f 85 86 00 00 00 jne 1149cf 114949: a1 d4 f0 13 00 mov 0x13f0d4,%eax 11494e: 40 inc %eax 11494f: a3 d4 f0 13 00 mov %eax,0x13f0d4 * 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 ); 114954: 83 ec 0c sub $0xc,%esp 114957: 68 64 ef 13 00 push $0x13ef64 11495c: 89 55 e4 mov %edx,-0x1c(%ebp) 11495f: e8 20 3e 00 00 call 118784 <_Objects_Allocate> 114964: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 114966: 83 c4 10 add $0x10,%esp 114969: 85 c0 test %eax,%eax 11496b: 8b 55 e4 mov -0x1c(%ebp),%edx 11496e: 75 0c jne 11497c _Thread_Enable_dispatch(); 114970: e8 29 4d 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 114975: b8 05 00 00 00 mov $0x5,%eax 11497a: eb 53 jmp 1149cf _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 11497c: 89 70 10 mov %esi,0x10(%eax) the_partition->length = length; 11497f: 89 50 14 mov %edx,0x14(%eax) the_partition->buffer_size = buffer_size; 114982: 89 78 18 mov %edi,0x18(%eax) the_partition->attribute_set = attribute_set; 114985: 8b 45 18 mov 0x18(%ebp),%eax 114988: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 11498b: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 114992: 57 push %edi 114993: 89 d0 mov %edx,%eax 114995: 31 d2 xor %edx,%edx 114997: f7 f7 div %edi 114999: 50 push %eax 11499a: 56 push %esi 11499b: 8d 43 24 lea 0x24(%ebx),%eax 11499e: 50 push %eax 11499f: e8 84 2a 00 00 call 117428 <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1149a4: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1149a7: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1149aa: 8b 15 80 ef 13 00 mov 0x13ef80,%edx 1149b0: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1149b3: 8b 55 08 mov 0x8(%ebp),%edx 1149b6: 89 53 0c mov %edx,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 1149b9: 8b 55 1c mov 0x1c(%ebp),%edx 1149bc: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1149be: e8 db 4c 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1149c3: 83 c4 10 add $0x10,%esp 1149c6: 31 c0 xor %eax,%eax 1149c8: eb 05 jmp 1149cf 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; 1149ca: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1149cf: 8d 65 f4 lea -0xc(%ebp),%esp 1149d2: 5b pop %ebx 1149d3: 5e pop %esi 1149d4: 5f pop %edi 1149d5: c9 leave 1149d6: c3 ret =============================================================================== 0010b085 : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 10b085: 55 push %ebp 10b086: 89 e5 mov %esp,%ebp 10b088: 57 push %edi 10b089: 56 push %esi 10b08a: 53 push %ebx 10b08b: 83 ec 30 sub $0x30,%esp 10b08e: 8b 75 08 mov 0x8(%ebp),%esi 10b091: 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 ); 10b094: 8d 45 e4 lea -0x1c(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 10b097: 50 push %eax 10b098: 56 push %esi 10b099: 68 74 83 12 00 push $0x128374 10b09e: e8 39 1e 00 00 call 10cedc <_Objects_Get> 10b0a3: 89 c7 mov %eax,%edi switch ( location ) { 10b0a5: 83 c4 10 add $0x10,%esp 10b0a8: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b0ac: 0f 85 3b 01 00 00 jne 10b1ed case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10b0b2: a1 8c 89 12 00 mov 0x12898c,%eax 10b0b7: 39 47 40 cmp %eax,0x40(%edi) 10b0ba: 74 0f je 10b0cb _Thread_Enable_dispatch(); 10b0bc: e8 cd 28 00 00 call 10d98e <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 10b0c1: be 17 00 00 00 mov $0x17,%esi 10b0c6: e9 27 01 00 00 jmp 10b1f2 } if ( length == RTEMS_PERIOD_STATUS ) { 10b0cb: 85 db test %ebx,%ebx 10b0cd: 75 1b jne 10b0ea switch ( the_period->state ) { 10b0cf: 8b 47 38 mov 0x38(%edi),%eax 10b0d2: 31 f6 xor %esi,%esi 10b0d4: 83 f8 04 cmp $0x4,%eax 10b0d7: 77 07 ja 10b0e0 <== NEVER TAKEN 10b0d9: 8b 34 85 8c 16 12 00 mov 0x12168c(,%eax,4),%esi case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10b0e0: e8 a9 28 00 00 call 10d98e <_Thread_Enable_dispatch> return( return_value ); 10b0e5: e9 08 01 00 00 jmp 10b1f2 } _ISR_Disable( level ); 10b0ea: 9c pushf 10b0eb: fa cli 10b0ec: 8f 45 d4 popl -0x2c(%ebp) if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 10b0ef: 8b 47 38 mov 0x38(%edi),%eax 10b0f2: 85 c0 test %eax,%eax 10b0f4: 75 4c jne 10b142 _ISR_Enable( level ); 10b0f6: ff 75 d4 pushl -0x2c(%ebp) 10b0f9: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10b0fa: 83 ec 0c sub $0xc,%esp 10b0fd: 57 push %edi 10b0fe: e8 3f fe ff ff call 10af42 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10b103: 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; 10b10a: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10b111: c7 47 2c fc b3 10 00 movl $0x10b3fc,0x2c(%edi) the_watchdog->id = id; 10b118: 89 77 30 mov %esi,0x30(%edi) the_watchdog->user_data = user_data; 10b11b: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10b122: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b125: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b128: 58 pop %eax 10b129: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b12a: 83 c7 10 add $0x10,%edi 10b12d: 57 push %edi 10b12e: 68 28 85 12 00 push $0x128528 10b133: e8 68 35 00 00 call 10e6a0 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b138: e8 51 28 00 00 call 10d98e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b13d: 83 c4 10 add $0x10,%esp 10b140: eb 65 jmp 10b1a7 } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 10b142: 83 f8 02 cmp $0x2,%eax 10b145: 75 64 jne 10b1ab /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10b147: 83 ec 0c sub $0xc,%esp 10b14a: 57 push %edi 10b14b: e8 5a fe ff ff call 10afaa <_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; 10b150: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) the_period->next_length = length; 10b157: 89 5f 3c mov %ebx,0x3c(%edi) _ISR_Enable( level ); 10b15a: ff 75 d4 pushl -0x2c(%ebp) 10b15d: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10b15e: a1 8c 89 12 00 mov 0x12898c,%eax 10b163: 8b 57 08 mov 0x8(%edi),%edx 10b166: 89 50 20 mov %edx,0x20(%eax) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b169: 5b pop %ebx 10b16a: 5e pop %esi 10b16b: 68 00 40 00 00 push $0x4000 10b170: 50 push %eax 10b171: e8 8a 2f 00 00 call 10e100 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10b176: 9c pushf 10b177: fa cli 10b178: 5a pop %edx local_state = the_period->state; 10b179: 8b 47 38 mov 0x38(%edi),%eax the_period->state = RATE_MONOTONIC_ACTIVE; 10b17c: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) _ISR_Enable( level ); 10b183: 52 push %edx 10b184: 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 ) 10b185: 83 c4 10 add $0x10,%esp 10b188: 83 f8 03 cmp $0x3,%eax 10b18b: 75 15 jne 10b1a2 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b18d: 51 push %ecx 10b18e: 51 push %ecx 10b18f: 68 00 40 00 00 push $0x4000 10b194: ff 35 8c 89 12 00 pushl 0x12898c 10b19a: e8 d9 24 00 00 call 10d678 <_Thread_Clear_state> 10b19f: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 10b1a2: e8 e7 27 00 00 call 10d98e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b1a7: 31 f6 xor %esi,%esi 10b1a9: eb 47 jmp 10b1f2 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b1ab: be 04 00 00 00 mov $0x4,%esi _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 10b1b0: 83 f8 04 cmp $0x4,%eax 10b1b3: 75 3d jne 10b1f2 <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10b1b5: 83 ec 0c sub $0xc,%esp 10b1b8: 57 push %edi 10b1b9: e8 ec fd ff ff call 10afaa <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10b1be: ff 75 d4 pushl -0x2c(%ebp) 10b1c1: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10b1c2: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) the_period->next_length = length; 10b1c9: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b1cc: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b1cf: 58 pop %eax 10b1d0: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b1d1: 83 c7 10 add $0x10,%edi 10b1d4: 57 push %edi 10b1d5: 68 28 85 12 00 push $0x128528 10b1da: e8 c1 34 00 00 call 10e6a0 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b1df: e8 aa 27 00 00 call 10d98e <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 10b1e4: 83 c4 10 add $0x10,%esp 10b1e7: 66 be 06 00 mov $0x6,%si 10b1eb: eb 05 jmp 10b1f2 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b1ed: be 04 00 00 00 mov $0x4,%esi } 10b1f2: 89 f0 mov %esi,%eax 10b1f4: 8d 65 f4 lea -0xc(%ebp),%esp 10b1f7: 5b pop %ebx 10b1f8: 5e pop %esi 10b1f9: 5f pop %edi 10b1fa: c9 leave 10b1fb: c3 ret =============================================================================== 0010b1fc : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 10b1fc: 55 push %ebp 10b1fd: 89 e5 mov %esp,%ebp 10b1ff: 57 push %edi 10b200: 56 push %esi 10b201: 53 push %ebx 10b202: 83 ec 7c sub $0x7c,%esp 10b205: 8b 5d 08 mov 0x8(%ebp),%ebx 10b208: 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 ) 10b20b: 85 ff test %edi,%edi 10b20d: 0f 84 2b 01 00 00 je 10b33e <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10b213: 52 push %edx 10b214: 52 push %edx 10b215: 68 a0 16 12 00 push $0x1216a0 10b21a: 53 push %ebx 10b21b: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 10b21d: 5e pop %esi 10b21e: 58 pop %eax 10b21f: 68 be 16 12 00 push $0x1216be 10b224: 53 push %ebx 10b225: ff d7 call *%edi (*print)( context, "--- Wall times are in seconds ---\n" ); 10b227: 5a pop %edx 10b228: 59 pop %ecx 10b229: 68 e0 16 12 00 push $0x1216e0 10b22e: 53 push %ebx 10b22f: ff d7 call *%edi Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10b231: 5e pop %esi 10b232: 58 pop %eax 10b233: 68 03 17 12 00 push $0x121703 10b238: 53 push %ebx 10b239: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 10b23b: 5a pop %edx 10b23c: 59 pop %ecx 10b23d: 68 4e 17 12 00 push $0x12174e 10b242: 53 push %ebx 10b243: 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 ; 10b245: 8b 35 7c 83 12 00 mov 0x12837c,%esi 10b24b: 83 c4 10 add $0x10,%esp 10b24e: e9 df 00 00 00 jmp 10b332 id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10b253: 50 push %eax 10b254: 50 push %eax 10b255: 8d 45 88 lea -0x78(%ebp),%eax 10b258: 50 push %eax 10b259: 56 push %esi 10b25a: e8 c1 56 00 00 call 110920 if ( status != RTEMS_SUCCESSFUL ) 10b25f: 83 c4 10 add $0x10,%esp 10b262: 85 c0 test %eax,%eax 10b264: 0f 85 c7 00 00 00 jne 10b331 #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 ); 10b26a: 51 push %ecx 10b26b: 51 push %ecx 10b26c: 8d 55 c0 lea -0x40(%ebp),%edx 10b26f: 52 push %edx 10b270: 56 push %esi 10b271: e8 4e 57 00 00 call 1109c4 #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 10b276: 83 c4 0c add $0xc,%esp 10b279: 8d 45 e3 lea -0x1d(%ebp),%eax 10b27c: 50 push %eax 10b27d: 6a 05 push $0x5 10b27f: ff 75 c0 pushl -0x40(%ebp) 10b282: e8 01 02 00 00 call 10b488 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10b287: 58 pop %eax 10b288: 5a pop %edx 10b289: ff 75 8c pushl -0x74(%ebp) 10b28c: ff 75 88 pushl -0x78(%ebp) 10b28f: 8d 55 e3 lea -0x1d(%ebp),%edx 10b292: 52 push %edx 10b293: 56 push %esi 10b294: 68 9a 17 12 00 push $0x12179a 10b299: 53 push %ebx 10b29a: ff d7 call *%edi ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10b29c: 8b 45 88 mov -0x78(%ebp),%eax 10b29f: 83 c4 20 add $0x20,%esp 10b2a2: 85 c0 test %eax,%eax 10b2a4: 75 0f jne 10b2b5 (*print)( context, "\n" ); 10b2a6: 51 push %ecx 10b2a7: 51 push %ecx 10b2a8: 68 04 1a 12 00 push $0x121a04 10b2ad: 53 push %ebx 10b2ae: ff d7 call *%edi continue; 10b2b0: 83 c4 10 add $0x10,%esp 10b2b3: eb 7c jmp 10b331 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 ); 10b2b5: 52 push %edx 10b2b6: 8d 55 d8 lea -0x28(%ebp),%edx 10b2b9: 52 push %edx 10b2ba: 50 push %eax 10b2bb: 8d 45 a0 lea -0x60(%ebp),%eax 10b2be: 50 push %eax 10b2bf: e8 b0 30 00 00 call 10e374 <_Timespec_Divide_by_integer> (*print)( context, 10b2c4: 8b 45 dc mov -0x24(%ebp),%eax 10b2c7: b9 e8 03 00 00 mov $0x3e8,%ecx 10b2cc: 99 cltd 10b2cd: f7 f9 idiv %ecx 10b2cf: 50 push %eax 10b2d0: ff 75 d8 pushl -0x28(%ebp) 10b2d3: 8b 45 9c mov -0x64(%ebp),%eax 10b2d6: 99 cltd 10b2d7: f7 f9 idiv %ecx 10b2d9: 50 push %eax 10b2da: ff 75 98 pushl -0x68(%ebp) 10b2dd: 8b 45 94 mov -0x6c(%ebp),%eax 10b2e0: 99 cltd 10b2e1: f7 f9 idiv %ecx 10b2e3: 50 push %eax 10b2e4: ff 75 90 pushl -0x70(%ebp) 10b2e7: 68 b1 17 12 00 push $0x1217b1 10b2ec: 53 push %ebx 10b2ed: 89 4d 84 mov %ecx,-0x7c(%ebp) 10b2f0: 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); 10b2f2: 83 c4 2c add $0x2c,%esp 10b2f5: 8d 55 d8 lea -0x28(%ebp),%edx 10b2f8: 52 push %edx 10b2f9: 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; 10b2fc: 8d 45 b8 lea -0x48(%ebp),%eax _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 10b2ff: 50 push %eax 10b300: e8 6f 30 00 00 call 10e374 <_Timespec_Divide_by_integer> (*print)( context, 10b305: 8b 45 dc mov -0x24(%ebp),%eax 10b308: 8b 4d 84 mov -0x7c(%ebp),%ecx 10b30b: 99 cltd 10b30c: f7 f9 idiv %ecx 10b30e: 50 push %eax 10b30f: ff 75 d8 pushl -0x28(%ebp) 10b312: 8b 45 b4 mov -0x4c(%ebp),%eax 10b315: 99 cltd 10b316: f7 f9 idiv %ecx 10b318: 50 push %eax 10b319: ff 75 b0 pushl -0x50(%ebp) 10b31c: 8b 45 ac mov -0x54(%ebp),%eax 10b31f: 99 cltd 10b320: f7 f9 idiv %ecx 10b322: 50 push %eax 10b323: ff 75 a8 pushl -0x58(%ebp) 10b326: 68 d0 17 12 00 push $0x1217d0 10b32b: 53 push %ebx 10b32c: ff d7 call *%edi 10b32e: 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++ ) { 10b331: 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 ; 10b332: 3b 35 80 83 12 00 cmp 0x128380,%esi 10b338: 0f 86 15 ff ff ff jbe 10b253 the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10b33e: 8d 65 f4 lea -0xc(%ebp),%esp 10b341: 5b pop %ebx 10b342: 5e pop %esi 10b343: 5f pop %edi 10b344: c9 leave 10b345: c3 ret =============================================================================== 00115c40 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 115c40: 55 push %ebp 115c41: 89 e5 mov %esp,%ebp 115c43: 53 push %ebx 115c44: 83 ec 14 sub $0x14,%esp 115c47: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; 115c4a: 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 ) 115c4f: 85 db test %ebx,%ebx 115c51: 74 6d je 115cc0 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 115c53: 50 push %eax 115c54: 50 push %eax 115c55: 8d 45 f4 lea -0xc(%ebp),%eax 115c58: 50 push %eax 115c59: ff 75 08 pushl 0x8(%ebp) 115c5c: e8 5f 3a 00 00 call 1196c0 <_Thread_Get> switch ( location ) { 115c61: 83 c4 10 add $0x10,%esp 115c64: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 115c68: 75 51 jne 115cbb case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 115c6a: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 115c70: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 115c74: 74 39 je 115caf if ( asr->is_enabled ) { 115c76: 80 7a 08 00 cmpb $0x0,0x8(%edx) 115c7a: 74 22 je 115c9e rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115c7c: 9c pushf 115c7d: fa cli 115c7e: 59 pop %ecx *signal_set |= signals; 115c7f: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 115c82: 51 push %ecx 115c83: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 115c84: 83 3d 00 f6 13 00 00 cmpl $0x0,0x13f600 115c8b: 74 19 je 115ca6 115c8d: 3b 05 04 f6 13 00 cmp 0x13f604,%eax 115c93: 75 11 jne 115ca6 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 115c95: c6 05 10 f6 13 00 01 movb $0x1,0x13f610 115c9c: eb 08 jmp 115ca6 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115c9e: 9c pushf 115c9f: fa cli 115ca0: 58 pop %eax *signal_set |= signals; 115ca1: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 115ca4: 50 push %eax 115ca5: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 115ca6: e8 f3 39 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115cab: 31 c0 xor %eax,%eax 115cad: eb 11 jmp 115cc0 } _Thread_Enable_dispatch(); 115caf: e8 ea 39 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 115cb4: b8 0b 00 00 00 mov $0xb,%eax 115cb9: eb 05 jmp 115cc0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115cbb: b8 04 00 00 00 mov $0x4,%eax } 115cc0: 8b 5d fc mov -0x4(%ebp),%ebx 115cc3: c9 leave 115cc4: c3 ret =============================================================================== 00110d68 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 110d68: 55 push %ebp 110d69: 89 e5 mov %esp,%ebp 110d6b: 57 push %edi 110d6c: 56 push %esi 110d6d: 53 push %ebx 110d6e: 83 ec 1c sub $0x1c,%esp 110d71: 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; 110d74: 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 ) 110d79: 85 c9 test %ecx,%ecx 110d7b: 0f 84 fb 00 00 00 je 110e7c return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 110d81: 8b 35 68 58 12 00 mov 0x125868,%esi api = executing->API_Extensions[ THREAD_API_RTEMS ]; 110d87: 8b 9e e8 00 00 00 mov 0xe8(%esi),%ebx asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 110d8d: 80 7e 74 01 cmpb $0x1,0x74(%esi) 110d91: 19 ff sbb %edi,%edi 110d93: 81 e7 00 01 00 00 and $0x100,%edi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 110d99: 83 7e 7c 00 cmpl $0x0,0x7c(%esi) 110d9d: 74 06 je 110da5 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 110d9f: 81 cf 00 02 00 00 or $0x200,%edi old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 110da5: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 110da9: 19 d2 sbb %edx,%edx 110dab: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 110db1: 89 55 e4 mov %edx,-0x1c(%ebp) 110db4: 89 4d e0 mov %ecx,-0x20(%ebp) 110db7: e8 59 c6 ff ff call 10d415 <_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; 110dbc: 8b 55 e4 mov -0x1c(%ebp),%edx 110dbf: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 110dc1: 09 f8 or %edi,%eax 110dc3: 8b 4d e0 mov -0x20(%ebp),%ecx 110dc6: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 110dc8: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 110dcf: 74 0b je 110ddc executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 110dd1: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 110dd8: 0f 94 46 74 sete 0x74(%esi) if ( mask & RTEMS_TIMESLICE_MASK ) { 110ddc: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 110de3: 74 21 je 110e06 if ( _Modes_Is_timeslice(mode_set) ) { 110de5: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 110dec: 74 11 je 110dff executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 110dee: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 110df5: a1 10 53 12 00 mov 0x125310,%eax 110dfa: 89 46 78 mov %eax,0x78(%esi) 110dfd: eb 07 jmp 110e06 } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 110dff: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 110e06: f6 45 0c 01 testb $0x1,0xc(%ebp) 110e0a: 74 0a je 110e16 */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 110e0c: f6 45 08 01 testb $0x1,0x8(%ebp) 110e10: 74 03 je 110e15 110e12: fa cli 110e13: eb 01 jmp 110e16 110e15: fb sti /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110e16: 31 c9 xor %ecx,%ecx if ( mask & RTEMS_ASR_MASK ) { 110e18: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 110e1f: 74 2a je 110e4b * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 110e21: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 110e28: 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 ) { 110e2b: 3a 43 08 cmp 0x8(%ebx),%al 110e2e: 74 1b je 110e4b asr->is_enabled = is_asr_enabled; 110e30: 88 43 08 mov %al,0x8(%ebx) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 110e33: 9c pushf 110e34: fa cli 110e35: 58 pop %eax _signals = information->signals_pending; 110e36: 8b 53 18 mov 0x18(%ebx),%edx information->signals_pending = information->signals_posted; 110e39: 8b 4b 14 mov 0x14(%ebx),%ecx 110e3c: 89 4b 18 mov %ecx,0x18(%ebx) information->signals_posted = _signals; 110e3f: 89 53 14 mov %edx,0x14(%ebx) _ISR_Enable( _level ); 110e42: 50 push %eax 110e43: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110e44: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 110e48: 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; 110e4b: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 110e4d: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 110e54: 75 26 jne 110e7c bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 110e56: 8b 15 68 58 12 00 mov 0x125868,%edx if ( are_signals_pending || 110e5c: 84 c9 test %cl,%cl 110e5e: 75 0e jne 110e6e 110e60: 3b 15 6c 58 12 00 cmp 0x12586c,%edx 110e66: 74 14 je 110e7c (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 110e68: 80 7a 74 00 cmpb $0x0,0x74(%edx) 110e6c: 74 0e je 110e7c <== NEVER TAKEN _Thread_Dispatch_necessary = true; 110e6e: c6 05 74 58 12 00 01 movb $0x1,0x125874 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 110e75: e8 46 b2 ff ff call 10c0c0 <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 110e7a: 31 c0 xor %eax,%eax } 110e7c: 83 c4 1c add $0x1c,%esp 110e7f: 5b pop %ebx 110e80: 5e pop %esi 110e81: 5f pop %edi 110e82: c9 leave 110e83: c3 ret =============================================================================== 0010dd84 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10dd84: 55 push %ebp 10dd85: 89 e5 mov %esp,%ebp 10dd87: 56 push %esi 10dd88: 53 push %ebx 10dd89: 83 ec 10 sub $0x10,%esp 10dd8c: 8b 5d 0c mov 0xc(%ebp),%ebx 10dd8f: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd92: 85 db test %ebx,%ebx 10dd94: 74 10 je 10dda6 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 ) ); 10dd96: 0f b6 15 24 42 12 00 movzbl 0x124224,%edx !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10dd9d: b8 13 00 00 00 mov $0x13,%eax ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dda2: 39 d3 cmp %edx,%ebx 10dda4: 77 52 ja 10ddf8 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10dda6: 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 ) 10ddab: 85 f6 test %esi,%esi 10ddad: 74 49 je 10ddf8 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10ddaf: 51 push %ecx 10ddb0: 51 push %ecx 10ddb1: 8d 45 f4 lea -0xc(%ebp),%eax 10ddb4: 50 push %eax 10ddb5: ff 75 08 pushl 0x8(%ebp) 10ddb8: e8 cb 1e 00 00 call 10fc88 <_Thread_Get> switch ( location ) { 10ddbd: 83 c4 10 add $0x10,%esp 10ddc0: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10ddc4: 75 2d jne 10ddf3 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10ddc6: 8b 50 14 mov 0x14(%eax),%edx 10ddc9: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10ddcb: 85 db test %ebx,%ebx 10ddcd: 74 1b je 10ddea the_thread->real_priority = new_priority; 10ddcf: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10ddd2: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10ddd6: 74 05 je 10dddd 10ddd8: 39 58 14 cmp %ebx,0x14(%eax) 10dddb: 76 0d jbe 10ddea <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10dddd: 52 push %edx 10ddde: 6a 00 push $0x0 10dde0: 53 push %ebx 10dde1: 50 push %eax 10dde2: e8 a9 1a 00 00 call 10f890 <_Thread_Change_priority> 10dde7: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10ddea: e8 77 1e 00 00 call 10fc66 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ddef: 31 c0 xor %eax,%eax 10ddf1: eb 05 jmp 10ddf8 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10ddf3: b8 04 00 00 00 mov $0x4,%eax } 10ddf8: 8d 65 f8 lea -0x8(%ebp),%esp 10ddfb: 5b pop %ebx 10ddfc: 5e pop %esi 10ddfd: c9 leave 10ddfe: c3 ret =============================================================================== 0011648c : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 11648c: 55 push %ebp 11648d: 89 e5 mov %esp,%ebp 11648f: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 116492: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 116495: 50 push %eax 116496: ff 75 08 pushl 0x8(%ebp) 116499: 68 1c fa 13 00 push $0x13fa1c 11649e: e8 49 27 00 00 call 118bec <_Objects_Get> switch ( location ) { 1164a3: 83 c4 10 add $0x10,%esp 1164a6: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 1164aa: 75 1e jne 1164ca case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 1164ac: 83 78 38 04 cmpl $0x4,0x38(%eax) 1164b0: 74 0f je 1164c1 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 1164b2: 83 ec 0c sub $0xc,%esp 1164b5: 83 c0 10 add $0x10,%eax 1164b8: 50 push %eax 1164b9: e8 7e 41 00 00 call 11a63c <_Watchdog_Remove> 1164be: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 1164c1: e8 d8 31 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1164c6: 31 c0 xor %eax,%eax 1164c8: eb 05 jmp 1164cf #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1164ca: b8 04 00 00 00 mov $0x4,%eax } 1164cf: c9 leave 1164d0: c3 ret =============================================================================== 001168ec : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 1168ec: 55 push %ebp 1168ed: 89 e5 mov %esp,%ebp 1168ef: 57 push %edi 1168f0: 56 push %esi 1168f1: 53 push %ebx 1168f2: 83 ec 1c sub $0x1c,%esp 1168f5: 8b 7d 0c mov 0xc(%ebp),%edi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 1168f8: 8b 35 5c fa 13 00 mov 0x13fa5c,%esi if ( !timer_server ) return RTEMS_INCORRECT_STATE; 1168fe: 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 ) 116903: 85 f6 test %esi,%esi 116905: 0f 84 b1 00 00 00 je 1169bc return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 11690b: b3 0b mov $0xb,%bl Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 11690d: 80 3d e8 f0 13 00 00 cmpb $0x0,0x13f0e8 116914: 0f 84 a2 00 00 00 je 1169bc <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 11691a: b3 09 mov $0x9,%bl return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 11691c: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 116920: 0f 84 96 00 00 00 je 1169bc return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 116926: 83 ec 0c sub $0xc,%esp 116929: 57 push %edi 11692a: e8 b5 d6 ff ff call 113fe4 <_TOD_Validate> 11692f: 83 c4 10 add $0x10,%esp return RTEMS_INVALID_CLOCK; 116932: b3 14 mov $0x14,%bl return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 116934: 84 c0 test %al,%al 116936: 0f 84 80 00 00 00 je 1169bc return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 11693c: 83 ec 0c sub $0xc,%esp 11693f: 57 push %edi 116940: e8 37 d6 ff ff call 113f7c <_TOD_To_seconds> 116945: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 116947: 83 c4 10 add $0x10,%esp 11694a: 3b 05 60 f1 13 00 cmp 0x13f160,%eax 116950: 76 6a jbe 1169bc 116952: 51 push %ecx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 116953: 8d 45 e4 lea -0x1c(%ebp),%eax 116956: 50 push %eax 116957: ff 75 08 pushl 0x8(%ebp) 11695a: 68 1c fa 13 00 push $0x13fa1c 11695f: e8 88 22 00 00 call 118bec <_Objects_Get> 116964: 89 c3 mov %eax,%ebx switch ( location ) { 116966: 83 c4 10 add $0x10,%esp 116969: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 11696d: 75 48 jne 1169b7 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 11696f: 83 ec 0c sub $0xc,%esp 116972: 8d 40 10 lea 0x10(%eax),%eax 116975: 50 push %eax 116976: e8 c1 3c 00 00 call 11a63c <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 11697b: 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; 116982: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) the_watchdog->routine = routine; 116989: 8b 45 10 mov 0x10(%ebp),%eax 11698c: 89 43 2c mov %eax,0x2c(%ebx) the_watchdog->id = id; 11698f: 8b 45 08 mov 0x8(%ebp),%eax 116992: 89 43 30 mov %eax,0x30(%ebx) the_watchdog->user_data = user_data; 116995: 8b 45 14 mov 0x14(%ebp),%eax 116998: 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(); 11699b: 2b 3d 60 f1 13 00 sub 0x13f160,%edi 1169a1: 89 7b 1c mov %edi,0x1c(%ebx) (*timer_server->schedule_operation)( timer_server, the_timer ); 1169a4: 58 pop %eax 1169a5: 5a pop %edx 1169a6: 53 push %ebx 1169a7: 56 push %esi 1169a8: ff 56 04 call *0x4(%esi) _Thread_Enable_dispatch(); 1169ab: e8 ee 2c 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1169b0: 83 c4 10 add $0x10,%esp 1169b3: 31 db xor %ebx,%ebx 1169b5: eb 05 jmp 1169bc #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1169b7: bb 04 00 00 00 mov $0x4,%ebx } 1169bc: 89 d8 mov %ebx,%eax 1169be: 8d 65 f4 lea -0xc(%ebp),%esp 1169c1: 5b pop %ebx 1169c2: 5e pop %esi 1169c3: 5f pop %edi 1169c4: c9 leave 1169c5: c3 ret =============================================================================== 0010a948 : #include int sched_get_priority_max( int policy ) { 10a948: 55 push %ebp 10a949: 89 e5 mov %esp,%ebp 10a94b: 83 ec 08 sub $0x8,%esp 10a94e: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a951: 83 f9 04 cmp $0x4,%ecx 10a954: 77 0b ja 10a961 10a956: b8 01 00 00 00 mov $0x1,%eax 10a95b: d3 e0 shl %cl,%eax 10a95d: a8 17 test $0x17,%al 10a95f: 75 10 jne 10a971 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a961: e8 e2 73 00 00 call 111d48 <__errno> 10a966: c7 00 16 00 00 00 movl $0x16,(%eax) 10a96c: 83 c8 ff or $0xffffffff,%eax 10a96f: eb 08 jmp 10a979 } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 10a971: 0f b6 05 48 22 12 00 movzbl 0x122248,%eax 10a978: 48 dec %eax } 10a979: c9 leave 10a97a: c3 ret =============================================================================== 0010a97c : #include int sched_get_priority_min( int policy ) { 10a97c: 55 push %ebp 10a97d: 89 e5 mov %esp,%ebp 10a97f: 83 ec 08 sub $0x8,%esp 10a982: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a985: 83 f9 04 cmp $0x4,%ecx 10a988: 77 11 ja 10a99b 10a98a: ba 01 00 00 00 mov $0x1,%edx 10a98f: d3 e2 shl %cl,%edx default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; 10a991: b8 01 00 00 00 mov $0x1,%eax int sched_get_priority_min( int policy ) { switch ( policy ) { 10a996: 80 e2 17 and $0x17,%dl 10a999: 75 0e jne 10a9a9 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a99b: e8 a8 73 00 00 call 111d48 <__errno> 10a9a0: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9a6: 83 c8 ff or $0xffffffff,%eax } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10a9a9: c9 leave 10a9aa: c3 ret =============================================================================== 0010a9ac : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10a9ac: 55 push %ebp 10a9ad: 89 e5 mov %esp,%ebp 10a9af: 56 push %esi 10a9b0: 53 push %ebx 10a9b1: 8b 75 08 mov 0x8(%ebp),%esi 10a9b4: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10a9b7: 85 f6 test %esi,%esi 10a9b9: 74 16 je 10a9d1 <== NEVER TAKEN 10a9bb: e8 90 d0 ff ff call 107a50 10a9c0: 39 c6 cmp %eax,%esi 10a9c2: 74 0d je 10a9d1 rtems_set_errno_and_return_minus_one( ESRCH ); 10a9c4: e8 7f 73 00 00 call 111d48 <__errno> 10a9c9: c7 00 03 00 00 00 movl $0x3,(%eax) 10a9cf: eb 0f jmp 10a9e0 if ( !interval ) 10a9d1: 85 db test %ebx,%ebx 10a9d3: 75 10 jne 10a9e5 rtems_set_errno_and_return_minus_one( EINVAL ); 10a9d5: e8 6e 73 00 00 call 111d48 <__errno> 10a9da: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9e0: 83 c8 ff or $0xffffffff,%eax 10a9e3: eb 13 jmp 10a9f8 _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10a9e5: 50 push %eax 10a9e6: 50 push %eax 10a9e7: 53 push %ebx 10a9e8: ff 35 20 63 12 00 pushl 0x126320 10a9ee: e8 b9 30 00 00 call 10daac <_Timespec_From_ticks> return 0; 10a9f3: 83 c4 10 add $0x10,%esp 10a9f6: 31 c0 xor %eax,%eax } 10a9f8: 8d 65 f8 lea -0x8(%ebp),%esp 10a9fb: 5b pop %ebx 10a9fc: 5e pop %esi 10a9fd: c9 leave 10a9fe: c3 ret =============================================================================== 0010d088 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10d088: 55 push %ebp 10d089: 89 e5 mov %esp,%ebp 10d08b: 57 push %edi 10d08c: 56 push %esi 10d08d: 53 push %ebx 10d08e: 83 ec 2c sub $0x2c,%esp 10d091: 8b 75 08 mov 0x8(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10d094: a1 a8 af 12 00 mov 0x12afa8,%eax 10d099: 40 inc %eax 10d09a: a3 a8 af 12 00 mov %eax,0x12afa8 va_list arg; mode_t mode; unsigned int value = 0; 10d09f: 31 ff xor %edi,%edi POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10d0a1: 8b 45 0c mov 0xc(%ebp),%eax 10d0a4: 25 00 02 00 00 and $0x200,%eax 10d0a9: 89 45 d4 mov %eax,-0x2c(%ebp) 10d0ac: 74 03 je 10d0b1 va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10d0ae: 8b 7d 14 mov 0x14(%ebp),%edi va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10d0b1: 52 push %edx 10d0b2: 52 push %edx 10d0b3: 8d 45 e4 lea -0x1c(%ebp),%eax 10d0b6: 50 push %eax 10d0b7: 56 push %esi 10d0b8: e8 b3 59 00 00 call 112a70 <_POSIX_Semaphore_Name_to_id> 10d0bd: 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 ) { 10d0bf: 83 c4 10 add $0x10,%esp 10d0c2: 85 c0 test %eax,%eax 10d0c4: 74 19 je 10d0df /* * 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) ) ) { 10d0c6: 83 f8 02 cmp $0x2,%eax 10d0c9: 75 06 jne 10d0d1 <== NEVER TAKEN 10d0cb: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10d0cf: 75 59 jne 10d12a _Thread_Enable_dispatch(); 10d0d1: e8 3c 28 00 00 call 10f912 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10d0d6: e8 69 7f 00 00 call 115044 <__errno> 10d0db: 89 18 mov %ebx,(%eax) 10d0dd: eb 1f jmp 10d0fe /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10d0df: 8b 45 0c mov 0xc(%ebp),%eax 10d0e2: 25 00 0a 00 00 and $0xa00,%eax 10d0e7: 3d 00 0a 00 00 cmp $0xa00,%eax 10d0ec: 75 15 jne 10d103 _Thread_Enable_dispatch(); 10d0ee: e8 1f 28 00 00 call 10f912 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10d0f3: e8 4c 7f 00 00 call 115044 <__errno> 10d0f8: c7 00 11 00 00 00 movl $0x11,(%eax) 10d0fe: 83 c8 ff or $0xffffffff,%eax 10d101: eb 4a jmp 10d14d 10d103: 50 push %eax } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10d104: 8d 45 dc lea -0x24(%ebp),%eax 10d107: 50 push %eax 10d108: ff 75 e4 pushl -0x1c(%ebp) 10d10b: 68 4c b2 12 00 push $0x12b24c 10d110: e8 d7 1c 00 00 call 10edec <_Objects_Get> 10d115: 89 45 e0 mov %eax,-0x20(%ebp) the_semaphore->open_count += 1; 10d118: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10d11b: e8 f2 27 00 00 call 10f912 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10d120: e8 ed 27 00 00 call 10f912 <_Thread_Enable_dispatch> goto return_id; 10d125: 83 c4 10 add $0x10,%esp 10d128: eb 1d jmp 10d147 /* * 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( 10d12a: 8d 45 e0 lea -0x20(%ebp),%eax 10d12d: 50 push %eax 10d12e: 57 push %edi 10d12f: 6a 00 push $0x0 10d131: 56 push %esi 10d132: e8 05 58 00 00 call 11293c <_POSIX_Semaphore_Create_support> 10d137: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10d139: e8 d4 27 00 00 call 10f912 <_Thread_Enable_dispatch> if ( status == -1 ) 10d13e: 83 c4 10 add $0x10,%esp return SEM_FAILED; 10d141: 83 c8 ff or $0xffffffff,%eax * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 10d144: 43 inc %ebx 10d145: 74 06 je 10d14d 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; 10d147: 8b 45 e0 mov -0x20(%ebp),%eax 10d14a: 83 c0 08 add $0x8,%eax #endif return id; } 10d14d: 8d 65 f4 lea -0xc(%ebp),%esp 10d150: 5b pop %ebx 10d151: 5e pop %esi 10d152: 5f pop %edi 10d153: c9 leave 10d154: c3 ret =============================================================================== 0010a820 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10a820: 55 push %ebp 10a821: 89 e5 mov %esp,%ebp 10a823: 57 push %edi 10a824: 56 push %esi 10a825: 53 push %ebx 10a826: 83 ec 1c sub $0x1c,%esp 10a829: 8b 5d 08 mov 0x8(%ebp),%ebx 10a82c: 8b 55 0c mov 0xc(%ebp),%edx 10a82f: 8b 45 10 mov 0x10(%ebp),%eax ISR_Level level; if ( oact ) 10a832: 85 c0 test %eax,%eax 10a834: 74 12 je 10a848 *oact = _POSIX_signals_Vectors[ sig ]; 10a836: 6b f3 0c imul $0xc,%ebx,%esi 10a839: 81 c6 fc 78 12 00 add $0x1278fc,%esi 10a83f: b9 03 00 00 00 mov $0x3,%ecx 10a844: 89 c7 mov %eax,%edi 10a846: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10a848: 85 db test %ebx,%ebx 10a84a: 74 0d je 10a859 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a84c: 8d 43 ff lea -0x1(%ebx),%eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10a84f: 83 f8 1f cmp $0x1f,%eax 10a852: 77 05 ja 10a859 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10a854: 83 fb 09 cmp $0x9,%ebx 10a857: 75 10 jne 10a869 rtems_set_errno_and_return_minus_one( EINVAL ); 10a859: e8 6e 77 00 00 call 111fcc <__errno> 10a85e: c7 00 16 00 00 00 movl $0x16,(%eax) 10a864: 83 c8 ff or $0xffffffff,%eax 10a867: eb 57 jmp 10a8c0 * 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; 10a869: 31 c0 xor %eax,%eax /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10a86b: 85 d2 test %edx,%edx 10a86d: 74 51 je 10a8c0 <== 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 ); 10a86f: 9c pushf 10a870: fa cli 10a871: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10a874: 83 7a 08 00 cmpl $0x0,0x8(%edx) 10a878: 75 1a jne 10a894 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10a87a: 6b f3 0c imul $0xc,%ebx,%esi 10a87d: 8d 86 fc 78 12 00 lea 0x1278fc(%esi),%eax 10a883: 81 c6 70 12 12 00 add $0x121270,%esi 10a889: b9 03 00 00 00 mov $0x3,%ecx 10a88e: 89 c7 mov %eax,%edi 10a890: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a892: eb 26 jmp 10a8ba } else { _POSIX_signals_Clear_process_signals( sig ); 10a894: 83 ec 0c sub $0xc,%esp 10a897: 53 push %ebx 10a898: 89 55 e0 mov %edx,-0x20(%ebp) 10a89b: e8 bc 4e 00 00 call 10f75c <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10a8a0: 6b db 0c imul $0xc,%ebx,%ebx 10a8a3: 81 c3 fc 78 12 00 add $0x1278fc,%ebx 10a8a9: b9 03 00 00 00 mov $0x3,%ecx 10a8ae: 8b 55 e0 mov -0x20(%ebp),%edx 10a8b1: 89 df mov %ebx,%edi 10a8b3: 89 d6 mov %edx,%esi 10a8b5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a8b7: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10a8ba: ff 75 e4 pushl -0x1c(%ebp) 10a8bd: 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; 10a8be: 31 c0 xor %eax,%eax } 10a8c0: 8d 65 f4 lea -0xc(%ebp),%esp 10a8c3: 5b pop %ebx 10a8c4: 5e pop %esi 10a8c5: 5f pop %edi 10a8c6: c9 leave 10a8c7: c3 ret =============================================================================== 0010abe7 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10abe7: 55 push %ebp 10abe8: 89 e5 mov %esp,%ebp 10abea: 57 push %edi 10abeb: 56 push %esi 10abec: 53 push %ebx 10abed: 83 ec 3c sub $0x3c,%esp 10abf0: 8b 75 08 mov 0x8(%ebp),%esi 10abf3: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10abf6: 85 f6 test %esi,%esi 10abf8: 74 24 je 10ac1e /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10abfa: 85 db test %ebx,%ebx 10abfc: 74 30 je 10ac2e if ( !_Timespec_Is_valid( timeout ) ) 10abfe: 83 ec 0c sub $0xc,%esp 10ac01: 53 push %ebx 10ac02: e8 5d 31 00 00 call 10dd64 <_Timespec_Is_valid> 10ac07: 83 c4 10 add $0x10,%esp 10ac0a: 84 c0 test %al,%al 10ac0c: 74 10 je 10ac1e rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10ac0e: 83 ec 0c sub $0xc,%esp 10ac11: 53 push %ebx 10ac12: e8 a5 31 00 00 call 10ddbc <_Timespec_To_ticks> if ( !interval ) 10ac17: 83 c4 10 add $0x10,%esp 10ac1a: 85 c0 test %eax,%eax 10ac1c: 75 12 jne 10ac30 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10ac1e: e8 51 79 00 00 call 112574 <__errno> 10ac23: c7 00 16 00 00 00 movl $0x16,(%eax) 10ac29: e9 39 01 00 00 jmp 10ad67 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; 10ac2e: 31 c0 xor %eax,%eax /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10ac30: 8b 7d 0c mov 0xc(%ebp),%edi 10ac33: 85 ff test %edi,%edi 10ac35: 75 03 jne 10ac3a 10ac37: 8d 7d dc lea -0x24(%ebp),%edi the_thread = _Thread_Executing; 10ac3a: 8b 15 c8 78 12 00 mov 0x1278c8,%edx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ac40: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx 10ac46: 89 4d d4 mov %ecx,-0x2c(%ebp) * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10ac49: 9c pushf 10ac4a: fa cli 10ac4b: 8f 45 d0 popl -0x30(%ebp) if ( *set & api->signals_pending ) { 10ac4e: 8b 1e mov (%esi),%ebx 10ac50: 89 5d c4 mov %ebx,-0x3c(%ebp) 10ac53: 8b 5d d4 mov -0x2c(%ebp),%ebx 10ac56: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx 10ac5c: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac5f: 74 32 je 10ac93 /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10ac61: 83 ec 0c sub $0xc,%esp 10ac64: 51 push %ecx 10ac65: e8 3e ff ff ff call 10aba8 <_POSIX_signals_Get_lowest> 10ac6a: 89 07 mov %eax,(%edi) _POSIX_signals_Clear_signals( 10ac6c: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac73: 6a 00 push $0x0 10ac75: 57 push %edi 10ac76: 50 push %eax 10ac77: 53 push %ebx 10ac78: e8 2b 51 00 00 call 10fda8 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10ac7d: ff 75 d0 pushl -0x30(%ebp) 10ac80: 9d popf the_info->si_code = SI_USER; 10ac81: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac88: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return the_info->si_signo; 10ac8f: 8b 1f mov (%edi),%ebx 10ac91: eb 3d jmp 10acd0 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10ac93: 8b 0d f0 7a 12 00 mov 0x127af0,%ecx 10ac99: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac9c: 74 3a je 10acd8 signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 10ac9e: 83 ec 0c sub $0xc,%esp 10aca1: 51 push %ecx 10aca2: e8 01 ff ff ff call 10aba8 <_POSIX_signals_Get_lowest> 10aca7: 89 c3 mov %eax,%ebx _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10aca9: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10acb0: 6a 01 push $0x1 10acb2: 57 push %edi 10acb3: 50 push %eax 10acb4: ff 75 d4 pushl -0x2c(%ebp) 10acb7: e8 ec 50 00 00 call 10fda8 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 10acbc: ff 75 d0 pushl -0x30(%ebp) 10acbf: 9d popf the_info->si_signo = signo; 10acc0: 89 1f mov %ebx,(%edi) the_info->si_code = SI_USER; 10acc2: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10acc9: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return signo; 10acd0: 83 c4 20 add $0x20,%esp 10acd3: e9 92 00 00 00 jmp 10ad6a } the_info->si_signo = -1; 10acd8: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10acde: 8b 0d a0 73 12 00 mov 0x1273a0,%ecx 10ace4: 41 inc %ecx 10ace5: 89 0d a0 73 12 00 mov %ecx,0x1273a0 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10aceb: c7 42 44 88 7a 12 00 movl $0x127a88,0x44(%edx) the_thread->Wait.return_code = EINTR; 10acf2: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) the_thread->Wait.option = *set; 10acf9: 8b 0e mov (%esi),%ecx 10acfb: 89 4a 30 mov %ecx,0x30(%edx) the_thread->Wait.return_argument = the_info; 10acfe: 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; 10ad01: c7 05 b8 7a 12 00 01 movl $0x1,0x127ab8 10ad08: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10ad0b: ff 75 d0 pushl -0x30(%ebp) 10ad0e: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10ad0f: 52 push %edx 10ad10: 68 e0 da 10 00 push $0x10dae0 10ad15: 50 push %eax 10ad16: 68 88 7a 12 00 push $0x127a88 10ad1b: e8 e4 2a 00 00 call 10d804 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10ad20: e8 95 26 00 00 call 10d3ba <_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 ); 10ad25: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ad2c: 6a 00 push $0x0 10ad2e: 57 push %edi 10ad2f: ff 37 pushl (%edi) 10ad31: ff 75 d4 pushl -0x2c(%ebp) 10ad34: e8 6f 50 00 00 call 10fda8 <_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) 10ad39: 83 c4 20 add $0x20,%esp 10ad3c: a1 c8 78 12 00 mov 0x1278c8,%eax 10ad41: 83 78 34 04 cmpl $0x4,0x34(%eax) 10ad45: 75 10 jne 10ad57 || !(*set & signo_to_mask( the_info->si_signo )) ) { 10ad47: 8b 1f mov (%edi),%ebx 10ad49: 8d 4b ff lea -0x1(%ebx),%ecx 10ad4c: b8 01 00 00 00 mov $0x1,%eax 10ad51: d3 e0 shl %cl,%eax 10ad53: 85 06 test %eax,(%esi) 10ad55: 75 13 jne 10ad6a errno = _Thread_Executing->Wait.return_code; 10ad57: e8 18 78 00 00 call 112574 <__errno> 10ad5c: 8b 15 c8 78 12 00 mov 0x1278c8,%edx 10ad62: 8b 52 34 mov 0x34(%edx),%edx 10ad65: 89 10 mov %edx,(%eax) return -1; 10ad67: 83 cb ff or $0xffffffff,%ebx } return the_info->si_signo; } 10ad6a: 89 d8 mov %ebx,%eax 10ad6c: 8d 65 f4 lea -0xc(%ebp),%esp 10ad6f: 5b pop %ebx 10ad70: 5e pop %esi 10ad71: 5f pop %edi 10ad72: c9 leave 10ad73: c3 ret =============================================================================== 0010ca08 : int sigwait( const sigset_t *set, int *sig ) { 10ca08: 55 push %ebp 10ca09: 89 e5 mov %esp,%ebp 10ca0b: 53 push %ebx 10ca0c: 83 ec 08 sub $0x8,%esp 10ca0f: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10ca12: 6a 00 push $0x0 10ca14: 6a 00 push $0x0 10ca16: ff 75 08 pushl 0x8(%ebp) 10ca19: e8 45 fe ff ff call 10c863 10ca1e: 89 c2 mov %eax,%edx if ( status != -1 ) { 10ca20: 83 c4 10 add $0x10,%esp 10ca23: 83 f8 ff cmp $0xffffffff,%eax 10ca26: 74 0a je 10ca32 if ( sig ) *sig = status; return 0; 10ca28: 31 c0 xor %eax,%eax int status; status = sigtimedwait( set, NULL, NULL ); if ( status != -1 ) { if ( sig ) 10ca2a: 85 db test %ebx,%ebx 10ca2c: 74 0b je 10ca39 <== NEVER TAKEN *sig = status; 10ca2e: 89 13 mov %edx,(%ebx) 10ca30: eb 07 jmp 10ca39 return 0; } return errno; 10ca32: e8 05 73 00 00 call 113d3c <__errno> 10ca37: 8b 00 mov (%eax),%eax } 10ca39: 8b 5d fc mov -0x4(%ebp),%ebx 10ca3c: c9 leave 10ca3d: c3 ret =============================================================================== 0010a084 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10a084: 55 push %ebp 10a085: 89 e5 mov %esp,%ebp 10a087: 56 push %esi 10a088: 53 push %ebx 10a089: 8b 5d 0c mov 0xc(%ebp),%ebx 10a08c: 8b 75 10 mov 0x10(%ebp),%esi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10a08f: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10a093: 75 1d jne 10a0b2 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10a095: 85 f6 test %esi,%esi 10a097: 74 19 je 10a0b2 /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10a099: 85 db test %ebx,%ebx 10a09b: 74 22 je 10a0bf /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10a09d: 8b 03 mov (%ebx),%eax 10a09f: 48 dec %eax 10a0a0: 83 f8 01 cmp $0x1,%eax 10a0a3: 77 0d ja 10a0b2 <== 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 ) 10a0a5: 8b 43 04 mov 0x4(%ebx),%eax 10a0a8: 85 c0 test %eax,%eax 10a0aa: 74 06 je 10a0b2 <== NEVER TAKEN static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a0ac: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10a0ad: 83 f8 1f cmp $0x1f,%eax 10a0b0: 76 0d jbe 10a0bf <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10a0b2: e8 9d 7c 00 00 call 111d54 <__errno> 10a0b7: c7 00 16 00 00 00 movl $0x16,(%eax) 10a0bd: eb 2f jmp 10a0ee rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a0bf: a1 b4 73 12 00 mov 0x1273b4,%eax 10a0c4: 40 inc %eax 10a0c5: a3 b4 73 12 00 mov %eax,0x1273b4 * 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 ); 10a0ca: 83 ec 0c sub $0xc,%esp 10a0cd: 68 98 76 12 00 push $0x127698 10a0d2: e8 75 1b 00 00 call 10bc4c <_Objects_Allocate> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10a0d7: 83 c4 10 add $0x10,%esp 10a0da: 85 c0 test %eax,%eax 10a0dc: 75 18 jne 10a0f6 _Thread_Enable_dispatch(); 10a0de: e8 47 2a 00 00 call 10cb2a <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10a0e3: e8 6c 7c 00 00 call 111d54 <__errno> 10a0e8: c7 00 0b 00 00 00 movl $0xb,(%eax) 10a0ee: 83 c8 ff or $0xffffffff,%eax 10a0f1: e9 83 00 00 00 jmp 10a179 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10a0f6: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10a0fa: 8b 15 dc 78 12 00 mov 0x1278dc,%edx 10a100: 8b 52 08 mov 0x8(%edx),%edx 10a103: 89 50 38 mov %edx,0x38(%eax) if ( evp != NULL ) { 10a106: 85 db test %ebx,%ebx 10a108: 74 11 je 10a11b ptimer->inf.sigev_notify = evp->sigev_notify; 10a10a: 8b 13 mov (%ebx),%edx 10a10c: 89 50 40 mov %edx,0x40(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10a10f: 8b 53 04 mov 0x4(%ebx),%edx 10a112: 89 50 44 mov %edx,0x44(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10a115: 8b 53 08 mov 0x8(%ebx),%edx 10a118: 89 50 48 mov %edx,0x48(%eax) } ptimer->overrun = 0; 10a11b: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) ptimer->timer_data.it_value.tv_sec = 0; 10a122: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10a129: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10a130: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10a137: 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; 10a13e: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10a145: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10a14c: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10a153: 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 ), 10a15a: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a15d: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a160: 8b 0d b4 76 12 00 mov 0x1276b4,%ecx 10a166: 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; 10a169: 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; 10a170: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10a172: e8 b3 29 00 00 call 10cb2a <_Thread_Enable_dispatch> return 0; 10a177: 31 c0 xor %eax,%eax } 10a179: 8d 65 f8 lea -0x8(%ebp),%esp 10a17c: 5b pop %ebx 10a17d: 5e pop %esi 10a17e: c9 leave 10a17f: c3 ret =============================================================================== 0010a180 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10a180: 55 push %ebp 10a181: 89 e5 mov %esp,%ebp 10a183: 57 push %edi 10a184: 56 push %esi 10a185: 53 push %ebx 10a186: 83 ec 2c sub $0x2c,%esp 10a189: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10a18c: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a190: 0f 84 58 01 00 00 je 10a2ee <== 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) ) ) { 10a196: 83 ec 0c sub $0xc,%esp 10a199: 8b 45 10 mov 0x10(%ebp),%eax 10a19c: 83 c0 08 add $0x8,%eax 10a19f: 50 push %eax 10a1a0: e8 53 33 00 00 call 10d4f8 <_Timespec_Is_valid> 10a1a5: 83 c4 10 add $0x10,%esp 10a1a8: 84 c0 test %al,%al 10a1aa: 0f 84 3e 01 00 00 je 10a2ee rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 10a1b0: 83 ec 0c sub $0xc,%esp 10a1b3: ff 75 10 pushl 0x10(%ebp) 10a1b6: e8 3d 33 00 00 call 10d4f8 <_Timespec_Is_valid> 10a1bb: 83 c4 10 add $0x10,%esp 10a1be: 84 c0 test %al,%al 10a1c0: 0f 84 28 01 00 00 je 10a2ee <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10a1c6: 85 db test %ebx,%ebx 10a1c8: 74 09 je 10a1d3 10a1ca: 83 fb 04 cmp $0x4,%ebx 10a1cd: 0f 85 1b 01 00 00 jne 10a2ee rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10a1d3: 8d 7d cc lea -0x34(%ebp),%edi 10a1d6: b9 04 00 00 00 mov $0x4,%ecx 10a1db: 8b 75 10 mov 0x10(%ebp),%esi 10a1de: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 10a1e0: 83 fb 04 cmp $0x4,%ebx 10a1e3: 75 2f jne 10a214 struct timespec now; _TOD_Get( &now ); 10a1e5: 83 ec 0c sub $0xc,%esp 10a1e8: 8d 5d dc lea -0x24(%ebp),%ebx 10a1eb: 53 push %ebx 10a1ec: e8 b3 15 00 00 call 10b7a4 <_TOD_Get> /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 10a1f1: 59 pop %ecx 10a1f2: 5e pop %esi 10a1f3: 8d 75 d4 lea -0x2c(%ebp),%esi 10a1f6: 56 push %esi 10a1f7: 53 push %ebx 10a1f8: e8 d7 32 00 00 call 10d4d4 <_Timespec_Greater_than> 10a1fd: 83 c4 10 add $0x10,%esp 10a200: 84 c0 test %al,%al 10a202: 0f 85 e6 00 00 00 jne 10a2ee rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 10a208: 52 push %edx 10a209: 56 push %esi 10a20a: 56 push %esi 10a20b: 53 push %ebx 10a20c: e8 0b 33 00 00 call 10d51c <_Timespec_Subtract> 10a211: 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 ); 10a214: 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 ); 10a215: 8d 45 e4 lea -0x1c(%ebp),%eax 10a218: 50 push %eax 10a219: ff 75 08 pushl 0x8(%ebp) 10a21c: 68 98 76 12 00 push $0x127698 10a221: e8 52 1e 00 00 call 10c078 <_Objects_Get> 10a226: 89 c3 mov %eax,%ebx switch ( location ) { 10a228: 83 c4 10 add $0x10,%esp 10a22b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10a22f: 0f 85 b9 00 00 00 jne 10a2ee 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 ) { 10a235: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10a239: 75 3b jne 10a276 10a23b: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10a23f: 75 35 jne 10a276 /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10a241: 83 ec 0c sub $0xc,%esp 10a244: 8d 40 10 lea 0x10(%eax),%eax 10a247: 50 push %eax 10a248: e8 9b 36 00 00 call 10d8e8 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 10a24d: 83 c4 10 add $0x10,%esp 10a250: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a254: 74 0d je 10a263 *ovalue = ptimer->timer_data; 10a256: 8d 73 54 lea 0x54(%ebx),%esi 10a259: b9 04 00 00 00 mov $0x4,%ecx 10a25e: 8b 7d 14 mov 0x14(%ebp),%edi 10a261: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* The new data are set */ ptimer->timer_data = normalize; 10a263: 8d 7b 54 lea 0x54(%ebx),%edi 10a266: 8d 75 cc lea -0x34(%ebp),%esi 10a269: b9 04 00 00 00 mov $0x4,%ecx 10a26e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a270: c6 43 3c 04 movb $0x4,0x3c(%ebx) 10a274: eb 35 jmp 10a2ab _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10a276: 83 ec 0c sub $0xc,%esp 10a279: ff 75 10 pushl 0x10(%ebp) 10a27c: e8 cf 32 00 00 call 10d550 <_Timespec_To_ticks> 10a281: 89 43 64 mov %eax,0x64(%ebx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 10a284: 8d 45 d4 lea -0x2c(%ebp),%eax 10a287: 89 04 24 mov %eax,(%esp) 10a28a: e8 c1 32 00 00 call 10d550 <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 10a28f: 89 1c 24 mov %ebx,(%esp) 10a292: 68 04 a3 10 00 push $0x10a304 10a297: ff 73 08 pushl 0x8(%ebx) 10a29a: 50 push %eax 10a29b: 8d 43 10 lea 0x10(%ebx),%eax 10a29e: 50 push %eax 10a29f: e8 78 57 00 00 call 10fa1c <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10a2a4: 83 c4 20 add $0x20,%esp 10a2a7: 84 c0 test %al,%al 10a2a9: 75 07 jne 10a2b2 _Thread_Enable_dispatch(); 10a2ab: e8 7a 28 00 00 call 10cb2a <_Thread_Enable_dispatch> 10a2b0: eb 38 jmp 10a2ea /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10a2b2: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a2b6: 74 0d je 10a2c5 *ovalue = ptimer->timer_data; 10a2b8: 8d 73 54 lea 0x54(%ebx),%esi 10a2bb: b9 04 00 00 00 mov $0x4,%ecx 10a2c0: 8b 7d 14 mov 0x14(%ebp),%edi 10a2c3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 10a2c5: 8d 7b 54 lea 0x54(%ebx),%edi 10a2c8: 8d 75 cc lea -0x34(%ebp),%esi 10a2cb: b9 04 00 00 00 mov $0x4,%ecx 10a2d0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a2d2: c6 43 3c 03 movb $0x3,0x3c(%ebx) _TOD_Get( &ptimer->time ); 10a2d6: 83 ec 0c sub $0xc,%esp 10a2d9: 83 c3 6c add $0x6c,%ebx 10a2dc: 53 push %ebx 10a2dd: e8 c2 14 00 00 call 10b7a4 <_TOD_Get> _Thread_Enable_dispatch(); 10a2e2: e8 43 28 00 00 call 10cb2a <_Thread_Enable_dispatch> return 0; 10a2e7: 83 c4 10 add $0x10,%esp 10a2ea: 31 c0 xor %eax,%eax 10a2ec: eb 0e jmp 10a2fc #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a2ee: e8 61 7a 00 00 call 111d54 <__errno> 10a2f3: c7 00 16 00 00 00 movl $0x16,(%eax) 10a2f9: 83 c8 ff or $0xffffffff,%eax } 10a2fc: 8d 65 f4 lea -0xc(%ebp),%esp 10a2ff: 5b pop %ebx 10a300: 5e pop %esi 10a301: 5f pop %edi 10a302: c9 leave 10a303: c3 ret =============================================================================== 00109fc0 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 109fc0: 55 push %ebp 109fc1: 89 e5 mov %esp,%ebp 109fc3: 57 push %edi 109fc4: 56 push %esi 109fc5: 53 push %ebx 109fc6: 83 ec 1c sub $0x1c,%esp 109fc9: 8b 75 08 mov 0x8(%ebp),%esi /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 109fcc: 83 3d 00 7d 12 00 00 cmpl $0x0,0x127d00 109fd3: 75 2c jne 10a001 <== NEVER TAKEN Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 109fd5: c7 05 ec 7c 12 00 00 movl $0x0,0x127cec 109fdc: 00 00 00 the_watchdog->routine = routine; 109fdf: c7 05 00 7d 12 00 88 movl $0x109f88,0x127d00 109fe6: 9f 10 00 the_watchdog->id = id; 109fe9: c7 05 04 7d 12 00 00 movl $0x0,0x127d04 109ff0: 00 00 00 the_watchdog->user_data = user_data; 109ff3: c7 05 08 7d 12 00 00 movl $0x0,0x127d08 109ffa: 00 00 00 useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109ffd: 31 db xor %ebx,%ebx 109fff: eb 4f jmp 10a050 if ( !the_timer->routine ) { _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 10a001: 83 ec 0c sub $0xc,%esp 10a004: 68 e4 7c 12 00 push $0x127ce4 10a009: e8 c2 34 00 00 call 10d4d0 <_Watchdog_Remove> if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 10a00e: 83 e8 02 sub $0x2,%eax 10a011: 83 c4 10 add $0x10,%esp useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 10a014: 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) ) { 10a016: 83 f8 01 cmp $0x1,%eax 10a019: 77 35 ja 10a050 <== 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); 10a01b: a1 f8 7c 12 00 mov 0x127cf8,%eax 10a020: 03 05 f0 7c 12 00 add 0x127cf0,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 10a026: 57 push %edi 10a027: 57 push %edi 10a028: 8d 55 e0 lea -0x20(%ebp),%edx 10a02b: 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); 10a02c: 2b 05 fc 7c 12 00 sub 0x127cfc,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 10a032: 50 push %eax 10a033: e8 38 30 00 00 call 10d070 <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 10a038: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx remaining += tp.tv_nsec / 1000; 10a03f: 8b 45 e4 mov -0x1c(%ebp),%eax 10a042: bf e8 03 00 00 mov $0x3e8,%edi 10a047: 99 cltd 10a048: f7 ff idiv %edi 10a04a: 8d 1c 08 lea (%eax,%ecx,1),%ebx 10a04d: 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 ) { 10a050: 85 f6 test %esi,%esi 10a052: 74 44 je 10a098 Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 10a054: b9 40 42 0f 00 mov $0xf4240,%ecx 10a059: 89 f0 mov %esi,%eax 10a05b: 31 d2 xor %edx,%edx 10a05d: f7 f1 div %ecx 10a05f: 89 45 e0 mov %eax,-0x20(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10a062: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx 10a068: 89 55 e4 mov %edx,-0x1c(%ebp) ticks = _Timespec_To_ticks( &tp ); 10a06b: 83 ec 0c sub $0xc,%esp 10a06e: 8d 75 e0 lea -0x20(%ebp),%esi 10a071: 56 push %esi 10a072: e8 55 30 00 00 call 10d0cc <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 10a077: 89 34 24 mov %esi,(%esp) 10a07a: e8 4d 30 00 00 call 10d0cc <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a07f: a3 f0 7c 12 00 mov %eax,0x127cf0 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a084: 59 pop %ecx 10a085: 5e pop %esi 10a086: 68 e4 7c 12 00 push $0x127ce4 10a08b: 68 d4 74 12 00 push $0x1274d4 10a090: e8 1b 33 00 00 call 10d3b0 <_Watchdog_Insert> 10a095: 83 c4 10 add $0x10,%esp } return remaining; } 10a098: 89 d8 mov %ebx,%eax 10a09a: 8d 65 f4 lea -0xc(%ebp),%esp 10a09d: 5b pop %ebx 10a09e: 5e pop %esi 10a09f: 5f pop %edi 10a0a0: c9 leave 10a0a1: c3 ret