=============================================================================== 0010ce0c <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10ce0c: 55 push %ebp 10ce0d: 89 e5 mov %esp,%ebp 10ce0f: 53 push %ebx 10ce10: 83 ec 04 sub $0x4,%esp 10ce13: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10ce16: 8b 15 38 88 12 00 mov 0x128838,%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 ); 10ce1c: 9c pushf 10ce1d: fa cli 10ce1e: 58 pop %eax if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10ce1f: 8b 4b 44 mov 0x44(%ebx),%ecx 10ce22: 85 c9 test %ecx,%ecx 10ce24: 75 0b jne 10ce31 <_CORE_RWLock_Release+0x25> _ISR_Enable( level ); 10ce26: 50 push %eax 10ce27: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ce28: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) return CORE_RWLOCK_SUCCESSFUL; 10ce2f: eb 72 jmp 10cea3 <_CORE_RWLock_Release+0x97> } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10ce31: 49 dec %ecx 10ce32: 75 0f jne 10ce43 <_CORE_RWLock_Release+0x37> the_rwlock->number_of_readers -= 1; 10ce34: 8b 4b 48 mov 0x48(%ebx),%ecx 10ce37: 49 dec %ecx 10ce38: 89 4b 48 mov %ecx,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10ce3b: 85 c9 test %ecx,%ecx 10ce3d: 74 04 je 10ce43 <_CORE_RWLock_Release+0x37> /* must be unlocked again */ _ISR_Enable( level ); 10ce3f: 50 push %eax 10ce40: 9d popf return CORE_RWLOCK_SUCCESSFUL; 10ce41: eb 60 jmp 10cea3 <_CORE_RWLock_Release+0x97> } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce43: 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; 10ce4a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10ce51: 50 push %eax 10ce52: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10ce53: 83 ec 0c sub $0xc,%esp 10ce56: 53 push %ebx 10ce57: e8 58 17 00 00 call 10e5b4 <_Thread_queue_Dequeue> if ( next ) { 10ce5c: 83 c4 10 add $0x10,%esp 10ce5f: 85 c0 test %eax,%eax 10ce61: 74 40 je 10cea3 <_CORE_RWLock_Release+0x97> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10ce63: 83 78 30 01 cmpl $0x1,0x30(%eax) 10ce67: 75 09 jne 10ce72 <_CORE_RWLock_Release+0x66> the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10ce69: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10ce70: eb 31 jmp 10cea3 <_CORE_RWLock_Release+0x97> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10ce72: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10ce75: 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 ); 10ce7c: 83 ec 0c sub $0xc,%esp 10ce7f: 53 push %ebx 10ce80: e8 27 1b 00 00 call 10e9ac <_Thread_queue_First> if ( !next || 10ce85: 83 c4 10 add $0x10,%esp 10ce88: 85 c0 test %eax,%eax 10ce8a: 74 17 je 10cea3 <_CORE_RWLock_Release+0x97> 10ce8c: 83 78 30 01 cmpl $0x1,0x30(%eax) 10ce90: 74 11 je 10cea3 <_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; 10ce92: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10ce95: 52 push %edx 10ce96: 52 push %edx 10ce97: 50 push %eax 10ce98: 53 push %ebx 10ce99: e8 fe 19 00 00 call 10e89c <_Thread_queue_Extract> } 10ce9e: 83 c4 10 add $0x10,%esp 10cea1: eb d9 jmp 10ce7c <_CORE_RWLock_Release+0x70> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cea3: 31 c0 xor %eax,%eax 10cea5: 8b 5d fc mov -0x4(%ebp),%ebx 10cea8: c9 leave 10cea9: c3 ret =============================================================================== 0010ceac <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10ceac: 55 push %ebp 10cead: 89 e5 mov %esp,%ebp 10ceaf: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10ceb2: 8d 45 f4 lea -0xc(%ebp),%eax 10ceb5: 50 push %eax 10ceb6: ff 75 08 pushl 0x8(%ebp) 10ceb9: e8 a2 13 00 00 call 10e260 <_Thread_Get> switch ( location ) { 10cebe: 83 c4 10 add $0x10,%esp 10cec1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10cec5: 75 17 jne 10cede <_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 ); 10cec7: 83 ec 0c sub $0xc,%esp 10ceca: 50 push %eax 10cecb: e8 a8 1b 00 00 call 10ea78 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10ced0: a1 f0 82 12 00 mov 0x1282f0,%eax 10ced5: 48 dec %eax 10ced6: a3 f0 82 12 00 mov %eax,0x1282f0 10cedb: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10cede: c9 leave 10cedf: c3 ret =============================================================================== 0011736c <_CORE_message_queue_Broadcast>: Objects_Id id __attribute__((unused)), CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)), #endif uint32_t *count ) { 11736c: 55 push %ebp 11736d: 89 e5 mov %esp,%ebp 11736f: 57 push %edi 117370: 56 push %esi 117371: 53 push %ebx 117372: 83 ec 1c sub $0x1c,%esp 117375: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; 117378: b8 01 00 00 00 mov $0x1,%eax { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 11737d: 8b 55 10 mov 0x10(%ebp),%edx 117380: 3b 53 4c cmp 0x4c(%ebx),%edx 117383: 77 4e ja 1173d3 <_CORE_message_queue_Broadcast+0x67><== NEVER TAKEN * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 117385: 83 7b 48 00 cmpl $0x0,0x48(%ebx) 117389: 75 09 jne 117394 <_CORE_message_queue_Broadcast+0x28> 11738b: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 117392: eb 23 jmp 1173b7 <_CORE_message_queue_Broadcast+0x4b> *count = 0; 117394: 8b 45 1c mov 0x1c(%ebp),%eax 117397: c7 00 00 00 00 00 movl $0x0,(%eax) 11739d: eb 32 jmp 1173d1 <_CORE_message_queue_Broadcast+0x65> */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { waitp = &the_thread->Wait; number_broadcasted += 1; 11739f: ff 45 e4 incl -0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 1173a2: 8b 42 2c mov 0x2c(%edx),%eax 1173a5: 89 c7 mov %eax,%edi 1173a7: 8b 75 0c mov 0xc(%ebp),%esi 1173aa: 8b 4d 10 mov 0x10(%ebp),%ecx 1173ad: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 1173af: 8b 42 28 mov 0x28(%edx),%eax 1173b2: 8b 55 10 mov 0x10(%ebp),%edx 1173b5: 89 10 mov %edx,(%eax) /* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = 1173b7: 83 ec 0c sub $0xc,%esp 1173ba: 53 push %ebx 1173bb: e8 84 24 00 00 call 119844 <_Thread_queue_Dequeue> 1173c0: 89 c2 mov %eax,%edx 1173c2: 83 c4 10 add $0x10,%esp 1173c5: 85 c0 test %eax,%eax 1173c7: 75 d6 jne 11739f <_CORE_message_queue_Broadcast+0x33> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 1173c9: 8b 55 e4 mov -0x1c(%ebp),%edx 1173cc: 8b 45 1c mov 0x1c(%ebp),%eax 1173cf: 89 10 mov %edx,(%eax) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 1173d1: 31 c0 xor %eax,%eax } 1173d3: 8d 65 f4 lea -0xc(%ebp),%esp 1173d6: 5b pop %ebx 1173d7: 5e pop %esi 1173d8: 5f pop %edi 1173d9: c9 leave 1173da: c3 ret =============================================================================== 00112220 <_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 ) { 112220: 55 push %ebp 112221: 89 e5 mov %esp,%ebp 112223: 57 push %edi 112224: 56 push %esi 112225: 53 push %ebx 112226: 83 ec 1c sub $0x1c,%esp 112229: 8b 5d 08 mov 0x8(%ebp),%ebx 11222c: 8b 7d 10 mov 0x10(%ebp),%edi 11222f: 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; 112232: 89 7b 44 mov %edi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 112235: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 11223c: 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; 11223f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) the_message_queue->notify_argument = the_argument; 112246: 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)) { 11224d: 89 d0 mov %edx,%eax 11224f: f6 c2 03 test $0x3,%dl 112252: 74 0c je 112260 <_CORE_message_queue_Initialize+0x40> allocated_message_size += sizeof(uint32_t); 112254: 83 c0 04 add $0x4,%eax allocated_message_size &= ~(sizeof(uint32_t) - 1); 112257: 83 e0 fc and $0xfffffffc,%eax } if (allocated_message_size < maximum_message_size) return false; 11225a: 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) 11225c: 39 d0 cmp %edx,%eax 11225e: 72 68 jb 1122c8 <_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)); 112260: 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 * 112263: 89 d1 mov %edx,%ecx 112265: 0f af cf imul %edi,%ecx (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) return false; 112268: 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) 11226a: 39 c1 cmp %eax,%ecx 11226c: 72 5a jb 1122c8 <_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 ); 11226e: 83 ec 0c sub $0xc,%esp 112271: 51 push %ecx 112272: 89 55 e4 mov %edx,-0x1c(%ebp) 112275: e8 74 27 00 00 call 1149ee <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 11227a: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 11227d: 83 c4 10 add $0x10,%esp 112280: 85 c0 test %eax,%eax 112282: 8b 55 e4 mov -0x1c(%ebp),%edx 112285: 74 41 je 1122c8 <_CORE_message_queue_Initialize+0xa8> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 112287: 52 push %edx 112288: 57 push %edi 112289: 50 push %eax 11228a: 8d 43 68 lea 0x68(%ebx),%eax 11228d: 50 push %eax 11228e: e8 b9 4a 00 00 call 116d4c <_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 ); 112293: 8d 43 54 lea 0x54(%ebx),%eax 112296: 89 43 50 mov %eax,0x50(%ebx) head->next = tail; head->previous = NULL; 112299: 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 ); 1122a0: 8d 43 50 lea 0x50(%ebx),%eax 1122a3: 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( 1122a6: 6a 06 push $0x6 1122a8: 68 80 00 00 00 push $0x80 1122ad: 8b 45 0c mov 0xc(%ebp),%eax 1122b0: 83 38 01 cmpl $0x1,(%eax) 1122b3: 0f 94 c0 sete %al 1122b6: 0f b6 c0 movzbl %al,%eax 1122b9: 50 push %eax 1122ba: 53 push %ebx 1122bb: e8 fc 1e 00 00 call 1141bc <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 1122c0: 83 c4 20 add $0x20,%esp 1122c3: be 01 00 00 00 mov $0x1,%esi } 1122c8: 89 f0 mov %esi,%eax 1122ca: 8d 65 f4 lea -0xc(%ebp),%esp 1122cd: 5b pop %ebx 1122ce: 5e pop %esi 1122cf: 5f pop %edi 1122d0: c9 leave 1122d1: c3 ret =============================================================================== 001122d4 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 1122d4: 55 push %ebp 1122d5: 89 e5 mov %esp,%ebp 1122d7: 57 push %edi 1122d8: 56 push %esi 1122d9: 53 push %ebx 1122da: 83 ec 2c sub $0x2c,%esp 1122dd: 8b 55 08 mov 0x8(%ebp),%edx 1122e0: 8b 45 0c mov 0xc(%ebp),%eax 1122e3: 89 45 dc mov %eax,-0x24(%ebp) 1122e6: 8b 5d 10 mov 0x10(%ebp),%ebx 1122e9: 89 5d e0 mov %ebx,-0x20(%ebp) 1122ec: 8b 4d 14 mov 0x14(%ebp),%ecx 1122ef: 8b 75 1c mov 0x1c(%ebp),%esi 1122f2: 89 75 d4 mov %esi,-0x2c(%ebp) 1122f5: 8a 45 18 mov 0x18(%ebp),%al 1122f8: 88 45 db mov %al,-0x25(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; executing = _Thread_Executing; 1122fb: a1 90 c9 12 00 mov 0x12c990,%eax executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 112300: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _ISR_Disable( level ); 112307: 9c pushf 112308: fa cli 112309: 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 ); } 11230c: 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 ); 11230f: 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)) 112312: 39 f3 cmp %esi,%ebx 112314: 0f 84 8a 00 00 00 je 1123a4 <_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; 11231a: 8b 33 mov (%ebx),%esi head->next = new_first; 11231c: 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 ); 11231f: 8d 7a 50 lea 0x50(%edx),%edi 112322: 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 ) { 112325: 85 db test %ebx,%ebx 112327: 74 7b je 1123a4 <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN the_message_queue->number_of_pending_messages -= 1; 112329: ff 4a 48 decl 0x48(%edx) _ISR_Enable( level ); 11232c: ff 75 e4 pushl -0x1c(%ebp) 11232f: 9d popf *size_p = the_message->Contents.size; 112330: 8b 43 0c mov 0xc(%ebx),%eax 112333: 89 01 mov %eax,(%ecx) _Thread_Executing->Wait.count = 112335: 8b 73 08 mov 0x8(%ebx),%esi 112338: a1 90 c9 12 00 mov 0x12c990,%eax 11233d: 89 70 24 mov %esi,0x24(%eax) _CORE_message_queue_Get_message_priority( the_message ); _CORE_message_queue_Copy_buffer( the_message->Contents.buffer, 112340: 8d 73 10 lea 0x10(%ebx),%esi 112343: 89 75 e4 mov %esi,-0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 112346: 8b 09 mov (%ecx),%ecx 112348: 8b 7d e0 mov -0x20(%ebp),%edi 11234b: 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 ); 11234d: 83 ec 0c sub $0xc,%esp 112350: 52 push %edx 112351: 89 55 d0 mov %edx,-0x30(%ebp) 112354: e8 2b 1b 00 00 call 113e84 <_Thread_queue_Dequeue> if ( !the_thread ) { 112359: 83 c4 10 add $0x10,%esp 11235c: 85 c0 test %eax,%eax 11235e: 8b 55 d0 mov -0x30(%ebp),%edx 112361: 75 15 jne 112378 <_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 ); 112363: 89 5d 0c mov %ebx,0xc(%ebp) 112366: 83 c2 68 add $0x68,%edx 112369: 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 ); } 11236c: 8d 65 f4 lea -0xc(%ebp),%esp 11236f: 5b pop %ebx 112370: 5e pop %esi 112371: 5f pop %edi 112372: c9 leave 112373: e9 28 fe ff ff jmp 1121a0 <_Chain_Append> CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 112378: 8b 48 24 mov 0x24(%eax),%ecx 11237b: 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; 11237e: 8b 48 30 mov 0x30(%eax),%ecx 112381: 89 4b 0c mov %ecx,0xc(%ebx) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 112384: 8b 70 2c mov 0x2c(%eax),%esi 112387: 8b 7d e4 mov -0x1c(%ebp),%edi 11238a: 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( 11238c: 8b 43 08 mov 0x8(%ebx),%eax 11238f: 89 45 10 mov %eax,0x10(%ebp) 112392: 89 5d 0c mov %ebx,0xc(%ebp) 112395: 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 ); } 112398: 8d 65 f4 lea -0xc(%ebp),%esp 11239b: 5b pop %ebx 11239c: 5e pop %esi 11239d: 5f pop %edi 11239e: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 11239f: e9 e0 49 00 00 jmp 116d84 <_CORE_message_queue_Insert_message> return; } #endif } if ( !wait ) { 1123a4: 80 7d db 00 cmpb $0x0,-0x25(%ebp) 1123a8: 75 13 jne 1123bd <_CORE_message_queue_Seize+0xe9> _ISR_Enable( level ); 1123aa: ff 75 e4 pushl -0x1c(%ebp) 1123ad: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 1123ae: 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 ); } 1123b5: 8d 65 f4 lea -0xc(%ebp),%esp 1123b8: 5b pop %ebx 1123b9: 5e pop %esi 1123ba: 5f pop %edi 1123bb: c9 leave 1123bc: 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; 1123bd: 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; 1123c4: 89 50 44 mov %edx,0x44(%eax) executing->Wait.id = id; 1123c7: 8b 5d dc mov -0x24(%ebp),%ebx 1123ca: 89 58 20 mov %ebx,0x20(%eax) executing->Wait.return_argument_second.mutable_object = buffer; 1123cd: 8b 75 e0 mov -0x20(%ebp),%esi 1123d0: 89 70 2c mov %esi,0x2c(%eax) executing->Wait.return_argument = size_p; 1123d3: 89 48 28 mov %ecx,0x28(%eax) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 1123d6: ff 75 e4 pushl -0x1c(%ebp) 1123d9: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 1123da: c7 45 10 6c 42 11 00 movl $0x11426c,0x10(%ebp) 1123e1: 8b 45 d4 mov -0x2c(%ebp),%eax 1123e4: 89 45 0c mov %eax,0xc(%ebp) 1123e7: 89 55 08 mov %edx,0x8(%ebp) } 1123ea: 8d 65 f4 lea -0xc(%ebp),%esp 1123ed: 5b pop %ebx 1123ee: 5e pop %esi 1123ef: 5f pop %edi 1123f0: 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 ); 1123f1: e9 9a 1b 00 00 jmp 113f90 <_Thread_queue_Enqueue_with_handler> =============================================================================== 0010ac2d <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10ac2d: 55 push %ebp 10ac2e: 89 e5 mov %esp,%ebp 10ac30: 53 push %ebx 10ac31: 83 ec 14 sub $0x14,%esp 10ac34: 8b 5d 08 mov 0x8(%ebp),%ebx 10ac37: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10ac3a: a1 e0 42 12 00 mov 0x1242e0,%eax 10ac3f: 85 c0 test %eax,%eax 10ac41: 74 19 je 10ac5c <_CORE_mutex_Seize+0x2f> 10ac43: 84 d2 test %dl,%dl 10ac45: 74 15 je 10ac5c <_CORE_mutex_Seize+0x2f><== NEVER TAKEN 10ac47: 83 3d 5c 44 12 00 01 cmpl $0x1,0x12445c 10ac4e: 76 0c jbe 10ac5c <_CORE_mutex_Seize+0x2f> 10ac50: 53 push %ebx 10ac51: 6a 12 push $0x12 10ac53: 6a 00 push $0x0 10ac55: 6a 00 push $0x0 10ac57: e8 dc 05 00 00 call 10b238 <_Internal_error_Occurred> 10ac5c: 51 push %ecx 10ac5d: 51 push %ecx 10ac5e: 8d 45 18 lea 0x18(%ebp),%eax 10ac61: 50 push %eax 10ac62: 53 push %ebx 10ac63: 88 55 f4 mov %dl,-0xc(%ebp) 10ac66: e8 89 47 00 00 call 10f3f4 <_CORE_mutex_Seize_interrupt_trylock> 10ac6b: 83 c4 10 add $0x10,%esp 10ac6e: 85 c0 test %eax,%eax 10ac70: 8a 55 f4 mov -0xc(%ebp),%dl 10ac73: 74 48 je 10acbd <_CORE_mutex_Seize+0x90> 10ac75: 84 d2 test %dl,%dl 10ac77: 75 12 jne 10ac8b <_CORE_mutex_Seize+0x5e> 10ac79: ff 75 18 pushl 0x18(%ebp) 10ac7c: 9d popf 10ac7d: a1 28 48 12 00 mov 0x124828,%eax 10ac82: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) 10ac89: eb 32 jmp 10acbd <_CORE_mutex_Seize+0x90> 10ac8b: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10ac92: a1 28 48 12 00 mov 0x124828,%eax 10ac97: 89 58 44 mov %ebx,0x44(%eax) 10ac9a: 8b 55 0c mov 0xc(%ebp),%edx 10ac9d: 89 50 20 mov %edx,0x20(%eax) 10aca0: a1 e0 42 12 00 mov 0x1242e0,%eax 10aca5: 40 inc %eax 10aca6: a3 e0 42 12 00 mov %eax,0x1242e0 10acab: ff 75 18 pushl 0x18(%ebp) 10acae: 9d popf 10acaf: 50 push %eax 10acb0: 50 push %eax 10acb1: ff 75 14 pushl 0x14(%ebp) 10acb4: 53 push %ebx 10acb5: e8 26 ff ff ff call 10abe0 <_CORE_mutex_Seize_interrupt_blocking> 10acba: 83 c4 10 add $0x10,%esp } 10acbd: 8b 5d fc mov -0x4(%ebp),%ebx 10acc0: c9 leave 10acc1: c3 ret =============================================================================== 0010ade8 <_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 ) { 10ade8: 55 push %ebp 10ade9: 89 e5 mov %esp,%ebp 10adeb: 53 push %ebx 10adec: 83 ec 10 sub $0x10,%esp 10adef: 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)) ) { 10adf2: 53 push %ebx 10adf3: e8 54 16 00 00 call 10c44c <_Thread_queue_Dequeue> 10adf8: 89 c2 mov %eax,%edx 10adfa: 83 c4 10 add $0x10,%esp { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10adfd: 31 c0 xor %eax,%eax if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10adff: 85 d2 test %edx,%edx 10ae01: 75 15 jne 10ae18 <_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 ); 10ae03: 9c pushf 10ae04: fa cli 10ae05: 59 pop %ecx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10ae06: 8b 53 48 mov 0x48(%ebx),%edx the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10ae09: 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 ) 10ae0b: 3b 53 40 cmp 0x40(%ebx),%edx 10ae0e: 73 06 jae 10ae16 <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN the_semaphore->count += 1; 10ae10: 42 inc %edx 10ae11: 89 53 48 mov %edx,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10ae14: 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 ); 10ae16: 51 push %ecx 10ae17: 9d popf } return status; } 10ae18: 8b 5d fc mov -0x4(%ebp),%ebx 10ae1b: c9 leave 10ae1c: c3 ret =============================================================================== 00109d4c <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109d4c: 55 push %ebp 109d4d: 89 e5 mov %esp,%ebp 109d4f: 57 push %edi 109d50: 56 push %esi 109d51: 53 push %ebx 109d52: 83 ec 2c sub $0x2c,%esp 109d55: 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 ]; 109d58: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi option_set = (rtems_option) the_thread->Wait.option; 109d5e: 8b 43 30 mov 0x30(%ebx),%eax 109d61: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109d64: 9c pushf 109d65: fa cli 109d66: 58 pop %eax pending_events = api->pending_events; 109d67: 8b 17 mov (%edi),%edx 109d69: 89 55 d4 mov %edx,-0x2c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109d6c: 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 ) ) { 109d6f: 21 f2 and %esi,%edx 109d71: 75 07 jne 109d7a <_Event_Surrender+0x2e> _ISR_Enable( level ); 109d73: 50 push %eax 109d74: 9d popf return; 109d75: e9 af 00 00 00 jmp 109e29 <_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() && 109d7a: 83 3d 24 48 12 00 00 cmpl $0x0,0x124824 109d81: 74 49 je 109dcc <_Event_Surrender+0x80> 109d83: 3b 1d 28 48 12 00 cmp 0x124828,%ebx 109d89: 75 41 jne 109dcc <_Event_Surrender+0x80> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109d8b: 8b 0d fc 4b 12 00 mov 0x124bfc,%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 ) && 109d91: 83 f9 02 cmp $0x2,%ecx 109d94: 74 09 je 109d9f <_Event_Surrender+0x53> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109d96: 8b 0d fc 4b 12 00 mov 0x124bfc,%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) || 109d9c: 49 dec %ecx 109d9d: 75 2d jne 109dcc <_Event_Surrender+0x80> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109d9f: 39 f2 cmp %esi,%edx 109da1: 74 06 je 109da9 <_Event_Surrender+0x5d> 109da3: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109da7: 74 1f je 109dc8 <_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) ); 109da9: 89 d6 mov %edx,%esi 109dab: f7 d6 not %esi 109dad: 23 75 d4 and -0x2c(%ebp),%esi 109db0: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 109db2: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109db9: 8b 4b 28 mov 0x28(%ebx),%ecx 109dbc: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109dbe: c7 05 fc 4b 12 00 03 movl $0x3,0x124bfc 109dc5: 00 00 00 } _ISR_Enable( level ); 109dc8: 50 push %eax 109dc9: 9d popf return; 109dca: eb 5d jmp 109e29 <_Event_Surrender+0xdd> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109dcc: f6 43 11 01 testb $0x1,0x11(%ebx) 109dd0: 74 55 je 109e27 <_Event_Surrender+0xdb> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109dd2: 39 f2 cmp %esi,%edx 109dd4: 74 06 je 109ddc <_Event_Surrender+0x90> 109dd6: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109dda: 74 4b je 109e27 <_Event_Surrender+0xdb> <== NEVER TAKEN 109ddc: 89 d6 mov %edx,%esi 109dde: f7 d6 not %esi 109de0: 23 75 d4 and -0x2c(%ebp),%esi 109de3: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 109de5: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109dec: 8b 4b 28 mov 0x28(%ebx),%ecx 109def: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109df1: 50 push %eax 109df2: 9d popf 109df3: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109df4: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109df8: 74 06 je 109e00 <_Event_Surrender+0xb4> _ISR_Enable( level ); 109dfa: 50 push %eax 109dfb: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109dfc: 51 push %ecx 109dfd: 51 push %ecx 109dfe: eb 17 jmp 109e17 <_Event_Surrender+0xcb> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109e00: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109e07: 50 push %eax 109e08: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109e09: 83 ec 0c sub $0xc,%esp 109e0c: 8d 43 48 lea 0x48(%ebx),%eax 109e0f: 50 push %eax 109e10: e8 87 30 00 00 call 10ce9c <_Watchdog_Remove> 109e15: 58 pop %eax 109e16: 5a pop %edx 109e17: 68 f8 ff 03 10 push $0x1003fff8 109e1c: 53 push %ebx 109e1d: e8 82 1f 00 00 call 10bda4 <_Thread_Clear_state> 109e22: 83 c4 10 add $0x10,%esp 109e25: eb 02 jmp 109e29 <_Event_Surrender+0xdd> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109e27: 50 push %eax 109e28: 9d popf } 109e29: 8d 65 f4 lea -0xc(%ebp),%esp 109e2c: 5b pop %ebx 109e2d: 5e pop %esi 109e2e: 5f pop %edi 109e2f: c9 leave 109e30: c3 ret =============================================================================== 00109e34 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109e34: 55 push %ebp 109e35: 89 e5 mov %esp,%ebp 109e37: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109e3a: 8d 45 f4 lea -0xc(%ebp),%eax 109e3d: 50 push %eax 109e3e: ff 75 08 pushl 0x8(%ebp) 109e41: e8 b2 22 00 00 call 10c0f8 <_Thread_Get> switch ( location ) { 109e46: 83 c4 10 add $0x10,%esp 109e49: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 109e4d: 75 49 jne 109e98 <_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 ); 109e4f: 9c pushf 109e50: fa cli 109e51: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 109e52: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 109e59: 3b 05 28 48 12 00 cmp 0x124828,%eax 109e5f: 75 13 jne 109e74 <_Event_Timeout+0x40> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 109e61: 8b 0d fc 4b 12 00 mov 0x124bfc,%ecx 109e67: 49 dec %ecx 109e68: 75 0a jne 109e74 <_Event_Timeout+0x40> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 109e6a: c7 05 fc 4b 12 00 02 movl $0x2,0x124bfc 109e71: 00 00 00 } the_thread->Wait.return_code = RTEMS_TIMEOUT; 109e74: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 109e7b: 52 push %edx 109e7c: 9d popf 109e7d: 52 push %edx 109e7e: 52 push %edx 109e7f: 68 f8 ff 03 10 push $0x1003fff8 109e84: 50 push %eax 109e85: e8 1a 1f 00 00 call 10bda4 <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 109e8a: a1 e0 42 12 00 mov 0x1242e0,%eax 109e8f: 48 dec %eax 109e90: a3 e0 42 12 00 mov %eax,0x1242e0 _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; 109e95: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 109e98: c9 leave 109e99: c3 ret =============================================================================== 0010fa4b <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 10fa4b: 55 push %ebp 10fa4c: 89 e5 mov %esp,%ebp 10fa4e: 57 push %edi 10fa4f: 56 push %esi 10fa50: 53 push %ebx 10fa51: 83 ec 4c sub $0x4c,%esp 10fa54: 8b 5d 08 mov 0x8(%ebp),%ebx 10fa57: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 10fa5a: 8b 43 20 mov 0x20(%ebx),%eax 10fa5d: 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; 10fa60: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 10fa67: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 10fa6e: 8b 53 10 mov 0x10(%ebx),%edx 10fa71: 89 55 c4 mov %edx,-0x3c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10fa74: 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; 10fa77: 8b 7b 30 mov 0x30(%ebx),%edi 10fa7a: 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; 10fa7d: 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 ) { 10fa7f: 8b 7d 0c mov 0xc(%ebp),%edi 10fa82: 01 cf add %ecx,%edi 10fa84: 0f 82 d4 01 00 00 jb 10fc5e <_Heap_Extend+0x213> return false; } extend_area_ok = _Heap_Get_first_and_last_block( 10fa8a: 52 push %edx 10fa8b: 52 push %edx 10fa8c: 8d 55 e0 lea -0x20(%ebp),%edx 10fa8f: 52 push %edx 10fa90: 8d 55 e4 lea -0x1c(%ebp),%edx 10fa93: 52 push %edx 10fa94: 50 push %eax 10fa95: ff 75 c4 pushl -0x3c(%ebp) 10fa98: 51 push %ecx 10fa99: ff 75 0c pushl 0xc(%ebp) 10fa9c: e8 ba b8 ff ff call 10b35b <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 10faa1: 83 c4 20 add $0x20,%esp 10faa4: 84 c0 test %al,%al 10faa6: 0f 84 b2 01 00 00 je 10fc5e <_Heap_Extend+0x213> 10faac: 8b 4d c0 mov -0x40(%ebp),%ecx 10faaf: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 10fab6: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 10fabd: 31 f6 xor %esi,%esi 10fabf: 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; 10fac6: 8b 43 18 mov 0x18(%ebx),%eax 10fac9: 89 5d b8 mov %ebx,-0x48(%ebp) 10facc: eb 02 jmp 10fad0 <_Heap_Extend+0x85> 10face: 89 c8 mov %ecx,%eax uintptr_t const sub_area_end = start_block->prev_size; 10fad0: 8b 19 mov (%ecx),%ebx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 10fad2: 39 c7 cmp %eax,%edi 10fad4: 76 09 jbe 10fadf <_Heap_Extend+0x94> 10fad6: 39 5d 0c cmp %ebx,0xc(%ebp) 10fad9: 0f 82 7d 01 00 00 jb 10fc5c <_Heap_Extend+0x211> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fadf: 39 c7 cmp %eax,%edi 10fae1: 74 06 je 10fae9 <_Heap_Extend+0x9e> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10fae3: 39 df cmp %ebx,%edi 10fae5: 72 07 jb 10faee <_Heap_Extend+0xa3> 10fae7: eb 08 jmp 10faf1 <_Heap_Extend+0xa6> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fae9: 89 4d d0 mov %ecx,-0x30(%ebp) 10faec: eb 03 jmp 10faf1 <_Heap_Extend+0xa6> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10faee: 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); 10faf1: 8d 43 f8 lea -0x8(%ebx),%eax 10faf4: 89 45 d4 mov %eax,-0x2c(%ebp) 10faf7: 89 d8 mov %ebx,%eax 10faf9: 31 d2 xor %edx,%edx 10fafb: 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); 10fafe: 29 55 d4 sub %edx,-0x2c(%ebp) link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 10fb01: 3b 5d 0c cmp 0xc(%ebp),%ebx 10fb04: 75 07 jne 10fb0d <_Heap_Extend+0xc2> start_block->prev_size = extend_area_end; 10fb06: 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 ) 10fb08: 8b 75 d4 mov -0x2c(%ebp),%esi 10fb0b: eb 08 jmp 10fb15 <_Heap_Extend+0xca> merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 10fb0d: 73 06 jae 10fb15 <_Heap_Extend+0xca> 10fb0f: 8b 55 d4 mov -0x2c(%ebp),%edx 10fb12: 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; 10fb15: 8b 45 d4 mov -0x2c(%ebp),%eax 10fb18: 8b 48 04 mov 0x4(%eax),%ecx 10fb1b: 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); 10fb1e: 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 ); 10fb20: 3b 4d c0 cmp -0x40(%ebp),%ecx 10fb23: 75 a9 jne 10face <_Heap_Extend+0x83> 10fb25: 8b 5d b8 mov -0x48(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 10fb28: 8b 55 0c mov 0xc(%ebp),%edx 10fb2b: 3b 53 18 cmp 0x18(%ebx),%edx 10fb2e: 73 05 jae 10fb35 <_Heap_Extend+0xea> heap->area_begin = extend_area_begin; 10fb30: 89 53 18 mov %edx,0x18(%ebx) 10fb33: eb 08 jmp 10fb3d <_Heap_Extend+0xf2> } else if ( heap->area_end < extend_area_end ) { 10fb35: 39 7b 1c cmp %edi,0x1c(%ebx) 10fb38: 73 03 jae 10fb3d <_Heap_Extend+0xf2> heap->area_end = extend_area_end; 10fb3a: 89 7b 1c mov %edi,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 10fb3d: 8b 45 e0 mov -0x20(%ebp),%eax 10fb40: 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 = 10fb43: 89 c1 mov %eax,%ecx 10fb45: 29 d1 sub %edx,%ecx 10fb47: 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; 10fb4a: 89 3a mov %edi,(%edx) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 10fb4c: 83 c9 01 or $0x1,%ecx 10fb4f: 89 4a 04 mov %ecx,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 10fb52: 8b 4d d4 mov -0x2c(%ebp),%ecx 10fb55: 89 08 mov %ecx,(%eax) extend_last_block->size_and_flag = 0; 10fb57: 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 ) { 10fb5e: 39 53 20 cmp %edx,0x20(%ebx) 10fb61: 76 05 jbe 10fb68 <_Heap_Extend+0x11d> heap->first_block = extend_first_block; 10fb63: 89 53 20 mov %edx,0x20(%ebx) 10fb66: eb 08 jmp 10fb70 <_Heap_Extend+0x125> } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 10fb68: 39 43 24 cmp %eax,0x24(%ebx) 10fb6b: 73 03 jae 10fb70 <_Heap_Extend+0x125> heap->last_block = extend_last_block; 10fb6d: 89 43 24 mov %eax,0x24(%ebx) } if ( merge_below_block != NULL ) { 10fb70: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fb74: 74 3b je 10fbb1 <_Heap_Extend+0x166> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 10fb76: 8b 43 10 mov 0x10(%ebx),%eax 10fb79: 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 ); 10fb7c: 8b 4d 0c mov 0xc(%ebp),%ecx 10fb7f: 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; 10fb82: 89 c8 mov %ecx,%eax 10fb84: 31 d2 xor %edx,%edx 10fb86: f7 75 d4 divl -0x2c(%ebp) if ( remainder != 0 ) { 10fb89: 85 d2 test %edx,%edx 10fb8b: 74 05 je 10fb92 <_Heap_Extend+0x147> <== ALWAYS TAKEN return value - remainder + alignment; 10fb8d: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED 10fb90: 29 d1 sub %edx,%ecx <== NOT EXECUTED uintptr_t const new_first_block_begin = 10fb92: 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; 10fb95: 8b 45 d0 mov -0x30(%ebp),%eax 10fb98: 8b 00 mov (%eax),%eax 10fb9a: 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 = 10fb9d: 8b 45 d0 mov -0x30(%ebp),%eax 10fba0: 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; 10fba2: 83 c8 01 or $0x1,%eax 10fba5: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 10fba8: 89 d8 mov %ebx,%eax 10fbaa: e8 81 fe ff ff call 10fa30 <_Heap_Free_block> 10fbaf: eb 14 jmp 10fbc5 <_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 ) { 10fbb1: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10fbb5: 74 0e je 10fbc5 <_Heap_Extend+0x17a> _Heap_Link_below( 10fbb7: 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; 10fbba: 8b 45 c8 mov -0x38(%ebp),%eax 10fbbd: 29 d0 sub %edx,%eax 10fbbf: 83 c8 01 or $0x1,%eax 10fbc2: 89 42 04 mov %eax,0x4(%edx) link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 10fbc5: 85 f6 test %esi,%esi 10fbc7: 74 30 je 10fbf9 <_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, 10fbc9: 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( 10fbcc: 29 f7 sub %esi,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10fbce: 89 f8 mov %edi,%eax 10fbd0: 31 d2 xor %edx,%edx 10fbd2: f7 73 10 divl 0x10(%ebx) 10fbd5: 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) 10fbd7: 8b 46 04 mov 0x4(%esi),%eax 10fbda: 29 f8 sub %edi,%eax | HEAP_PREV_BLOCK_USED; 10fbdc: 83 c8 01 or $0x1,%eax 10fbdf: 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; 10fbe3: 8b 46 04 mov 0x4(%esi),%eax 10fbe6: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 10fbe9: 09 f8 or %edi,%eax 10fbeb: 89 46 04 mov %eax,0x4(%esi) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 10fbee: 89 f2 mov %esi,%edx 10fbf0: 89 d8 mov %ebx,%eax 10fbf2: e8 39 fe ff ff call 10fa30 <_Heap_Free_block> 10fbf7: eb 21 jmp 10fc1a <_Heap_Extend+0x1cf> ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 10fbf9: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10fbfd: 74 1b je 10fc1a <_Heap_Extend+0x1cf> _Heap_Link_above( 10fbff: 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 ); 10fc02: 8b 45 e4 mov -0x1c(%ebp),%eax 10fc05: 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; 10fc08: 8b 7d cc mov -0x34(%ebp),%edi 10fc0b: 8b 57 04 mov 0x4(%edi),%edx 10fc0e: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 10fc11: 09 d0 or %edx,%eax 10fc13: 89 47 04 mov %eax,0x4(%edi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 10fc16: 83 49 04 01 orl $0x1,0x4(%ecx) extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 10fc1a: 85 f6 test %esi,%esi 10fc1c: 75 10 jne 10fc2e <_Heap_Extend+0x1e3> 10fc1e: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fc22: 75 0a jne 10fc2e <_Heap_Extend+0x1e3> _Heap_Free_block( heap, extend_first_block ); 10fc24: 8b 55 e4 mov -0x1c(%ebp),%edx 10fc27: 89 d8 mov %ebx,%eax 10fc29: e8 02 fe ff ff call 10fa30 <_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 10fc2e: 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( 10fc31: 8b 43 20 mov 0x20(%ebx),%eax 10fc34: 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; 10fc36: 8b 4a 04 mov 0x4(%edx),%ecx 10fc39: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 10fc3c: 09 c8 or %ecx,%eax 10fc3e: 89 42 04 mov %eax,0x4(%edx) } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 10fc41: 8b 43 30 mov 0x30(%ebx),%eax 10fc44: 2b 45 bc sub -0x44(%ebp),%eax /* Statistics */ stats->size += extended_size; 10fc47: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 10fc4a: 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 ) 10fc4f: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10fc53: 74 09 je 10fc5e <_Heap_Extend+0x213> <== NEVER TAKEN *extended_size_ptr = extended_size; 10fc55: 8b 55 14 mov 0x14(%ebp),%edx 10fc58: 89 02 mov %eax,(%edx) 10fc5a: eb 02 jmp 10fc5e <_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; 10fc5c: 31 f6 xor %esi,%esi if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 10fc5e: 89 f0 mov %esi,%eax 10fc60: 8d 65 f4 lea -0xc(%ebp),%esp 10fc63: 5b pop %ebx 10fc64: 5e pop %esi 10fc65: 5f pop %edi 10fc66: c9 leave 10fc67: c3 ret =============================================================================== 0010f690 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 10f690: 55 push %ebp 10f691: 89 e5 mov %esp,%ebp 10f693: 57 push %edi 10f694: 56 push %esi 10f695: 53 push %ebx 10f696: 83 ec 14 sub $0x14,%esp 10f699: 8b 4d 08 mov 0x8(%ebp),%ecx 10f69c: 8b 45 0c mov 0xc(%ebp),%eax 10f69f: 8d 58 f8 lea -0x8(%eax),%ebx 10f6a2: 31 d2 xor %edx,%edx 10f6a4: 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); 10f6a7: 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 10f6a9: 8b 41 20 mov 0x20(%ecx),%eax 10f6ac: 89 45 ec mov %eax,-0x14(%ebp) && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f6af: 31 d2 xor %edx,%edx 10f6b1: 39 c3 cmp %eax,%ebx 10f6b3: 72 08 jb 10f6bd <_Heap_Free+0x2d> 10f6b5: 31 d2 xor %edx,%edx 10f6b7: 39 59 24 cmp %ebx,0x24(%ecx) 10f6ba: 0f 93 c2 setae %dl bool next_is_free = false; _Heap_Protection_block_check( heap, block ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 10f6bd: 31 c0 xor %eax,%eax uintptr_t next_block_size = 0; bool next_is_free = false; _Heap_Protection_block_check( heap, block ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { 10f6bf: 85 d2 test %edx,%edx 10f6c1: 0f 84 21 01 00 00 je 10f7e8 <_Heap_Free+0x158> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f6c7: 8b 43 04 mov 0x4(%ebx),%eax 10f6ca: 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; 10f6cd: 89 c6 mov %eax,%esi 10f6cf: 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); 10f6d2: 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; 10f6d5: 31 ff xor %edi,%edi 10f6d7: 3b 55 ec cmp -0x14(%ebp),%edx 10f6da: 72 0a jb 10f6e6 <_Heap_Free+0x56> <== NEVER TAKEN 10f6dc: 31 c0 xor %eax,%eax 10f6de: 39 51 24 cmp %edx,0x24(%ecx) 10f6e1: 0f 93 c0 setae %al 10f6e4: 89 c7 mov %eax,%edi _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { _HAssert( false ); return false; 10f6e6: 31 c0 xor %eax,%eax block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10f6e8: 85 ff test %edi,%edi 10f6ea: 0f 84 f8 00 00 00 je 10f7e8 <_Heap_Free+0x158> <== NEVER TAKEN --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f6f0: 8b 7a 04 mov 0x4(%edx),%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { _HAssert( false ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10f6f3: f7 c7 01 00 00 00 test $0x1,%edi 10f6f9: 0f 84 e9 00 00 00 je 10f7e8 <_Heap_Free+0x158> <== NEVER TAKEN - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10f6ff: 83 e7 fe and $0xfffffffe,%edi 10f702: 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 10f705: 8b 41 24 mov 0x24(%ecx),%eax 10f708: 89 45 e4 mov %eax,-0x1c(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 10f70b: 31 c0 xor %eax,%eax 10f70d: 3b 55 e4 cmp -0x1c(%ebp),%edx 10f710: 74 0a je 10f71c <_Heap_Free+0x8c> 10f712: 31 c0 xor %eax,%eax 10f714: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 10f719: 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 10f71c: 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 ) ) { 10f71f: f6 45 f0 01 testb $0x1,-0x10(%ebp) 10f723: 75 62 jne 10f787 <_Heap_Free+0xf7> uintptr_t const prev_size = block->prev_size; 10f725: 8b 03 mov (%ebx),%eax 10f727: 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); 10f72a: 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; 10f72c: 31 ff xor %edi,%edi 10f72e: 3b 5d ec cmp -0x14(%ebp),%ebx 10f731: 72 0a jb 10f73d <_Heap_Free+0xad> <== NEVER TAKEN 10f733: 31 c0 xor %eax,%eax 10f735: 39 5d e4 cmp %ebx,-0x1c(%ebp) 10f738: 0f 93 c0 setae %al 10f73b: 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 ); 10f73d: 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 ) ) { 10f73f: 85 ff test %edi,%edi 10f741: 0f 84 a1 00 00 00 je 10f7e8 <_Heap_Free+0x158> <== NEVER TAKEN return( false ); } /* As we always coalesce free blocks, the block that preceedes prev_block must have been used. */ if ( !_Heap_Is_prev_used ( prev_block) ) { 10f747: f6 43 04 01 testb $0x1,0x4(%ebx) 10f74b: 0f 84 97 00 00 00 je 10f7e8 <_Heap_Free+0x158> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 10f751: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f755: 74 1a je 10f771 <_Heap_Free+0xe1> uintptr_t const size = block_size + prev_size + next_block_size; 10f757: 8b 45 e8 mov -0x18(%ebp),%eax 10f75a: 8d 04 06 lea (%esi,%eax,1),%eax 10f75d: 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; 10f760: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = block->prev; 10f763: 8b 52 0c mov 0xc(%edx),%edx prev->next = next; 10f766: 89 7a 08 mov %edi,0x8(%edx) next->prev = prev; 10f769: 89 57 0c mov %edx,0xc(%edi) _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 10f76c: ff 49 38 decl 0x38(%ecx) 10f76f: eb 33 jmp 10f7a4 <_Heap_Free+0x114> prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uintptr_t const size = block_size + prev_size; 10f771: 8b 45 f0 mov -0x10(%ebp),%eax 10f774: 8d 04 06 lea (%esi,%eax,1),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f777: 89 c7 mov %eax,%edi 10f779: 83 cf 01 or $0x1,%edi 10f77c: 89 7b 04 mov %edi,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f77f: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 10f783: 89 02 mov %eax,(%edx) 10f785: eb 56 jmp 10f7dd <_Heap_Free+0x14d> } } else if ( next_is_free ) { /* coalesce next */ 10f787: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f78b: 74 24 je 10f7b1 <_Heap_Free+0x121> uintptr_t const size = block_size + next_block_size; 10f78d: 8b 45 e8 mov -0x18(%ebp),%eax 10f790: 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; 10f792: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = old_block->prev; 10f795: 8b 52 0c mov 0xc(%edx),%edx new_block->next = next; 10f798: 89 7b 08 mov %edi,0x8(%ebx) new_block->prev = prev; 10f79b: 89 53 0c mov %edx,0xc(%ebx) next->prev = new_block; 10f79e: 89 5f 0c mov %ebx,0xc(%edi) prev->next = new_block; 10f7a1: 89 5a 08 mov %ebx,0x8(%edx) _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f7a4: 89 c2 mov %eax,%edx 10f7a6: 83 ca 01 or $0x1,%edx 10f7a9: 89 53 04 mov %edx,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 10f7ac: 89 04 03 mov %eax,(%ebx,%eax,1) 10f7af: eb 2c jmp 10f7dd <_Heap_Free+0x14d> RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 10f7b1: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 10f7b4: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 10f7b7: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 10f7ba: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 10f7bd: 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; 10f7c0: 89 f0 mov %esi,%eax 10f7c2: 83 c8 01 or $0x1,%eax 10f7c5: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f7c8: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 10f7cc: 89 32 mov %esi,(%edx) /* Statistics */ ++stats->free_blocks; 10f7ce: 8b 41 38 mov 0x38(%ecx),%eax 10f7d1: 40 inc %eax 10f7d2: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 10f7d5: 39 41 3c cmp %eax,0x3c(%ecx) 10f7d8: 73 03 jae 10f7dd <_Heap_Free+0x14d> stats->max_free_blocks = stats->free_blocks; 10f7da: 89 41 3c mov %eax,0x3c(%ecx) } } /* Statistics */ --stats->used_blocks; 10f7dd: ff 49 40 decl 0x40(%ecx) ++stats->frees; 10f7e0: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 10f7e3: 01 71 30 add %esi,0x30(%ecx) return( true ); 10f7e6: b0 01 mov $0x1,%al } 10f7e8: 83 c4 14 add $0x14,%esp 10f7eb: 5b pop %ebx 10f7ec: 5e pop %esi 10f7ed: 5f pop %edi 10f7ee: c9 leave 10f7ef: c3 ret =============================================================================== 0011cc34 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11cc34: 55 push %ebp 11cc35: 89 e5 mov %esp,%ebp 11cc37: 57 push %edi 11cc38: 56 push %esi 11cc39: 53 push %ebx 11cc3a: 8b 5d 08 mov 0x8(%ebp),%ebx 11cc3d: 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); 11cc40: 8d 4e f8 lea -0x8(%esi),%ecx 11cc43: 89 f0 mov %esi,%eax 11cc45: 31 d2 xor %edx,%edx 11cc47: 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); 11cc4a: 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 11cc4c: 8b 53 20 mov 0x20(%ebx),%edx && (uintptr_t) block <= (uintptr_t) heap->last_block; 11cc4f: 31 ff xor %edi,%edi 11cc51: 39 d1 cmp %edx,%ecx 11cc53: 72 0a jb 11cc5f <_Heap_Size_of_alloc_area+0x2b> 11cc55: 31 c0 xor %eax,%eax 11cc57: 39 4b 24 cmp %ecx,0x24(%ebx) 11cc5a: 0f 93 c0 setae %al 11cc5d: 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; 11cc5f: 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 ) ) { 11cc61: 85 ff test %edi,%edi 11cc63: 74 30 je 11cc95 <_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; 11cc65: 8b 41 04 mov 0x4(%ecx),%eax 11cc68: 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); 11cc6b: 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; 11cc6d: 31 ff xor %edi,%edi 11cc6f: 39 d1 cmp %edx,%ecx 11cc71: 72 0a jb 11cc7d <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN 11cc73: 31 c0 xor %eax,%eax 11cc75: 39 4b 24 cmp %ecx,0x24(%ebx) 11cc78: 0f 93 c0 setae %al 11cc7b: 89 c7 mov %eax,%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) ) { return false; 11cc7d: 31 c0 xor %eax,%eax } block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( 11cc7f: 85 ff test %edi,%edi 11cc81: 74 12 je 11cc95 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 11cc83: f6 41 04 01 testb $0x1,0x4(%ecx) 11cc87: 74 0c je 11cc95 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11cc89: 29 f1 sub %esi,%ecx 11cc8b: 8d 51 04 lea 0x4(%ecx),%edx 11cc8e: 8b 45 10 mov 0x10(%ebp),%eax 11cc91: 89 10 mov %edx,(%eax) return true; 11cc93: b0 01 mov $0x1,%al } 11cc95: 5b pop %ebx 11cc96: 5e pop %esi 11cc97: 5f pop %edi 11cc98: c9 leave 11cc99: c3 ret =============================================================================== 0010bc16 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10bc16: 55 push %ebp 10bc17: 89 e5 mov %esp,%ebp 10bc19: 57 push %edi 10bc1a: 56 push %esi 10bc1b: 53 push %ebx 10bc1c: 83 ec 4c sub $0x4c,%esp 10bc1f: 8b 75 08 mov 0x8(%ebp),%esi 10bc22: 8b 5d 0c mov 0xc(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10bc25: 8b 46 10 mov 0x10(%esi),%eax 10bc28: 89 45 d8 mov %eax,-0x28(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10bc2b: 8b 4e 14 mov 0x14(%esi),%ecx 10bc2e: 89 4d d4 mov %ecx,-0x2c(%ebp) Heap_Block *const first_block = heap->first_block; 10bc31: 8b 46 20 mov 0x20(%esi),%eax 10bc34: 89 45 d0 mov %eax,-0x30(%ebp) Heap_Block *const last_block = heap->last_block; 10bc37: 8b 4e 24 mov 0x24(%esi),%ecx 10bc3a: 89 4d c8 mov %ecx,-0x38(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10bc3d: c7 45 e4 d8 bb 10 00 movl $0x10bbd8,-0x1c(%ebp) 10bc44: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10bc48: 74 07 je 10bc51 <_Heap_Walk+0x3b> 10bc4a: c7 45 e4 dd bb 10 00 movl $0x10bbdd,-0x1c(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; 10bc51: 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() ) ) { 10bc53: 83 3d e4 64 12 00 03 cmpl $0x3,0x1264e4 10bc5a: 0f 85 e8 02 00 00 jne 10bf48 <_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)( 10bc60: 52 push %edx 10bc61: ff 76 0c pushl 0xc(%esi) 10bc64: ff 76 08 pushl 0x8(%esi) 10bc67: ff 75 c8 pushl -0x38(%ebp) 10bc6a: ff 75 d0 pushl -0x30(%ebp) 10bc6d: ff 76 1c pushl 0x1c(%esi) 10bc70: ff 76 18 pushl 0x18(%esi) 10bc73: ff 75 d4 pushl -0x2c(%ebp) 10bc76: ff 75 d8 pushl -0x28(%ebp) 10bc79: 68 b1 f7 11 00 push $0x11f7b1 10bc7e: 6a 00 push $0x0 10bc80: 53 push %ebx 10bc81: 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 ) { 10bc84: 83 c4 30 add $0x30,%esp 10bc87: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10bc8b: 75 0b jne 10bc98 <_Heap_Walk+0x82> (*printer)( source, true, "page size is zero\n" ); 10bc8d: 50 push %eax 10bc8e: 68 42 f8 11 00 push $0x11f842 10bc93: e9 6b 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10bc98: f6 45 d8 03 testb $0x3,-0x28(%ebp) 10bc9c: 74 0d je 10bcab <_Heap_Walk+0x95> (*printer)( 10bc9e: ff 75 d8 pushl -0x28(%ebp) 10bca1: 68 55 f8 11 00 push $0x11f855 10bca6: e9 58 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bcab: 8b 45 d4 mov -0x2c(%ebp),%eax 10bcae: 31 d2 xor %edx,%edx 10bcb0: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10bcb3: 85 d2 test %edx,%edx 10bcb5: 74 0d je 10bcc4 <_Heap_Walk+0xae> (*printer)( 10bcb7: ff 75 d4 pushl -0x2c(%ebp) 10bcba: 68 73 f8 11 00 push $0x11f873 10bcbf: e9 3f 02 00 00 jmp 10bf03 <_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; 10bcc4: 8b 45 d0 mov -0x30(%ebp),%eax 10bcc7: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bcca: 31 d2 xor %edx,%edx 10bccc: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( 10bccf: 85 d2 test %edx,%edx 10bcd1: 74 0d je 10bce0 <_Heap_Walk+0xca> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10bcd3: ff 75 d0 pushl -0x30(%ebp) 10bcd6: 68 97 f8 11 00 push $0x11f897 10bcdb: e9 23 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10bce0: 8b 45 d0 mov -0x30(%ebp),%eax 10bce3: f6 40 04 01 testb $0x1,0x4(%eax) 10bce7: 75 0b jne 10bcf4 <_Heap_Walk+0xde> (*printer)( 10bce9: 57 push %edi 10bcea: 68 c8 f8 11 00 push $0x11f8c8 10bcef: e9 0f 02 00 00 jmp 10bf03 <_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; 10bcf4: 8b 4d c8 mov -0x38(%ebp),%ecx 10bcf7: 8b 79 04 mov 0x4(%ecx),%edi 10bcfa: 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); 10bcfd: 01 cf add %ecx,%edi ); return false; } if ( _Heap_Is_free( last_block ) ) { 10bcff: f6 47 04 01 testb $0x1,0x4(%edi) 10bd03: 75 0b jne 10bd10 <_Heap_Walk+0xfa> (*printer)( 10bd05: 56 push %esi 10bd06: 68 f6 f8 11 00 push $0x11f8f6 10bd0b: e9 f3 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> ); return false; } if ( 10bd10: 3b 7d d0 cmp -0x30(%ebp),%edi 10bd13: 74 0b je 10bd20 <_Heap_Walk+0x10a> <== ALWAYS TAKEN _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10bd15: 51 push %ecx <== NOT EXECUTED 10bd16: 68 0b f9 11 00 push $0x11f90b <== NOT EXECUTED 10bd1b: e9 e3 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> <== NOT EXECUTED int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10bd20: 8b 46 10 mov 0x10(%esi),%eax 10bd23: 89 45 e0 mov %eax,-0x20(%ebp) block = next_block; } while ( block != first_block ); return true; } 10bd26: 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 ); 10bd29: 89 75 dc mov %esi,-0x24(%ebp) 10bd2c: eb 75 jmp 10bda3 <_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; 10bd2e: 31 c0 xor %eax,%eax 10bd30: 39 4e 20 cmp %ecx,0x20(%esi) 10bd33: 77 08 ja 10bd3d <_Heap_Walk+0x127> 10bd35: 31 c0 xor %eax,%eax 10bd37: 39 4e 24 cmp %ecx,0x24(%esi) 10bd3a: 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 ) ) { 10bd3d: 85 c0 test %eax,%eax 10bd3f: 75 0b jne 10bd4c <_Heap_Walk+0x136> (*printer)( 10bd41: 51 push %ecx 10bd42: 68 3a f9 11 00 push $0x11f93a 10bd47: e9 b7 01 00 00 jmp 10bf03 <_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; 10bd4c: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bd4f: 31 d2 xor %edx,%edx 10bd51: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10bd54: 85 d2 test %edx,%edx 10bd56: 74 0b je 10bd63 <_Heap_Walk+0x14d> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10bd58: 51 push %ecx 10bd59: 68 5a f9 11 00 push $0x11f95a 10bd5e: e9 a0 01 00 00 jmp 10bf03 <_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; 10bd63: 8b 41 04 mov 0x4(%ecx),%eax 10bd66: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10bd69: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10bd6e: 74 0b je 10bd7b <_Heap_Walk+0x165> (*printer)( 10bd70: 51 push %ecx 10bd71: 68 8a f9 11 00 push $0x11f98a 10bd76: e9 88 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> ); return false; } if ( free_block->prev != prev_block ) { 10bd7b: 8b 41 0c mov 0xc(%ecx),%eax 10bd7e: 3b 45 dc cmp -0x24(%ebp),%eax 10bd81: 74 1a je 10bd9d <_Heap_Walk+0x187> (*printer)( 10bd83: 83 ec 0c sub $0xc,%esp 10bd86: 50 push %eax 10bd87: 51 push %ecx 10bd88: 68 a6 f9 11 00 push $0x11f9a6 10bd8d: 6a 01 push $0x1 10bd8f: 53 push %ebx 10bd90: ff 55 e4 call *-0x1c(%ebp) 10bd93: 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; 10bd96: 31 c0 xor %eax,%eax 10bd98: e9 ab 01 00 00 jmp 10bf48 <_Heap_Walk+0x332> return false; } prev_block = free_block; free_block = free_block->next; 10bd9d: 89 4d dc mov %ecx,-0x24(%ebp) 10bda0: 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 ) { 10bda3: 39 f1 cmp %esi,%ecx 10bda5: 75 87 jne 10bd2e <_Heap_Walk+0x118> 10bda7: 89 5d dc mov %ebx,-0x24(%ebp) 10bdaa: eb 02 jmp 10bdae <_Heap_Walk+0x198> block->prev_size ); } block = next_block; } while ( block != first_block ); 10bdac: 89 df mov %ebx,%edi return true; } 10bdae: 8b 4f 04 mov 0x4(%edi),%ecx 10bdb1: 89 4d cc mov %ecx,-0x34(%ebp) 10bdb4: 83 e1 fe and $0xfffffffe,%ecx 10bdb7: 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); 10bdba: 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; 10bdbd: 31 c0 xor %eax,%eax 10bdbf: 39 5e 20 cmp %ebx,0x20(%esi) 10bdc2: 77 08 ja 10bdcc <_Heap_Walk+0x1b6> <== NEVER TAKEN 10bdc4: 31 c0 xor %eax,%eax 10bdc6: 39 5e 24 cmp %ebx,0x24(%esi) 10bdc9: 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 ) ) { 10bdcc: 85 c0 test %eax,%eax 10bdce: 75 11 jne 10bde1 <_Heap_Walk+0x1cb> 10bdd0: 89 d9 mov %ebx,%ecx 10bdd2: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bdd5: 83 ec 0c sub $0xc,%esp 10bdd8: 51 push %ecx 10bdd9: 57 push %edi 10bdda: 68 d8 f9 11 00 push $0x11f9d8 10bddf: eb ac jmp 10bd8d <_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; 10bde1: 3b 7d c8 cmp -0x38(%ebp),%edi 10bde4: 0f 95 c1 setne %cl RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bde7: 8b 45 e0 mov -0x20(%ebp),%eax 10bdea: 31 d2 xor %edx,%edx 10bdec: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10bdef: 85 d2 test %edx,%edx 10bdf1: 74 15 je 10be08 <_Heap_Walk+0x1f2> 10bdf3: 84 c9 test %cl,%cl 10bdf5: 74 11 je 10be08 <_Heap_Walk+0x1f2> 10bdf7: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bdfa: 83 ec 0c sub $0xc,%esp 10bdfd: ff 75 e0 pushl -0x20(%ebp) 10be00: 57 push %edi 10be01: 68 05 fa 11 00 push $0x11fa05 10be06: eb 85 jmp 10bd8d <_Heap_Walk+0x177> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10be08: 8b 45 d4 mov -0x2c(%ebp),%eax 10be0b: 39 45 e0 cmp %eax,-0x20(%ebp) 10be0e: 73 18 jae 10be28 <_Heap_Walk+0x212> 10be10: 84 c9 test %cl,%cl 10be12: 74 14 je 10be28 <_Heap_Walk+0x212> <== NEVER TAKEN 10be14: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be17: 52 push %edx 10be18: 52 push %edx 10be19: 50 push %eax 10be1a: ff 75 e0 pushl -0x20(%ebp) 10be1d: 57 push %edi 10be1e: 68 33 fa 11 00 push $0x11fa33 10be23: e9 65 ff ff ff jmp 10bd8d <_Heap_Walk+0x177> ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10be28: 39 fb cmp %edi,%ebx 10be2a: 77 18 ja 10be44 <_Heap_Walk+0x22e> 10be2c: 84 c9 test %cl,%cl 10be2e: 74 14 je 10be44 <_Heap_Walk+0x22e> 10be30: 89 d9 mov %ebx,%ecx 10be32: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be35: 83 ec 0c sub $0xc,%esp 10be38: 51 push %ecx 10be39: 57 push %edi 10be3a: 68 5e fa 11 00 push $0x11fa5e 10be3f: e9 49 ff ff ff jmp 10bd8d <_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; 10be44: 8b 4d cc mov -0x34(%ebp),%ecx 10be47: 83 e1 01 and $0x1,%ecx 10be4a: 89 4d c4 mov %ecx,-0x3c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10be4d: f6 43 04 01 testb $0x1,0x4(%ebx) 10be51: 0f 85 ba 00 00 00 jne 10bf11 <_Heap_Walk+0x2fb> block = next_block; } while ( block != first_block ); return true; } 10be57: 8b 46 08 mov 0x8(%esi),%eax 10be5a: 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 ? 10be5d: 8b 4f 08 mov 0x8(%edi),%ecx 10be60: 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)( 10be63: ba 7e f7 11 00 mov $0x11f77e,%edx 10be68: 3b 4e 0c cmp 0xc(%esi),%ecx 10be6b: 74 0e je 10be7b <_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)" : "") 10be6d: ba b5 f6 11 00 mov $0x11f6b5,%edx 10be72: 39 f1 cmp %esi,%ecx 10be74: 75 05 jne 10be7b <_Heap_Walk+0x265> 10be76: ba 8d f7 11 00 mov $0x11f78d,%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 ? 10be7b: 8b 47 0c mov 0xc(%edi),%eax 10be7e: 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)( 10be81: b8 97 f7 11 00 mov $0x11f797,%eax 10be86: 8b 4d c0 mov -0x40(%ebp),%ecx 10be89: 39 4d cc cmp %ecx,-0x34(%ebp) 10be8c: 74 0f je 10be9d <_Heap_Walk+0x287> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10be8e: b8 b5 f6 11 00 mov $0x11f6b5,%eax 10be93: 39 75 cc cmp %esi,-0x34(%ebp) 10be96: 75 05 jne 10be9d <_Heap_Walk+0x287> 10be98: b8 a7 f7 11 00 mov $0x11f7a7,%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)( 10be9d: 83 ec 0c sub $0xc,%esp 10bea0: 52 push %edx 10bea1: ff 75 b4 pushl -0x4c(%ebp) 10bea4: 50 push %eax 10bea5: ff 75 cc pushl -0x34(%ebp) 10bea8: ff 75 e0 pushl -0x20(%ebp) 10beab: 57 push %edi 10beac: 68 92 fa 11 00 push $0x11fa92 10beb1: 6a 00 push $0x0 10beb3: ff 75 dc pushl -0x24(%ebp) 10beb6: 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 ) { 10beb9: 8b 03 mov (%ebx),%eax 10bebb: 83 c4 30 add $0x30,%esp 10bebe: 39 45 e0 cmp %eax,-0x20(%ebp) 10bec1: 74 16 je 10bed9 <_Heap_Walk+0x2c3> 10bec3: 89 d9 mov %ebx,%ecx 10bec5: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bec8: 56 push %esi 10bec9: 51 push %ecx 10beca: 50 push %eax 10becb: ff 75 e0 pushl -0x20(%ebp) 10bece: 57 push %edi 10becf: 68 c7 fa 11 00 push $0x11fac7 10bed4: e9 b4 fe ff ff jmp 10bd8d <_Heap_Walk+0x177> ); return false; } if ( !prev_used ) { 10bed9: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bedd: 75 0b jne 10beea <_Heap_Walk+0x2d4> 10bedf: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bee2: 57 push %edi 10bee3: 68 00 fb 11 00 push $0x11fb00 10bee8: eb 19 jmp 10bf03 <_Heap_Walk+0x2ed> block = next_block; } while ( block != first_block ); return true; } 10beea: 8b 46 08 mov 0x8(%esi),%eax 10beed: eb 07 jmp 10bef6 <_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 ) { 10beef: 39 f8 cmp %edi,%eax 10bef1: 74 4a je 10bf3d <_Heap_Walk+0x327> return true; } free_block = free_block->next; 10bef3: 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 ) { 10bef6: 39 f0 cmp %esi,%eax 10bef8: 75 f5 jne 10beef <_Heap_Walk+0x2d9> 10befa: 8b 5d dc mov -0x24(%ebp),%ebx return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10befd: 57 push %edi 10befe: 68 6b fb 11 00 push $0x11fb6b 10bf03: 6a 01 push $0x1 10bf05: 53 push %ebx 10bf06: ff 55 e4 call *-0x1c(%ebp) 10bf09: 83 c4 10 add $0x10,%esp 10bf0c: e9 85 fe ff ff jmp 10bd96 <_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) { 10bf11: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bf15: 74 0e je 10bf25 <_Heap_Walk+0x30f> (*printer)( 10bf17: 83 ec 0c sub $0xc,%esp 10bf1a: ff 75 e0 pushl -0x20(%ebp) 10bf1d: 57 push %edi 10bf1e: 68 2f fb 11 00 push $0x11fb2f 10bf23: eb 0d jmp 10bf32 <_Heap_Walk+0x31c> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10bf25: 51 push %ecx 10bf26: 51 push %ecx 10bf27: ff 37 pushl (%edi) 10bf29: ff 75 e0 pushl -0x20(%ebp) 10bf2c: 57 push %edi 10bf2d: 68 46 fb 11 00 push $0x11fb46 10bf32: 6a 00 push $0x0 10bf34: ff 75 dc pushl -0x24(%ebp) 10bf37: ff 55 e4 call *-0x1c(%ebp) 10bf3a: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10bf3d: 3b 5d d0 cmp -0x30(%ebp),%ebx 10bf40: 0f 85 66 fe ff ff jne 10bdac <_Heap_Walk+0x196> return true; 10bf46: b0 01 mov $0x1,%al } 10bf48: 8d 65 f4 lea -0xc(%ebp),%esp 10bf4b: 5b pop %ebx 10bf4c: 5e pop %esi 10bf4d: 5f pop %edi 10bf4e: c9 leave 10bf4f: c3 ret =============================================================================== 0010b238 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10b238: 55 push %ebp 10b239: 89 e5 mov %esp,%ebp 10b23b: 53 push %ebx 10b23c: 83 ec 08 sub $0x8,%esp 10b23f: 8b 45 08 mov 0x8(%ebp),%eax 10b242: 8b 55 0c mov 0xc(%ebp),%edx 10b245: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10b248: a3 98 43 12 00 mov %eax,0x124398 _Internal_errors_What_happened.is_internal = is_internal; 10b24d: 88 15 9c 43 12 00 mov %dl,0x12439c _Internal_errors_What_happened.the_error = the_error; 10b253: 89 1d a0 43 12 00 mov %ebx,0x1243a0 _User_extensions_Fatal( the_source, is_internal, the_error ); 10b259: 53 push %ebx 10b25a: 0f b6 d2 movzbl %dl,%edx 10b25d: 52 push %edx 10b25e: 50 push %eax 10b25f: e8 f7 19 00 00 call 10cc5b <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10b264: c7 05 5c 44 12 00 05 movl $0x5,0x12445c <== NOT EXECUTED 10b26b: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b26e: fa cli <== NOT EXECUTED 10b26f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b271: f4 hlt <== NOT EXECUTED 10b272: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b275: eb fe jmp 10b275 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010b2c8 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b2c8: 55 push %ebp 10b2c9: 89 e5 mov %esp,%ebp 10b2cb: 56 push %esi 10b2cc: 53 push %ebx 10b2cd: 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; 10b2d0: 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 ) 10b2d2: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10b2d6: 74 53 je 10b32b <_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 ); 10b2d8: 8d 73 20 lea 0x20(%ebx),%esi 10b2db: 83 ec 0c sub $0xc,%esp 10b2de: 56 push %esi 10b2df: e8 38 f7 ff ff call 10aa1c <_Chain_Get> 10b2e4: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10b2e6: 83 c4 10 add $0x10,%esp 10b2e9: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10b2ed: 74 3c je 10b32b <_Objects_Allocate+0x63> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b2ef: 85 c0 test %eax,%eax 10b2f1: 75 1a jne 10b30d <_Objects_Allocate+0x45> _Objects_Extend_information( information ); 10b2f3: 83 ec 0c sub $0xc,%esp 10b2f6: 53 push %ebx 10b2f7: e8 60 00 00 00 call 10b35c <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b2fc: 89 34 24 mov %esi,(%esp) 10b2ff: e8 18 f7 ff ff call 10aa1c <_Chain_Get> 10b304: 89 c1 mov %eax,%ecx } if ( the_object ) { 10b306: 83 c4 10 add $0x10,%esp 10b309: 85 c0 test %eax,%eax 10b30b: 74 1e je 10b32b <_Objects_Allocate+0x63> uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10b30d: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10b311: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10b315: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10b317: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10b31b: 31 d2 xor %edx,%edx 10b31d: f7 f6 div %esi information->inactive_per_block[ block ]--; 10b31f: c1 e0 02 shl $0x2,%eax 10b322: 03 43 30 add 0x30(%ebx),%eax 10b325: ff 08 decl (%eax) information->inactive--; 10b327: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10b32b: 89 c8 mov %ecx,%eax 10b32d: 8d 65 f8 lea -0x8(%ebp),%esp 10b330: 5b pop %ebx 10b331: 5e pop %esi 10b332: c9 leave 10b333: c3 ret =============================================================================== 0010b650 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10b650: 55 push %ebp 10b651: 89 e5 mov %esp,%ebp 10b653: 57 push %edi 10b654: 56 push %esi 10b655: 53 push %ebx 10b656: 83 ec 0c sub $0xc,%esp 10b659: 8b 75 08 mov 0x8(%ebp),%esi 10b65c: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 10b65f: 31 db xor %ebx,%ebx ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10b661: 66 85 ff test %di,%di 10b664: 74 37 je 10b69d <_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 ); 10b666: 83 ec 0c sub $0xc,%esp 10b669: 56 push %esi 10b66a: e8 81 41 00 00 call 10f7f0 <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10b66f: 83 c4 10 add $0x10,%esp 10b672: 85 c0 test %eax,%eax 10b674: 74 27 je 10b69d <_Objects_Get_information+0x4d> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10b676: 0f b7 ff movzwl %di,%edi 10b679: 39 c7 cmp %eax,%edi 10b67b: 77 20 ja 10b69d <_Objects_Get_information+0x4d> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b67d: 8b 04 b5 b8 42 12 00 mov 0x1242b8(,%esi,4),%eax 10b684: 85 c0 test %eax,%eax 10b686: 74 15 je 10b69d <_Objects_Get_information+0x4d><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10b688: 8b 1c b8 mov (%eax,%edi,4),%ebx if ( !info ) 10b68b: 85 db test %ebx,%ebx 10b68d: 74 0e je 10b69d <_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; 10b68f: 31 c0 xor %eax,%eax 10b691: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx) 10b696: 0f 95 c0 setne %al 10b699: f7 d8 neg %eax 10b69b: 21 c3 and %eax,%ebx #endif return info; } 10b69d: 89 d8 mov %ebx,%eax 10b69f: 8d 65 f4 lea -0xc(%ebp),%esp 10b6a2: 5b pop %ebx 10b6a3: 5e pop %esi 10b6a4: 5f pop %edi 10b6a5: c9 leave 10b6a6: c3 ret =============================================================================== 00118ab4 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 118ab4: 55 push %ebp 118ab5: 89 e5 mov %esp,%ebp 118ab7: 53 push %ebx 118ab8: 8b 55 08 mov 0x8(%ebp),%edx 118abb: 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; 118abe: b8 01 00 00 00 mov $0x1,%eax 118ac3: 2b 42 08 sub 0x8(%edx),%eax 118ac6: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 118ac9: 0f b7 5a 10 movzwl 0x10(%edx),%ebx 118acd: 39 c3 cmp %eax,%ebx 118acf: 72 12 jb 118ae3 <_Objects_Get_no_protection+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { 118ad1: 8b 52 1c mov 0x1c(%edx),%edx 118ad4: 8b 04 82 mov (%edx,%eax,4),%eax 118ad7: 85 c0 test %eax,%eax 118ad9: 74 08 je 118ae3 <_Objects_Get_no_protection+0x2f><== NEVER TAKEN *location = OBJECTS_LOCAL; 118adb: c7 01 00 00 00 00 movl $0x0,(%ecx) return the_object; 118ae1: eb 08 jmp 118aeb <_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; 118ae3: c7 01 01 00 00 00 movl $0x1,(%ecx) return NULL; 118ae9: 31 c0 xor %eax,%eax } 118aeb: 5b pop %ebx 118aec: c9 leave 118aed: c3 ret =============================================================================== 0010c86c <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10c86c: 55 push %ebp 10c86d: 89 e5 mov %esp,%ebp 10c86f: 53 push %ebx 10c870: 83 ec 14 sub $0x14,%esp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10c873: 8b 45 08 mov 0x8(%ebp),%eax 10c876: 85 c0 test %eax,%eax 10c878: 75 08 jne 10c882 <_Objects_Id_to_name+0x16> 10c87a: a1 94 78 12 00 mov 0x127894,%eax 10c87f: 8b 40 08 mov 0x8(%eax),%eax 10c882: 89 c2 mov %eax,%edx 10c884: c1 ea 18 shr $0x18,%edx 10c887: 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 ) 10c88a: 8d 4a ff lea -0x1(%edx),%ecx the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 10c88d: bb 03 00 00 00 mov $0x3,%ebx 10c892: 83 f9 02 cmp $0x2,%ecx 10c895: 77 36 ja 10c8cd <_Objects_Id_to_name+0x61> 10c897: eb 3b jmp 10c8d4 <_Objects_Id_to_name+0x68> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10c899: 89 c1 mov %eax,%ecx 10c89b: 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 ]; 10c89e: 8b 14 8a mov (%edx,%ecx,4),%edx if ( !information ) 10c8a1: 85 d2 test %edx,%edx 10c8a3: 74 28 je 10c8cd <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10c8a5: 80 7a 38 00 cmpb $0x0,0x38(%edx) 10c8a9: 75 22 jne 10c8cd <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 10c8ab: 51 push %ecx 10c8ac: 8d 4d f4 lea -0xc(%ebp),%ecx 10c8af: 51 push %ecx 10c8b0: 50 push %eax 10c8b1: 52 push %edx 10c8b2: e8 5d ff ff ff call 10c814 <_Objects_Get> if ( !the_object ) 10c8b7: 83 c4 10 add $0x10,%esp 10c8ba: 85 c0 test %eax,%eax 10c8bc: 74 0f je 10c8cd <_Objects_Id_to_name+0x61> return OBJECTS_INVALID_ID; *name = the_object->name; 10c8be: 8b 50 0c mov 0xc(%eax),%edx 10c8c1: 8b 45 0c mov 0xc(%ebp),%eax 10c8c4: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10c8c6: e8 9f 09 00 00 call 10d26a <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10c8cb: 31 db xor %ebx,%ebx } 10c8cd: 89 d8 mov %ebx,%eax 10c8cf: 8b 5d fc mov -0x4(%ebp),%ebx 10c8d2: c9 leave 10c8d3: 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 ] ) 10c8d4: 8b 14 95 24 73 12 00 mov 0x127324(,%edx,4),%edx 10c8db: 85 d2 test %edx,%edx 10c8dd: 75 ba jne 10c899 <_Objects_Id_to_name+0x2d> 10c8df: eb ec jmp 10c8cd <_Objects_Id_to_name+0x61> =============================================================================== 0010e2bc <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10e2bc: 55 push %ebp 10e2bd: 89 e5 mov %esp,%ebp 10e2bf: 57 push %edi 10e2c0: 56 push %esi 10e2c1: 53 push %ebx 10e2c2: 83 ec 30 sub $0x30,%esp 10e2c5: 8b 75 08 mov 0x8(%ebp),%esi 10e2c8: 8b 5d 14 mov 0x14(%ebp),%ebx 10e2cb: 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 ); 10e2ce: 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( 10e2d1: 50 push %eax 10e2d2: 56 push %esi 10e2d3: 68 f0 cc 12 00 push $0x12ccf0 10e2d8: 88 55 d4 mov %dl,-0x2c(%ebp) 10e2db: e8 f4 2a 00 00 call 110dd4 <_Objects_Get> switch ( location ) { 10e2e0: 83 c4 10 add $0x10,%esp 10e2e3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10e2e7: 8a 55 d4 mov -0x2c(%ebp),%dl 10e2ea: 0f 85 aa 00 00 00 jne 10e39a <_POSIX_Message_queue_Receive_support+0xde> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10e2f0: 8b 78 14 mov 0x14(%eax),%edi 10e2f3: 89 f9 mov %edi,%ecx 10e2f5: 83 e1 03 and $0x3,%ecx 10e2f8: 49 dec %ecx 10e2f9: 75 0a jne 10e305 <_POSIX_Message_queue_Receive_support+0x49> _Thread_Enable_dispatch(); 10e2fb: e8 26 35 00 00 call 111826 <_Thread_Enable_dispatch> 10e300: e9 95 00 00 00 jmp 10e39a <_POSIX_Message_queue_Receive_support+0xde> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10e305: 8b 40 10 mov 0x10(%eax),%eax if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10e308: 8b 48 68 mov 0x68(%eax),%ecx 10e30b: 39 4d 10 cmp %ecx,0x10(%ebp) 10e30e: 73 15 jae 10e325 <_POSIX_Message_queue_Receive_support+0x69> _Thread_Enable_dispatch(); 10e310: e8 11 35 00 00 call 111826 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10e315: e8 6a 8b 00 00 call 116e84 <__errno> 10e31a: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10e320: e9 80 00 00 00 jmp 10e3a5 <_POSIX_Message_queue_Receive_support+0xe9> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10e325: 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 ) 10e32c: 31 c9 xor %ecx,%ecx 10e32e: 84 d2 test %dl,%dl 10e330: 74 09 je 10e33b <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true; 10e332: 81 e7 00 40 00 00 and $0x4000,%edi 10e338: 0f 94 c1 sete %cl do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10e33b: 52 push %edx 10e33c: 52 push %edx 10e33d: ff 75 1c pushl 0x1c(%ebp) 10e340: 0f b6 c9 movzbl %cl,%ecx 10e343: 51 push %ecx 10e344: 8d 55 e0 lea -0x20(%ebp),%edx 10e347: 52 push %edx 10e348: ff 75 0c pushl 0xc(%ebp) 10e34b: 56 push %esi 10e34c: 83 c0 1c add $0x1c,%eax 10e34f: 50 push %eax 10e350: e8 7f 1c 00 00 call 10ffd4 <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10e355: 83 c4 20 add $0x20,%esp 10e358: e8 c9 34 00 00 call 111826 <_Thread_Enable_dispatch> *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10e35d: a1 68 cd 12 00 mov 0x12cd68,%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); 10e362: 8b 50 24 mov 0x24(%eax),%edx 10e365: c1 fa 1f sar $0x1f,%edx 10e368: 8b 48 24 mov 0x24(%eax),%ecx 10e36b: 31 d1 xor %edx,%ecx 10e36d: 89 0b mov %ecx,(%ebx) 10e36f: 29 13 sub %edx,(%ebx) if ( !_Thread_Executing->Wait.return_code ) 10e371: 83 78 34 00 cmpl $0x0,0x34(%eax) 10e375: 75 05 jne 10e37c <_POSIX_Message_queue_Receive_support+0xc0> return length_out; 10e377: 8b 45 e0 mov -0x20(%ebp),%eax 10e37a: eb 2c jmp 10e3a8 <_POSIX_Message_queue_Receive_support+0xec> rtems_set_errno_and_return_minus_one( 10e37c: e8 03 8b 00 00 call 116e84 <__errno> 10e381: 89 c3 mov %eax,%ebx 10e383: 83 ec 0c sub $0xc,%esp 10e386: a1 68 cd 12 00 mov 0x12cd68,%eax 10e38b: ff 70 34 pushl 0x34(%eax) 10e38e: e8 ed 01 00 00 call 10e580 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10e393: 89 03 mov %eax,(%ebx) 10e395: 83 c4 10 add $0x10,%esp 10e398: eb 0b jmp 10e3a5 <_POSIX_Message_queue_Receive_support+0xe9> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e39a: e8 e5 8a 00 00 call 116e84 <__errno> 10e39f: c7 00 09 00 00 00 movl $0x9,(%eax) 10e3a5: 83 c8 ff or $0xffffffff,%eax } 10e3a8: 8d 65 f4 lea -0xc(%ebp),%esp 10e3ab: 5b pop %ebx 10e3ac: 5e pop %esi 10e3ad: 5f pop %edi 10e3ae: c9 leave 10e3af: c3 ret =============================================================================== 0010e94c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 10e94c: 55 push %ebp 10e94d: 89 e5 mov %esp,%ebp 10e94f: 83 ec 08 sub $0x8,%esp 10e952: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e955: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10e95b: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10e962: 75 2c jne 10e990 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN 10e964: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 10e96b: 75 23 jne 10e990 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44> thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 10e96d: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10e974: 74 1a je 10e990 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10e976: a1 d0 52 12 00 mov 0x1252d0,%eax 10e97b: 48 dec %eax 10e97c: a3 d0 52 12 00 mov %eax,0x1252d0 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 10e981: 50 push %eax 10e982: 50 push %eax 10e983: 6a ff push $0xffffffff 10e985: 52 push %edx 10e986: e8 51 08 00 00 call 10f1dc <_POSIX_Thread_Exit> 10e98b: 83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 10e98e: c9 leave 10e98f: c3 ret 10e990: c9 leave thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); } else _Thread_Enable_dispatch(); 10e991: e9 e8 da ff ff jmp 10c47e <_Thread_Enable_dispatch> =============================================================================== 0010fbe4 <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 10fbe4: 55 push %ebp 10fbe5: 89 e5 mov %esp,%ebp 10fbe7: 57 push %edi 10fbe8: 56 push %esi 10fbe9: 53 push %ebx 10fbea: 83 ec 28 sub $0x28,%esp 10fbed: 8b 55 08 mov 0x8(%ebp),%edx 10fbf0: 8b 5d 0c mov 0xc(%ebp),%ebx 10fbf3: 8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10fbf6: ff 33 pushl (%ebx) 10fbf8: 89 55 e0 mov %edx,-0x20(%ebp) 10fbfb: e8 c4 ff ff ff call 10fbc4 <_POSIX_Priority_Is_valid> 10fc00: 83 c4 10 add $0x10,%esp return EINVAL; 10fc03: 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 ) ) 10fc08: 84 c0 test %al,%al 10fc0a: 8b 55 e0 mov -0x20(%ebp),%edx 10fc0d: 0f 84 a4 00 00 00 je 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10fc13: c7 07 00 00 00 00 movl $0x0,(%edi) *budget_callout = NULL; 10fc19: 8b 45 14 mov 0x14(%ebp),%eax 10fc1c: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 10fc22: 85 d2 test %edx,%edx 10fc24: 75 0b jne 10fc31 <_POSIX_Thread_Translate_sched_param+0x4d> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10fc26: c7 07 01 00 00 00 movl $0x1,(%edi) 10fc2c: e9 83 00 00 00 jmp 10fcb4 <_POSIX_Thread_Translate_sched_param+0xd0> return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 10fc31: 31 f6 xor %esi,%esi if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 10fc33: 83 fa 01 cmp $0x1,%edx 10fc36: 74 7f je 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 10fc38: 83 fa 02 cmp $0x2,%edx 10fc3b: 75 08 jne 10fc45 <_POSIX_Thread_Translate_sched_param+0x61> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 10fc3d: c7 07 02 00 00 00 movl $0x2,(%edi) return 0; 10fc43: eb 72 jmp 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; 10fc45: 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 ) { 10fc4a: 83 fa 04 cmp $0x4,%edx 10fc4d: 75 68 jne 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3> if ( (param->sched_ss_repl_period.tv_sec == 0) && 10fc4f: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10fc53: 75 06 jne 10fc5b <_POSIX_Thread_Translate_sched_param+0x77> 10fc55: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10fc59: 74 5c je 10fcb7 <_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) && 10fc5b: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fc5f: 75 0b jne 10fc6c <_POSIX_Thread_Translate_sched_param+0x88> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; 10fc61: 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) && 10fc66: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fc6a: 74 4b je 10fcb7 <_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 ) < 10fc6c: 83 ec 0c sub $0xc,%esp 10fc6f: 8d 43 08 lea 0x8(%ebx),%eax 10fc72: 50 push %eax 10fc73: e8 04 de ff ff call 10da7c <_Timespec_To_ticks> 10fc78: 89 45 e4 mov %eax,-0x1c(%ebp) _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 10fc7b: 8d 43 10 lea 0x10(%ebx),%eax 10fc7e: 89 04 24 mov %eax,(%esp) 10fc81: e8 f6 dd ff ff call 10da7c <_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 ) < 10fc86: 83 c4 10 add $0x10,%esp _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; 10fc89: 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 ) < 10fc8e: 39 45 e4 cmp %eax,-0x1c(%ebp) 10fc91: 72 24 jb 10fcb7 <_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 ) ) 10fc93: 83 ec 0c sub $0xc,%esp 10fc96: ff 73 04 pushl 0x4(%ebx) 10fc99: e8 26 ff ff ff call 10fbc4 <_POSIX_Priority_Is_valid> 10fc9e: 83 c4 10 add $0x10,%esp 10fca1: 84 c0 test %al,%al 10fca3: 74 12 je 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 10fca5: c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 10fcab: 8b 45 14 mov 0x14(%ebp),%eax 10fcae: c7 00 ed a7 10 00 movl $0x10a7ed,(%eax) return 0; 10fcb4: 66 31 f6 xor %si,%si } return EINVAL; } 10fcb7: 89 f0 mov %esi,%eax 10fcb9: 8d 65 f4 lea -0xc(%ebp),%esp 10fcbc: 5b pop %ebx 10fcbd: 5e pop %esi 10fcbe: 5f pop %edi 10fcbf: c9 leave 10fcc0: c3 ret =============================================================================== 0010a4f0 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10a4f0: 55 push %ebp 10a4f1: 89 e5 mov %esp,%ebp 10a4f3: 57 push %edi 10a4f4: 56 push %esi 10a4f5: 53 push %ebx 10a4f6: 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; 10a4f9: 8b 3d 10 12 12 00 mov 0x121210,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10a4ff: 8b 15 0c 12 12 00 mov 0x12120c,%edx if ( !user_threads || maximum == 0 ) 10a505: 85 d2 test %edx,%edx 10a507: 74 54 je 10a55d <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a509: 85 ff test %edi,%edi 10a50b: 74 50 je 10a55d <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a50d: 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 ); 10a50f: 8d 75 a4 lea -0x5c(%ebp),%esi 10a512: 83 ec 0c sub $0xc,%esp 10a515: 56 push %esi 10a516: 89 55 94 mov %edx,-0x6c(%ebp) 10a519: e8 a6 57 00 00 call 10fcc4 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10a51e: 5a pop %edx 10a51f: 59 pop %ecx 10a520: 6a 02 push $0x2 10a522: 56 push %esi 10a523: e8 c4 57 00 00 call 10fcec (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10a528: 59 pop %ecx 10a529: 58 pop %eax 10a52a: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10a52e: 56 push %esi 10a52f: e8 e4 57 00 00 call 10fd18 status = pthread_create( 10a534: 6a 00 push $0x0 10a536: ff 34 df pushl (%edi,%ebx,8) 10a539: 56 push %esi 10a53a: 8d 45 e4 lea -0x1c(%ebp),%eax 10a53d: 50 push %eax 10a53e: e8 e5 fc ff ff call 10a228 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10a543: 83 c4 20 add $0x20,%esp 10a546: 85 c0 test %eax,%eax 10a548: 8b 55 94 mov -0x6c(%ebp),%edx 10a54b: 74 0b je 10a558 <_POSIX_Threads_Initialize_user_threads_body+0x68> _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 10a54d: 52 push %edx 10a54e: 50 push %eax 10a54f: 6a 01 push $0x1 10a551: 6a 02 push $0x2 10a553: e8 f0 1b 00 00 call 10c148 <_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++ ) { 10a558: 43 inc %ebx 10a559: 39 d3 cmp %edx,%ebx 10a55b: 72 b5 jb 10a512 <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); } } 10a55d: 8d 65 f4 lea -0xc(%ebp),%esp 10a560: 5b pop %ebx 10a561: 5e pop %esi 10a562: 5f pop %edi 10a563: c9 leave 10a564: c3 ret =============================================================================== 0010ed2f <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 10ed2f: 55 push %ebp 10ed30: 89 e5 mov %esp,%ebp 10ed32: 56 push %esi 10ed33: 53 push %ebx 10ed34: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ed37: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget ); 10ed3d: 83 ec 0c sub $0xc,%esp 10ed40: 8d 86 98 00 00 00 lea 0x98(%esi),%eax 10ed46: 50 push %eax 10ed47: e8 3c 0e 00 00 call 10fb88 <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 10ed4c: 89 43 78 mov %eax,0x78(%ebx) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10ed4f: 0f b6 05 f4 01 12 00 movzbl 0x1201f4,%eax 10ed56: 2b 86 88 00 00 00 sub 0x88(%esi),%eax new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); the_thread->real_priority = new_priority; 10ed5c: 89 43 18 mov %eax,0x18(%ebx) */ #if 0 printk( "TSR %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 10ed5f: 83 c4 10 add $0x10,%esp 10ed62: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10ed66: 75 12 jne 10ed7a <_POSIX_Threads_Sporadic_budget_TSR+0x4b><== NEVER TAKEN /* * If this would make them less important, then do not change it. */ if ( the_thread->current_priority > new_priority ) { 10ed68: 39 43 14 cmp %eax,0x14(%ebx) 10ed6b: 76 0d jbe 10ed7a <_POSIX_Threads_Sporadic_budget_TSR+0x4b> _Thread_Change_priority( the_thread, new_priority, true ); 10ed6d: 52 push %edx 10ed6e: 6a 01 push $0x1 10ed70: 50 push %eax 10ed71: 53 push %ebx 10ed72: e8 19 cf ff ff call 10bc90 <_Thread_Change_priority> 10ed77: 83 c4 10 add $0x10,%esp #endif } } /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ); 10ed7a: 83 ec 0c sub $0xc,%esp 10ed7d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax 10ed83: 50 push %eax 10ed84: e8 ff 0d 00 00 call 10fb88 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10ed89: 89 86 b4 00 00 00 mov %eax,0xb4(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10ed8f: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 10ed92: 81 c6 a8 00 00 00 add $0xa8,%esi 10ed98: 89 75 0c mov %esi,0xc(%ebp) 10ed9b: c7 45 08 c4 43 12 00 movl $0x1243c4,0x8(%ebp) } 10eda2: 8d 65 f8 lea -0x8(%ebp),%esp 10eda5: 5b pop %ebx 10eda6: 5e pop %esi 10eda7: c9 leave 10eda8: e9 cf df ff ff jmp 10cd7c <_Watchdog_Insert> =============================================================================== 0010edad <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10edad: 55 push %ebp 10edae: 89 e5 mov %esp,%ebp 10edb0: 83 ec 08 sub $0x8,%esp 10edb3: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10edb6: 8b 88 ec 00 00 00 mov 0xec(%eax),%ecx /* * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 10edbc: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 10edc3: 0f b6 15 f4 01 12 00 movzbl 0x1201f4,%edx 10edca: 2b 91 8c 00 00 00 sub 0x8c(%ecx),%edx new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority); the_thread->real_priority = new_priority; 10edd0: 89 50 18 mov %edx,0x18(%eax) */ #if 0 printk( "callout %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 10edd3: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10edd7: 75 12 jne 10edeb <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN /* * Make sure we are actually lowering it. If they have lowered it * to logically lower than sched_ss_low_priority, then we do not want to * change it. */ if ( the_thread->current_priority < new_priority ) { 10edd9: 39 50 14 cmp %edx,0x14(%eax) 10eddc: 73 0d jae 10edeb <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN _Thread_Change_priority( the_thread, new_priority, true ); 10edde: 51 push %ecx 10eddf: 6a 01 push $0x1 10ede1: 52 push %edx 10ede2: 50 push %eax 10ede3: e8 a8 ce ff ff call 10bc90 <_Thread_Change_priority> 10ede8: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 10edeb: c9 leave 10edec: c3 ret =============================================================================== 0010a2b0 <_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) { 10a2b0: 55 push %ebp 10a2b1: 89 e5 mov %esp,%ebp 10a2b3: 53 push %ebx 10a2b4: 83 ec 04 sub $0x4,%esp 10a2b7: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a2ba: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a2bd: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 10a2c1: 75 06 jne 10a2c9 <_POSIX_Timer_TSR+0x19> 10a2c3: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10a2c7: 74 34 je 10a2fd <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10a2c9: 83 ec 0c sub $0xc,%esp 10a2cc: 53 push %ebx 10a2cd: 68 b0 a2 10 00 push $0x10a2b0 10a2d2: ff 73 08 pushl 0x8(%ebx) 10a2d5: ff 73 64 pushl 0x64(%ebx) 10a2d8: 8d 43 10 lea 0x10(%ebx),%eax 10a2db: 50 push %eax 10a2dc: e8 af 56 00 00 call 10f990 <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a2e1: 83 c4 20 add $0x20,%esp 10a2e4: 84 c0 test %al,%al 10a2e6: 74 30 je 10a318 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a2e8: 83 ec 0c sub $0xc,%esp 10a2eb: 8d 43 6c lea 0x6c(%ebx),%eax 10a2ee: 50 push %eax 10a2ef: e8 5c 14 00 00 call 10b750 <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a2f4: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10a2f8: 83 c4 10 add $0x10,%esp 10a2fb: eb 04 jmp 10a301 <_POSIX_Timer_TSR+0x51> } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a2fd: 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 ) ) { 10a301: 50 push %eax 10a302: 50 push %eax 10a303: ff 73 44 pushl 0x44(%ebx) 10a306: ff 73 38 pushl 0x38(%ebx) 10a309: e8 56 52 00 00 call 10f564 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a30e: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10a315: 83 c4 10 add $0x10,%esp } 10a318: 8b 5d fc mov -0x4(%ebp),%ebx 10a31b: c9 leave 10a31c: c3 ret =============================================================================== 00110b68 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 110b68: 55 push %ebp 110b69: 89 e5 mov %esp,%ebp 110b6b: 57 push %edi 110b6c: 56 push %esi 110b6d: 53 push %ebx 110b6e: 83 ec 68 sub $0x68,%esp 110b71: 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, 110b74: 6a 01 push $0x1 110b76: 0f b6 45 10 movzbl 0x10(%ebp),%eax 110b7a: 50 push %eax 110b7b: 8d 45 dc lea -0x24(%ebp),%eax 110b7e: 50 push %eax 110b7f: 53 push %ebx 110b80: ff 75 08 pushl 0x8(%ebp) 110b83: e8 8c 00 00 00 call 110c14 <_POSIX_signals_Clear_signals> 110b88: 83 c4 20 add $0x20,%esp is_global, true ) ) return false; 110b8b: 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, 110b8d: 84 c0 test %al,%al 110b8f: 74 78 je 110c09 <_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 ) 110b91: 6b d3 0c imul $0xc,%ebx,%edx 110b94: 8b 82 64 48 12 00 mov 0x124864(%edx),%eax 110b9a: 83 f8 01 cmp $0x1,%eax 110b9d: 74 6a je 110c09 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 110b9f: 8b 4d 08 mov 0x8(%ebp),%ecx 110ba2: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 110ba8: 89 4d a4 mov %ecx,-0x5c(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 110bab: 0b 8a 60 48 12 00 or 0x124860(%edx),%ecx 110bb1: 8b 75 08 mov 0x8(%ebp),%esi 110bb4: 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, 110bba: 8d 7d b4 lea -0x4c(%ebp),%edi 110bbd: 8b 35 28 48 12 00 mov 0x124828,%esi 110bc3: 83 c6 20 add $0x20,%esi 110bc6: b9 0a 00 00 00 mov $0xa,%ecx 110bcb: 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 ) { 110bcd: 83 ba 5c 48 12 00 02 cmpl $0x2,0x12485c(%edx) 110bd4: 75 09 jne 110bdf <_POSIX_signals_Check_signal+0x77> case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 110bd6: 52 push %edx 110bd7: 6a 00 push $0x0 110bd9: 8d 55 dc lea -0x24(%ebp),%edx 110bdc: 52 push %edx 110bdd: eb 03 jmp 110be2 <_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 ); 110bdf: 83 ec 0c sub $0xc,%esp 110be2: 53 push %ebx 110be3: ff d0 call *%eax break; 110be5: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 110be8: 8b 3d 28 48 12 00 mov 0x124828,%edi 110bee: 83 c7 20 add $0x20,%edi 110bf1: 8d 75 b4 lea -0x4c(%ebp),%esi 110bf4: b9 0a 00 00 00 mov $0xa,%ecx 110bf9: 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; 110bfb: 8b 75 a4 mov -0x5c(%ebp),%esi 110bfe: 8b 4d 08 mov 0x8(%ebp),%ecx 110c01: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx) return true; 110c07: b1 01 mov $0x1,%cl } 110c09: 88 c8 mov %cl,%al 110c0b: 8d 65 f4 lea -0xc(%ebp),%esp 110c0e: 5b pop %ebx 110c0f: 5e pop %esi 110c10: 5f pop %edi 110c11: c9 leave 110c12: c3 ret =============================================================================== 001110fc <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 1110fc: 55 push %ebp 1110fd: 89 e5 mov %esp,%ebp 1110ff: 53 push %ebx 111100: 8b 4d 08 mov 0x8(%ebp),%ecx clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 111103: 9c pushf 111104: fa cli 111105: 5a pop %edx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 111106: 6b c1 0c imul $0xc,%ecx,%eax 111109: 83 b8 5c 48 12 00 02 cmpl $0x2,0x12485c(%eax) 111110: 75 0e jne 111120 <_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 ); 111112: 8d 98 58 4a 12 00 lea 0x124a58(%eax),%ebx if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 111118: 39 98 54 4a 12 00 cmp %ebx,0x124a54(%eax) 11111e: 75 0e jne 11112e <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN 111120: 49 dec %ecx 111121: b8 fe ff ff ff mov $0xfffffffe,%eax clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 111126: d3 c0 rol %cl,%eax 111128: 21 05 50 4a 12 00 and %eax,0x124a50 } _ISR_Enable( level ); 11112e: 52 push %edx 11112f: 9d popf } 111130: 5b pop %ebx 111131: c9 leave 111132: c3 ret =============================================================================== 0010ab58 <_POSIX_signals_Get_lowest>: #include int _POSIX_signals_Get_lowest( sigset_t set ) { 10ab58: 55 push %ebp 10ab59: 89 e5 mov %esp,%ebp 10ab5b: 56 push %esi 10ab5c: 53 push %ebx 10ab5d: 8b 55 08 mov 0x8(%ebp),%edx int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ab60: b8 1b 00 00 00 mov $0x1b,%eax 10ab65: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10ab6a: 8d 48 ff lea -0x1(%eax),%ecx 10ab6d: 89 de mov %ebx,%esi 10ab6f: d3 e6 shl %cl,%esi ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10ab71: 85 d6 test %edx,%esi 10ab73: 75 1e jne 10ab93 <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ab75: 40 inc %eax 10ab76: 83 f8 20 cmp $0x20,%eax 10ab79: 75 ef jne 10ab6a <_POSIX_signals_Get_lowest+0x12> 10ab7b: b0 01 mov $0x1,%al 10ab7d: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10ab82: 8d 48 ff lea -0x1(%eax),%ecx 10ab85: 89 de mov %ebx,%esi 10ab87: 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 ) ) { 10ab89: 85 d6 test %edx,%esi 10ab8b: 75 06 jne 10ab93 <_POSIX_signals_Get_lowest+0x3b> */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10ab8d: 40 inc %eax 10ab8e: 83 f8 1b cmp $0x1b,%eax 10ab91: 75 ef jne 10ab82 <_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; } 10ab93: 5b pop %ebx 10ab94: 5e pop %esi 10ab95: c9 leave 10ab96: c3 ret =============================================================================== 0012190c <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 12190c: 55 push %ebp 12190d: 89 e5 mov %esp,%ebp 12190f: 57 push %edi 121910: 56 push %esi 121911: 53 push %ebx 121912: 83 ec 0c sub $0xc,%esp 121915: 8b 5d 08 mov 0x8(%ebp),%ebx 121918: 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 ]; 12191b: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 121921: 8d 4e ff lea -0x1(%esi),%ecx 121924: ba 01 00 00 00 mov $0x1,%edx 121929: d3 e2 shl %cl,%edx /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 12192b: 8b 4b 10 mov 0x10(%ebx),%ecx 12192e: 89 cf mov %ecx,%edi 121930: 81 e7 00 80 00 10 and $0x10008000,%edi 121936: 81 ff 00 80 00 10 cmp $0x10008000,%edi 12193c: 75 58 jne 121996 <_POSIX_signals_Unblock_thread+0x8a> if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 12193e: 85 53 30 test %edx,0x30(%ebx) 121941: 75 12 jne 121955 <_POSIX_signals_Unblock_thread+0x49> 121943: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 121949: f7 d0 not %eax /* * This should only be reached via pthread_kill(). */ return false; 12194b: 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) ) { 12194d: 85 c2 test %eax,%edx 12194f: 0f 84 b0 00 00 00 je 121a05 <_POSIX_signals_Unblock_thread+0xf9> the_thread->Wait.return_code = EINTR; 121955: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 12195c: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 12195f: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 121963: 75 12 jne 121977 <_POSIX_signals_Unblock_thread+0x6b> the_info->si_signo = signo; 121965: 89 30 mov %esi,(%eax) the_info->si_code = SI_USER; 121967: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 12196e: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 121975: eb 0c jmp 121983 <_POSIX_signals_Unblock_thread+0x77> } else { *the_info = *info; 121977: b9 03 00 00 00 mov $0x3,%ecx 12197c: 89 c7 mov %eax,%edi 12197e: 8b 75 10 mov 0x10(%ebp),%esi 121981: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 121983: 83 ec 0c sub $0xc,%esp 121986: 53 push %ebx 121987: e8 68 f5 fe ff call 110ef4 <_Thread_queue_Extract_with_proxy> return true; 12198c: 83 c4 10 add $0x10,%esp 12198f: bf 01 00 00 00 mov $0x1,%edi 121994: eb 6f jmp 121a05 <_POSIX_signals_Unblock_thread+0xf9> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 121996: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 12199c: 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; 12199e: 31 ff xor %edi,%edi } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 1219a0: 85 c2 test %eax,%edx 1219a2: 74 61 je 121a05 <_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 ) ) { 1219a4: f7 c1 00 00 00 10 test $0x10000000,%ecx 1219aa: 74 3d je 1219e9 <_POSIX_signals_Unblock_thread+0xdd> the_thread->Wait.return_code = EINTR; 1219ac: 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) ) 1219b3: f7 c1 e0 be 03 00 test $0x3bee0,%ecx 1219b9: 74 0b je 1219c6 <_POSIX_signals_Unblock_thread+0xba> _Thread_queue_Extract_with_proxy( the_thread ); 1219bb: 83 ec 0c sub $0xc,%esp 1219be: 53 push %ebx 1219bf: e8 30 f5 fe ff call 110ef4 <_Thread_queue_Extract_with_proxy> 1219c4: eb 1e jmp 1219e4 <_POSIX_signals_Unblock_thread+0xd8> else if ( _States_Is_delaying(the_thread->current_state) ) { 1219c6: 80 e1 08 and $0x8,%cl 1219c9: 74 3a je 121a05 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 1219cb: 83 ec 0c sub $0xc,%esp 1219ce: 8d 43 48 lea 0x48(%ebx),%eax 1219d1: 50 push %eax 1219d2: e8 85 fc fe ff call 11165c <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 1219d7: 58 pop %eax 1219d8: 5a pop %edx 1219d9: 68 f8 ff 03 10 push $0x1003fff8 1219de: 53 push %ebx 1219df: e8 80 eb fe ff call 110564 <_Thread_Clear_state> 1219e4: 83 c4 10 add $0x10,%esp 1219e7: eb 1c jmp 121a05 <_POSIX_signals_Unblock_thread+0xf9> _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 1219e9: 85 c9 test %ecx,%ecx 1219eb: 75 18 jne 121a05 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1219ed: 83 3d 98 a9 12 00 00 cmpl $0x0,0x12a998 1219f4: 74 0f je 121a05 <_POSIX_signals_Unblock_thread+0xf9> 1219f6: 3b 1d 9c a9 12 00 cmp 0x12a99c,%ebx 1219fc: 75 07 jne 121a05 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN _Thread_Dispatch_necessary = true; 1219fe: c6 05 a8 a9 12 00 01 movb $0x1,0x12a9a8 } } return false; } 121a05: 89 f8 mov %edi,%eax 121a07: 8d 65 f4 lea -0xc(%ebp),%esp 121a0a: 5b pop %ebx 121a0b: 5e pop %esi 121a0c: 5f pop %edi 121a0d: c9 leave 121a0e: c3 ret =============================================================================== 0010b3a8 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10b3a8: 55 push %ebp 10b3a9: 89 e5 mov %esp,%ebp 10b3ab: 53 push %ebx 10b3ac: 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 ); 10b3af: 8d 45 f4 lea -0xc(%ebp),%eax 10b3b2: 50 push %eax 10b3b3: ff 75 08 pushl 0x8(%ebp) 10b3b6: 68 14 73 12 00 push $0x127314 10b3bb: e8 cc 1a 00 00 call 10ce8c <_Objects_Get> 10b3c0: 89 c3 mov %eax,%ebx switch ( location ) { 10b3c2: 83 c4 10 add $0x10,%esp 10b3c5: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10b3c9: 75 64 jne 10b42f <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10b3cb: 8b 40 40 mov 0x40(%eax),%eax if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b3ce: f6 40 11 40 testb $0x40,0x11(%eax) 10b3d2: 74 18 je 10b3ec <_Rate_monotonic_Timeout+0x44> 10b3d4: 8b 53 08 mov 0x8(%ebx),%edx 10b3d7: 39 50 20 cmp %edx,0x20(%eax) 10b3da: 75 10 jne 10b3ec <_Rate_monotonic_Timeout+0x44> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10b3dc: 52 push %edx 10b3dd: 52 push %edx 10b3de: 68 f8 ff 03 10 push $0x1003fff8 10b3e3: 50 push %eax 10b3e4: e8 4f 21 00 00 call 10d538 <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10b3e9: 59 pop %ecx 10b3ea: eb 10 jmp 10b3fc <_Rate_monotonic_Timeout+0x54> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10b3ec: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 10b3f0: 75 2b jne 10b41d <_Rate_monotonic_Timeout+0x75> the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10b3f2: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) _Rate_monotonic_Initiate_statistics( the_period ); 10b3f9: 83 ec 0c sub $0xc,%esp 10b3fc: 53 push %ebx 10b3fd: e8 ec fa ff ff call 10aeee <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b402: 8b 43 3c mov 0x3c(%ebx),%eax 10b405: 89 43 1c mov %eax,0x1c(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b408: 58 pop %eax 10b409: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 10b40a: 83 c3 10 add $0x10,%ebx 10b40d: 53 push %ebx 10b40e: 68 e8 74 12 00 push $0x1274e8 10b413: e8 f8 31 00 00 call 10e610 <_Watchdog_Insert> 10b418: 83 c4 10 add $0x10,%esp 10b41b: eb 07 jmp 10b424 <_Rate_monotonic_Timeout+0x7c> } else the_period->state = RATE_MONOTONIC_EXPIRED; 10b41d: 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; 10b424: a1 04 74 12 00 mov 0x127404,%eax 10b429: 48 dec %eax 10b42a: a3 04 74 12 00 mov %eax,0x127404 case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b42f: 8b 5d fc mov -0x4(%ebp),%ebx 10b432: c9 leave 10b433: c3 ret =============================================================================== 0010f808 <_Scheduler_priority_Block>: void _Scheduler_priority_Block( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { 10f808: 55 push %ebp 10f809: 89 e5 mov %esp,%ebp 10f80b: 56 push %esi 10f80c: 53 push %ebx 10f80d: 8b 55 0c mov 0xc(%ebp),%edx RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_extract( Thread_Control *the_thread ) { Chain_Control *ready = the_thread->scheduler.priority->ready_chain; 10f810: 8b 82 8c 00 00 00 mov 0x8c(%edx),%eax 10f816: 8b 00 mov (%eax),%eax if ( _Chain_Has_only_one_node( ready ) ) { 10f818: 8b 48 08 mov 0x8(%eax),%ecx 10f81b: 39 08 cmp %ecx,(%eax) 10f81d: 75 38 jne 10f857 <_Scheduler_priority_Block+0x4f> RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10f81f: 8d 48 04 lea 0x4(%eax),%ecx 10f822: 89 08 mov %ecx,(%eax) head->next = tail; head->previous = NULL; 10f824: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) tail->previous = head; 10f82b: 89 40 08 mov %eax,0x8(%eax) _Chain_Initialize_empty( ready ); _Priority_bit_map_Remove( &the_thread->scheduler.priority->Priority_map ); 10f82e: 8b 8a 8c 00 00 00 mov 0x8c(%edx),%ecx RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor &= the_priority_map->block_minor; 10f834: 8b 59 04 mov 0x4(%ecx),%ebx 10f837: 66 8b 03 mov (%ebx),%ax 10f83a: 66 23 41 0e and 0xe(%ecx),%ax 10f83e: 66 89 03 mov %ax,(%ebx) if ( *the_priority_map->minor == 0 ) 10f841: 66 85 c0 test %ax,%ax 10f844: 75 1b jne 10f861 <_Scheduler_priority_Block+0x59> _Priority_Major_bit_map &= the_priority_map->block_major; 10f846: 66 a1 38 48 12 00 mov 0x124838,%ax 10f84c: 23 41 0c and 0xc(%ecx),%eax 10f84f: 66 a3 38 48 12 00 mov %ax,0x124838 10f855: eb 0a jmp 10f861 <_Scheduler_priority_Block+0x59> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10f857: 8b 0a mov (%edx),%ecx previous = the_node->previous; 10f859: 8b 42 04 mov 0x4(%edx),%eax next->previous = previous; 10f85c: 89 41 04 mov %eax,0x4(%ecx) previous->next = next; 10f85f: 89 08 mov %ecx,(%eax) { _Scheduler_priority_Ready_queue_extract(the_thread); /* TODO: flash critical section */ if ( _Thread_Is_heir( the_thread ) ) 10f861: 3b 15 2c 48 12 00 cmp 0x12482c,%edx 10f867: 75 42 jne 10f8ab <_Scheduler_priority_Block+0xa3> RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void ) { Priority_bit_map_Control minor; Priority_bit_map_Control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major ); 10f869: 66 8b 35 38 48 12 00 mov 0x124838,%si 10f870: 31 c9 xor %ecx,%ecx 10f872: 89 cb mov %ecx,%ebx 10f874: 66 0f bc de bsf %si,%bx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10f878: 0f b7 db movzwl %bx,%ebx 10f87b: 66 8b b4 1b 3c 48 12 mov 0x12483c(%ebx,%ebx,1),%si 10f882: 00 10f883: 66 0f bc ce bsf %si,%cx return (_Priority_Bits_index( major ) << 4) + 10f887: c1 e3 04 shl $0x4,%ebx 10f88a: 0f b7 c9 movzwl %cx,%ecx 10f88d: 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 ] ) ) 10f890: 6b c0 0c imul $0xc,%eax,%eax 10f893: 8b 4d 08 mov 0x8(%ebp),%ecx 10f896: 03 01 add (%ecx),%eax _Scheduler_priority_Block_body(the_scheduler, the_thread); } 10f898: 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 ); 10f89a: 83 c0 04 add $0x4,%eax return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10f89d: 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 ] ) ) 10f89f: 39 c3 cmp %eax,%ebx 10f8a1: 74 02 je 10f8a5 <_Scheduler_priority_Block+0x9d><== NEVER TAKEN return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); 10f8a3: 89 d9 mov %ebx,%ecx RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10f8a5: 89 0d 2c 48 12 00 mov %ecx,0x12482c /* TODO: flash critical section */ if ( _Thread_Is_heir( the_thread ) ) _Scheduler_priority_Schedule_body(the_scheduler); if ( _Thread_Is_executing( the_thread ) ) 10f8ab: 3b 15 28 48 12 00 cmp 0x124828,%edx 10f8b1: 75 07 jne 10f8ba <_Scheduler_priority_Block+0xb2> _Thread_Dispatch_necessary = true; 10f8b3: c6 05 34 48 12 00 01 movb $0x1,0x124834 10f8ba: 5b pop %ebx 10f8bb: 5e pop %esi 10f8bc: c9 leave 10f8bd: c3 ret =============================================================================== 0010baa8 <_Scheduler_priority_Schedule>: */ void _Scheduler_priority_Schedule( Scheduler_Control *the_scheduler ) { 10baa8: 55 push %ebp 10baa9: 89 e5 mov %esp,%ebp 10baab: 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 ); 10baac: 66 8b 1d 38 48 12 00 mov 0x124838,%bx 10bab3: 31 d2 xor %edx,%edx 10bab5: 89 d1 mov %edx,%ecx 10bab7: 66 0f bc cb bsf %bx,%cx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10babb: 0f b7 c9 movzwl %cx,%ecx 10babe: 66 8b 9c 09 3c 48 12 mov 0x12483c(%ecx,%ecx,1),%bx 10bac5: 00 10bac6: 66 0f bc d3 bsf %bx,%dx return (_Priority_Bits_index( major ) << 4) + 10baca: c1 e1 04 shl $0x4,%ecx 10bacd: 0f b7 d2 movzwl %dx,%edx 10bad0: 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 ] ) ) 10bad3: 6b c0 0c imul $0xc,%eax,%eax 10bad6: 8b 55 08 mov 0x8(%ebp),%edx 10bad9: 03 02 add (%edx),%eax _Scheduler_priority_Schedule_body( the_scheduler ); } 10badb: 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 ); 10badd: 83 c0 04 add $0x4,%eax return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10bae0: 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 ] ) ) 10bae2: 39 c1 cmp %eax,%ecx 10bae4: 74 02 je 10bae8 <_Scheduler_priority_Schedule+0x40><== NEVER TAKEN return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); 10bae6: 89 ca mov %ecx,%edx RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10bae8: 89 15 2c 48 12 00 mov %edx,0x12482c 10baee: 5b pop %ebx 10baef: c9 leave 10baf0: c3 ret =============================================================================== 0010acb8 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10acb8: 55 push %ebp 10acb9: 89 e5 mov %esp,%ebp 10acbb: 56 push %esi 10acbc: 53 push %ebx 10acbd: 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(); 10acc0: 8b 35 c4 42 12 00 mov 0x1242c4,%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; 10acc6: 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) || 10acc8: 85 c9 test %ecx,%ecx 10acca: 74 57 je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10accc: b8 40 42 0f 00 mov $0xf4240,%eax 10acd1: 31 d2 xor %edx,%edx 10acd3: f7 f6 div %esi rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10acd5: 39 41 18 cmp %eax,0x18(%ecx) 10acd8: 73 49 jae 10ad23 <_TOD_Validate+0x6b> (the_tod->ticks >= ticks_per_second) || 10acda: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10acde: 77 43 ja 10ad23 <_TOD_Validate+0x6b> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10ace0: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10ace4: 77 3d ja 10ad23 <_TOD_Validate+0x6b> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10ace6: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10acea: 77 37 ja 10ad23 <_TOD_Validate+0x6b> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10acec: 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) || 10acef: 85 c0 test %eax,%eax 10acf1: 74 30 je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->month == 0) || 10acf3: 83 f8 0c cmp $0xc,%eax 10acf6: 77 2b ja 10ad23 <_TOD_Validate+0x6b> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10acf8: 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) || 10acfa: 81 fe c3 07 00 00 cmp $0x7c3,%esi 10ad00: 76 21 jbe 10ad23 <_TOD_Validate+0x6b> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10ad02: 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) || 10ad05: 85 d2 test %edx,%edx 10ad07: 74 1a je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10ad09: 83 e6 03 and $0x3,%esi 10ad0c: 75 09 jne 10ad17 <_TOD_Validate+0x5f> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10ad0e: 8b 04 85 ac 14 12 00 mov 0x1214ac(,%eax,4),%eax 10ad15: eb 07 jmp 10ad1e <_TOD_Validate+0x66> else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad17: 8b 04 85 78 14 12 00 mov 0x121478(,%eax,4),%eax * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 10ad1e: 39 c2 cmp %eax,%edx 10ad20: 0f 96 c3 setbe %bl if ( the_tod->day > days_in_month ) return false; return true; } 10ad23: 88 d8 mov %bl,%al 10ad25: 5b pop %ebx 10ad26: 5e pop %esi 10ad27: c9 leave 10ad28: c3 ret =============================================================================== 0010bc90 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10bc90: 55 push %ebp 10bc91: 89 e5 mov %esp,%ebp 10bc93: 57 push %edi 10bc94: 56 push %esi 10bc95: 53 push %ebx 10bc96: 83 ec 28 sub $0x28,%esp 10bc99: 8b 5d 08 mov 0x8(%ebp),%ebx 10bc9c: 8b 75 0c mov 0xc(%ebp),%esi 10bc9f: 8a 45 10 mov 0x10(%ebp),%al 10bca2: 88 45 e7 mov %al,-0x19(%ebp) */ /* * Save original state */ original_state = the_thread->current_state; 10bca5: 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 ); 10bca8: 53 push %ebx 10bca9: e8 1a 0c 00 00 call 10c8c8 <_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 ) 10bcae: 83 c4 10 add $0x10,%esp 10bcb1: 39 73 14 cmp %esi,0x14(%ebx) 10bcb4: 74 0c je 10bcc2 <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10bcb6: 50 push %eax 10bcb7: 50 push %eax 10bcb8: 56 push %esi 10bcb9: 53 push %ebx 10bcba: e8 a9 0b 00 00 call 10c868 <_Thread_Set_priority> 10bcbf: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10bcc2: 9c pushf 10bcc3: fa cli 10bcc4: 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; 10bcc5: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10bcc8: 83 f8 04 cmp $0x4,%eax 10bccb: 74 2f je 10bcfc <_Thread_Change_priority+0x6c> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10bccd: 83 e7 04 and $0x4,%edi 10bcd0: 75 08 jne 10bcda <_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); 10bcd2: 89 c2 mov %eax,%edx 10bcd4: 83 e2 fb and $0xfffffffb,%edx 10bcd7: 89 53 10 mov %edx,0x10(%ebx) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10bcda: 56 push %esi 10bcdb: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10bcdc: a9 e0 be 03 00 test $0x3bee0,%eax 10bce1: 0f 84 b5 00 00 00 je 10bd9c <_Thread_Change_priority+0x10c> _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10bce7: 89 5d 0c mov %ebx,0xc(%ebp) 10bcea: 8b 43 44 mov 0x44(%ebx),%eax 10bced: 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 ); } 10bcf0: 8d 65 f4 lea -0xc(%ebp),%esp 10bcf3: 5b pop %ebx 10bcf4: 5e pop %esi 10bcf5: 5f pop %edi 10bcf6: 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 ); 10bcf7: e9 e4 0a 00 00 jmp 10c7e0 <_Thread_queue_Requeue> } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10bcfc: 83 e7 04 and $0x4,%edi 10bcff: 75 6b jne 10bd6c <_Thread_Change_priority+0xdc><== NEVER TAKEN * Ready Queue with interrupts off. * * FIXME: hard-coded for priority scheduling. Might be ok since this * function is specific to priority scheduling? */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10bd01: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( prepend_it ) 10bd08: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10bd0c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 10bd12: 74 2b je 10bd3f <_Thread_Change_priority+0xaf> RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10bd14: 8b 50 04 mov 0x4(%eax),%edx 10bd17: 66 8b 48 0a mov 0xa(%eax),%cx 10bd1b: 66 09 0a or %cx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bd1e: 66 8b 15 38 48 12 00 mov 0x124838,%dx 10bd25: 0b 50 08 or 0x8(%eax),%edx 10bd28: 66 89 15 38 48 12 00 mov %dx,0x124838 Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); _Chain_Prepend_unprotected( the_thread->scheduler.priority->ready_chain, 10bd2f: 8b 00 mov (%eax),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10bd31: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10bd34: 8b 10 mov (%eax),%edx after_node->next = the_node; 10bd36: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10bd38: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10bd3a: 89 5a 04 mov %ebx,0x4(%edx) 10bd3d: eb 2d jmp 10bd6c <_Thread_Change_priority+0xdc> RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10bd3f: 8b 50 04 mov 0x4(%eax),%edx 10bd42: 66 8b 48 0a mov 0xa(%eax),%cx 10bd46: 66 09 0a or %cx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bd49: 66 8b 15 38 48 12 00 mov 0x124838,%dx 10bd50: 0b 50 08 or 0x8(%eax),%edx 10bd53: 66 89 15 38 48 12 00 mov %dx,0x124838 Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); _Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain, 10bd5a: 8b 00 mov (%eax),%eax Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10bd5c: 8b 50 08 mov 0x8(%eax),%edx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 10bd5f: 8d 48 04 lea 0x4(%eax),%ecx 10bd62: 89 0b mov %ecx,(%ebx) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10bd64: 89 58 08 mov %ebx,0x8(%eax) old_last->next = the_node; 10bd67: 89 1a mov %ebx,(%edx) the_node->previous = old_last; 10bd69: 89 53 04 mov %edx,0x4(%ebx) _Scheduler_priority_Ready_queue_enqueue_first( the_thread ); else _Scheduler_priority_Ready_queue_enqueue( the_thread ); } _ISR_Flash( level ); 10bd6c: 56 push %esi 10bd6d: 9d popf 10bd6e: fa cli */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( Scheduler_Control *the_scheduler ) { the_scheduler->Operations.schedule( the_scheduler ); 10bd6f: 83 ec 0c sub $0xc,%esp 10bd72: 68 68 43 12 00 push $0x124368 10bd77: ff 15 6c 43 12 00 call *0x12436c * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10bd7d: a1 28 48 12 00 mov 0x124828,%eax * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Scheduler_Schedule(&_Scheduler); if ( !_Thread_Is_executing_also_the_heir() && 10bd82: 83 c4 10 add $0x10,%esp 10bd85: 3b 05 2c 48 12 00 cmp 0x12482c,%eax 10bd8b: 74 0d je 10bd9a <_Thread_Change_priority+0x10a> 10bd8d: 80 78 74 00 cmpb $0x0,0x74(%eax) 10bd91: 74 07 je 10bd9a <_Thread_Change_priority+0x10a> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10bd93: c6 05 34 48 12 00 01 movb $0x1,0x124834 _ISR_Enable( level ); 10bd9a: 56 push %esi 10bd9b: 9d popf } 10bd9c: 8d 65 f4 lea -0xc(%ebp),%esp 10bd9f: 5b pop %ebx 10bda0: 5e pop %esi 10bda1: 5f pop %edi 10bda2: c9 leave 10bda3: c3 ret =============================================================================== 0010bf64 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10bf64: 55 push %ebp 10bf65: 89 e5 mov %esp,%ebp 10bf67: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10bf6a: 8d 45 f4 lea -0xc(%ebp),%eax 10bf6d: 50 push %eax 10bf6e: ff 75 08 pushl 0x8(%ebp) 10bf71: e8 82 01 00 00 call 10c0f8 <_Thread_Get> switch ( location ) { 10bf76: 83 c4 10 add $0x10,%esp 10bf79: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10bf7d: 75 1b jne 10bf9a <_Thread_Delay_ended+0x36><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10bf7f: 52 push %edx 10bf80: 52 push %edx 10bf81: 68 18 00 00 10 push $0x10000018 10bf86: 50 push %eax 10bf87: e8 18 fe ff ff call 10bda4 <_Thread_Clear_state> 10bf8c: a1 e0 42 12 00 mov 0x1242e0,%eax 10bf91: 48 dec %eax 10bf92: a3 e0 42 12 00 mov %eax,0x1242e0 10bf97: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10bf9a: c9 leave 10bf9b: c3 ret =============================================================================== 0010bf9c <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10bf9c: 55 push %ebp 10bf9d: 89 e5 mov %esp,%ebp 10bf9f: 57 push %edi 10bfa0: 56 push %esi 10bfa1: 53 push %ebx 10bfa2: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10bfa5: 8b 1d 28 48 12 00 mov 0x124828,%ebx _ISR_Disable( level ); 10bfab: 9c pushf 10bfac: fa cli 10bfad: 58 pop %eax #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); _Timestamp_Subtract( 10bfae: 8d 7d d8 lea -0x28(%ebp),%edi Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10bfb1: e9 f9 00 00 00 jmp 10c0af <_Thread_Dispatch+0x113> heir = _Thread_Heir; 10bfb6: 8b 35 2c 48 12 00 mov 0x12482c,%esi _Thread_Dispatch_disable_level = 1; 10bfbc: c7 05 e0 42 12 00 01 movl $0x1,0x1242e0 10bfc3: 00 00 00 _Thread_Dispatch_necessary = false; 10bfc6: c6 05 34 48 12 00 00 movb $0x0,0x124834 _Thread_Executing = heir; 10bfcd: 89 35 28 48 12 00 mov %esi,0x124828 /* * 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 ) 10bfd3: 39 de cmp %ebx,%esi 10bfd5: 0f 84 e2 00 00 00 je 10c0bd <_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 ) 10bfdb: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10bfdf: 75 09 jne 10bfea <_Thread_Dispatch+0x4e> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10bfe1: 8b 15 b0 42 12 00 mov 0x1242b0,%edx 10bfe7: 89 56 78 mov %edx,0x78(%esi) _ISR_Enable( level ); 10bfea: 50 push %eax 10bfeb: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10bfec: 83 ec 0c sub $0xc,%esp 10bfef: 8d 45 e0 lea -0x20(%ebp),%eax 10bff2: 50 push %eax 10bff3: e8 e0 34 00 00 call 10f4d8 <_TOD_Get_uptime> _Timestamp_Subtract( 10bff8: 83 c4 0c add $0xc,%esp 10bffb: 57 push %edi 10bffc: 8d 45 e0 lea -0x20(%ebp),%eax 10bfff: 50 push %eax 10c000: 68 b0 43 12 00 push $0x1243b0 10c005: e8 06 0b 00 00 call 10cb10 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10c00a: 58 pop %eax 10c00b: 5a pop %edx 10c00c: 57 push %edi 10c00d: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10c013: 50 push %eax 10c014: e8 c7 0a 00 00 call 10cae0 <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10c019: 8b 45 e0 mov -0x20(%ebp),%eax 10c01c: 8b 55 e4 mov -0x1c(%ebp),%edx 10c01f: a3 b0 43 12 00 mov %eax,0x1243b0 10c024: 89 15 b4 43 12 00 mov %edx,0x1243b4 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10c02a: a1 88 43 12 00 mov 0x124388,%eax 10c02f: 83 c4 10 add $0x10,%esp 10c032: 85 c0 test %eax,%eax 10c034: 74 10 je 10c046 <_Thread_Dispatch+0xaa> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10c036: 8b 10 mov (%eax),%edx 10c038: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx) *_Thread_libc_reent = heir->libc_reent; 10c03e: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx 10c044: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10c046: 51 push %ecx 10c047: 51 push %ecx 10c048: 56 push %esi 10c049: 53 push %ebx 10c04a: e8 f9 0c 00 00 call 10cd48 <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10c04f: 58 pop %eax 10c050: 5a pop %edx 10c051: 81 c6 c8 00 00 00 add $0xc8,%esi 10c057: 56 push %esi 10c058: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10c05e: 50 push %eax 10c05f: e8 ac 0f 00 00 call 10d010 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10c064: 83 c4 10 add $0x10,%esp 10c067: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx) 10c06e: 74 36 je 10c0a6 <_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 ); 10c070: a1 64 43 12 00 mov 0x124364,%eax 10c075: 39 c3 cmp %eax,%ebx 10c077: 74 2d je 10c0a6 <_Thread_Dispatch+0x10a> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10c079: 85 c0 test %eax,%eax 10c07b: 74 11 je 10c08e <_Thread_Dispatch+0xf2> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10c07d: 83 ec 0c sub $0xc,%esp 10c080: 05 e0 00 00 00 add $0xe0,%eax 10c085: 50 push %eax 10c086: e8 b9 0f 00 00 call 10d044 <_CPU_Context_save_fp> 10c08b: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10c08e: 83 ec 0c sub $0xc,%esp 10c091: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax 10c097: 50 push %eax 10c098: e8 b1 0f 00 00 call 10d04e <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10c09d: 89 1d 64 43 12 00 mov %ebx,0x124364 10c0a3: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10c0a6: 8b 1d 28 48 12 00 mov 0x124828,%ebx _ISR_Disable( level ); 10c0ac: 9c pushf 10c0ad: fa cli 10c0ae: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10c0af: 8a 15 34 48 12 00 mov 0x124834,%dl 10c0b5: 84 d2 test %dl,%dl 10c0b7: 0f 85 f9 fe ff ff jne 10bfb6 <_Thread_Dispatch+0x1a> _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10c0bd: c7 05 e0 42 12 00 00 movl $0x0,0x1242e0 10c0c4: 00 00 00 _ISR_Enable( level ); 10c0c7: 50 push %eax 10c0c8: 9d popf _API_extensions_Run_postswitch(); 10c0c9: e8 15 e8 ff ff call 10a8e3 <_API_extensions_Run_postswitch> } 10c0ce: 8d 65 f4 lea -0xc(%ebp),%esp 10c0d1: 5b pop %ebx 10c0d2: 5e pop %esi 10c0d3: 5f pop %edi 10c0d4: c9 leave 10c0d5: c3 ret =============================================================================== 00110fb0 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 110fb0: 55 push %ebp 110fb1: 89 e5 mov %esp,%ebp 110fb3: 53 push %ebx 110fb4: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 110fb7: 8b 1d 28 48 12 00 mov 0x124828,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110fbd: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax _ISR_Set_level(level); 110fc3: 85 c0 test %eax,%eax 110fc5: 74 03 je 110fca <_Thread_Handler+0x1a> 110fc7: fa cli 110fc8: eb 01 jmp 110fcb <_Thread_Handler+0x1b> 110fca: fb sti #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 110fcb: a0 a0 3f 12 00 mov 0x123fa0,%al 110fd0: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 110fd3: c6 05 a0 3f 12 00 01 movb $0x1,0x123fa0 #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 110fda: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx) 110fe1: 74 24 je 111007 <_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 ); 110fe3: a1 64 43 12 00 mov 0x124364,%eax 110fe8: 39 c3 cmp %eax,%ebx 110fea: 74 1b je 111007 <_Thread_Handler+0x57> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 110fec: 85 c0 test %eax,%eax 110fee: 74 11 je 111001 <_Thread_Handler+0x51> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110ff0: 83 ec 0c sub $0xc,%esp 110ff3: 05 e0 00 00 00 add $0xe0,%eax 110ff8: 50 push %eax 110ff9: e8 46 c0 ff ff call 10d044 <_CPU_Context_save_fp> 110ffe: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 111001: 89 1d 64 43 12 00 mov %ebx,0x124364 /* * Take care that 'begin' extensions get to complete before * 'switch' extensions can run. This means must keep dispatch * disabled until all 'begin' extensions complete. */ _User_extensions_Thread_begin( executing ); 111007: 83 ec 0c sub $0xc,%esp 11100a: 53 push %ebx 11100b: e8 e8 bb ff ff call 10cbf8 <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 111010: e8 c1 b0 ff ff call 10c0d6 <_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) */ { 111015: 83 c4 10 add $0x10,%esp 111018: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 11101c: 75 05 jne 111023 <_Thread_Handler+0x73> INIT_NAME (); 11101e: e8 6d be 00 00 call 11ce90 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 111023: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 111029: 85 c0 test %eax,%eax 11102b: 75 0b jne 111038 <_Thread_Handler+0x88> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 11102d: 83 ec 0c sub $0xc,%esp 111030: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 111036: eb 0c jmp 111044 <_Thread_Handler+0x94> executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 111038: 48 dec %eax 111039: 75 15 jne 111050 <_Thread_Handler+0xa0> <== NEVER TAKEN executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 11103b: 83 ec 0c sub $0xc,%esp 11103e: ff b3 98 00 00 00 pushl 0x98(%ebx) 111044: 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 = 11104a: 89 43 28 mov %eax,0x28(%ebx) 11104d: 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 ); 111050: 83 ec 0c sub $0xc,%esp 111053: 53 push %ebx 111054: e8 d0 bb ff ff call 10cc29 <_User_extensions_Thread_exitted> _Internal_error_Occurred( 111059: 83 c4 0c add $0xc,%esp 11105c: 6a 05 push $0x5 11105e: 6a 01 push $0x1 111060: 6a 00 push $0x0 111062: e8 d1 a1 ff ff call 10b238 <_Internal_error_Occurred> =============================================================================== 0010c168 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10c168: 55 push %ebp 10c169: 89 e5 mov %esp,%ebp 10c16b: 57 push %edi 10c16c: 56 push %esi 10c16d: 53 push %ebx 10c16e: 83 ec 1c sub $0x1c,%esp 10c171: 8b 5d 0c mov 0xc(%ebp),%ebx 10c174: 8b 4d 10 mov 0x10(%ebp),%ecx 10c177: 8b 75 14 mov 0x14(%ebp),%esi 10c17a: 8a 55 18 mov 0x18(%ebp),%dl 10c17d: 8a 45 20 mov 0x20(%ebp),%al 10c180: 88 45 e3 mov %al,-0x1d(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10c183: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10c18a: 00 00 00 10c18d: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx) 10c194: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10c197: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10c19e: 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 ) { 10c1a1: 85 c9 test %ecx,%ecx 10c1a3: 75 31 jne 10c1d6 <_Thread_Initialize+0x6e> actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10c1a5: 51 push %ecx 10c1a6: 51 push %ecx 10c1a7: 56 push %esi 10c1a8: 53 push %ebx 10c1a9: 88 55 dc mov %dl,-0x24(%ebp) 10c1ac: e8 87 07 00 00 call 10c938 <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10c1b1: 83 c4 10 add $0x10,%esp 10c1b4: 39 f0 cmp %esi,%eax 10c1b6: 8a 55 dc mov -0x24(%ebp),%dl 10c1b9: 0f 82 f9 01 00 00 jb 10c3b8 <_Thread_Initialize+0x250> 10c1bf: 85 c0 test %eax,%eax 10c1c1: 0f 84 f1 01 00 00 je 10c3b8 <_Thread_Initialize+0x250><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10c1c7: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10c1cd: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx) 10c1d4: eb 09 jmp 10c1df <_Thread_Initialize+0x77> } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 10c1d6: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx) 10c1dd: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10c1df: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx) the_stack->size = size; 10c1e5: 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; 10c1eb: 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 ) { 10c1ed: 84 d2 test %dl,%dl 10c1ef: 74 17 je 10c208 <_Thread_Initialize+0xa0> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10c1f1: 83 ec 0c sub $0xc,%esp 10c1f4: 6a 6c push $0x6c 10c1f6: e8 bb 0d 00 00 call 10cfb6 <_Workspace_Allocate> 10c1fb: 89 c7 mov %eax,%edi if ( !fp_area ) 10c1fd: 83 c4 10 add $0x10,%esp 10c200: 85 c0 test %eax,%eax 10c202: 0f 84 25 01 00 00 je 10c32d <_Thread_Initialize+0x1c5> goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10c208: 89 bb e0 00 00 00 mov %edi,0xe0(%ebx) the_thread->Start.fp_context = fp_area; 10c20e: 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; 10c214: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10c21b: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10c222: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10c229: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c230: a1 94 43 12 00 mov 0x124394,%eax * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c235: 31 f6 xor %esi,%esi #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c237: 85 c0 test %eax,%eax 10c239: 74 1d je 10c258 <_Thread_Initialize+0xf0> extensions_area = _Workspace_Allocate( 10c23b: 83 ec 0c sub $0xc,%esp 10c23e: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10c245: 50 push %eax 10c246: e8 6b 0d 00 00 call 10cfb6 <_Workspace_Allocate> 10c24b: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10c24d: 83 c4 10 add $0x10,%esp 10c250: 85 c0 test %eax,%eax 10c252: 0f 84 d7 00 00 00 je 10c32f <_Thread_Initialize+0x1c7> goto failed; } the_thread->extensions = (void **) extensions_area; 10c258: 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 ) { 10c25e: 85 f6 test %esi,%esi 10c260: 74 16 je 10c278 <_Thread_Initialize+0x110> for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10c262: 8b 15 94 43 12 00 mov 0x124394,%edx 10c268: 31 c0 xor %eax,%eax 10c26a: eb 08 jmp 10c274 <_Thread_Initialize+0x10c> the_thread->extensions[i] = NULL; 10c26c: 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++ ) 10c273: 40 inc %eax 10c274: 39 d0 cmp %edx,%eax 10c276: 76 f4 jbe 10c26c <_Thread_Initialize+0x104> /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c278: 8a 45 e3 mov -0x1d(%ebp),%al 10c27b: 88 83 a0 00 00 00 mov %al,0xa0(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10c281: 8b 45 24 mov 0x24(%ebp),%eax 10c284: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.budget_callout = budget_callout; 10c28a: 8b 45 28 mov 0x28(%ebp),%eax 10c28d: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) switch ( budget_algorithm ) { 10c293: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10c297: 75 08 jne 10c2a1 <_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; 10c299: a1 b0 42 12 00 mov 0x1242b0,%eax 10c29e: 89 43 78 mov %eax,0x78(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10c2a1: 8b 45 2c mov 0x2c(%ebp),%eax 10c2a4: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) the_thread->current_state = STATES_DORMANT; 10c2aa: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10c2b1: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10c2b8: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10c2bf: 8b 45 1c mov 0x1c(%ebp),%eax 10c2c2: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10c2c5: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) RTEMS_INLINE_ROUTINE void* _Scheduler_Thread_scheduler_allocate( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { return 10c2cb: 52 push %edx 10c2cc: 52 push %edx 10c2cd: 53 push %ebx 10c2ce: 68 68 43 12 00 push $0x124368 10c2d3: ff 15 7c 43 12 00 call *0x12437c 10c2d9: 89 45 e4 mov %eax,-0x1c(%ebp) sched =_Scheduler_Thread_scheduler_allocate( &_Scheduler, the_thread ); if ( !sched ) 10c2dc: 83 c4 10 add $0x10,%esp 10c2df: 85 c0 test %eax,%eax 10c2e1: 74 53 je 10c336 <_Thread_Initialize+0x1ce> goto failed; _Thread_Set_priority( the_thread, priority ); 10c2e3: 50 push %eax 10c2e4: 50 push %eax 10c2e5: ff 75 1c pushl 0x1c(%ebp) 10c2e8: 53 push %ebx 10c2e9: e8 7a 05 00 00 call 10c868 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10c2ee: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10c2f5: 00 00 00 10c2f8: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10c2ff: 00 00 00 _Thread_Stack_Free( the_thread ); return false; } 10c302: 8b 45 08 mov 0x8(%ebp),%eax 10c305: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c308: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c30c: 89 1c 90 mov %ebx,(%eax,%edx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c30f: 8b 45 30 mov 0x30(%ebp),%eax 10c312: 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 ); 10c315: 89 1c 24 mov %ebx,(%esp) 10c318: e8 7b 09 00 00 call 10cc98 <_User_extensions_Thread_create> 10c31d: 88 c2 mov %al,%dl if ( extension_status ) 10c31f: 83 c4 10 add $0x10,%esp return true; 10c322: 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 ) 10c324: 84 d2 test %dl,%dl 10c326: 74 0e je 10c336 <_Thread_Initialize+0x1ce> 10c328: e9 8d 00 00 00 jmp 10c3ba <_Thread_Initialize+0x252> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c32d: 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; 10c32f: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; failed: if ( the_thread->libc_reent ) 10c336: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax 10c33c: 85 c0 test %eax,%eax 10c33e: 74 0c je 10c34c <_Thread_Initialize+0x1e4> _Workspace_Free( the_thread->libc_reent ); 10c340: 83 ec 0c sub $0xc,%esp 10c343: 50 push %eax 10c344: e8 86 0c 00 00 call 10cfcf <_Workspace_Free> 10c349: 83 c4 10 add $0x10,%esp for ( i=0 ; i <= THREAD_API_LAST ; i++ ) if ( the_thread->API_Extensions[i] ) 10c34c: 8b 83 e8 00 00 00 mov 0xe8(%ebx),%eax 10c352: 85 c0 test %eax,%eax 10c354: 74 0c je 10c362 <_Thread_Initialize+0x1fa> _Workspace_Free( the_thread->API_Extensions[i] ); 10c356: 83 ec 0c sub $0xc,%esp 10c359: 50 push %eax 10c35a: e8 70 0c 00 00 call 10cfcf <_Workspace_Free> 10c35f: 83 c4 10 add $0x10,%esp failed: if ( the_thread->libc_reent ) _Workspace_Free( the_thread->libc_reent ); for ( i=0 ; i <= THREAD_API_LAST ; i++ ) if ( the_thread->API_Extensions[i] ) 10c362: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 10c368: 85 c0 test %eax,%eax 10c36a: 74 0c je 10c378 <_Thread_Initialize+0x210> _Workspace_Free( the_thread->API_Extensions[i] ); 10c36c: 83 ec 0c sub $0xc,%esp 10c36f: 50 push %eax 10c370: e8 5a 0c 00 00 call 10cfcf <_Workspace_Free> 10c375: 83 c4 10 add $0x10,%esp if ( extensions_area ) 10c378: 85 f6 test %esi,%esi 10c37a: 74 0c je 10c388 <_Thread_Initialize+0x220> (void) _Workspace_Free( extensions_area ); 10c37c: 83 ec 0c sub $0xc,%esp 10c37f: 56 push %esi 10c380: e8 4a 0c 00 00 call 10cfcf <_Workspace_Free> 10c385: 83 c4 10 add $0x10,%esp #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10c388: 85 ff test %edi,%edi 10c38a: 74 0c je 10c398 <_Thread_Initialize+0x230> (void) _Workspace_Free( fp_area ); 10c38c: 83 ec 0c sub $0xc,%esp 10c38f: 57 push %edi 10c390: e8 3a 0c 00 00 call 10cfcf <_Workspace_Free> 10c395: 83 c4 10 add $0x10,%esp #endif if ( sched ) 10c398: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10c39c: 74 0e je 10c3ac <_Thread_Initialize+0x244> (void) _Workspace_Free( sched ); 10c39e: 83 ec 0c sub $0xc,%esp 10c3a1: ff 75 e4 pushl -0x1c(%ebp) 10c3a4: e8 26 0c 00 00 call 10cfcf <_Workspace_Free> 10c3a9: 83 c4 10 add $0x10,%esp _Thread_Stack_Free( the_thread ); 10c3ac: 83 ec 0c sub $0xc,%esp 10c3af: 53 push %ebx 10c3b0: e8 d3 05 00 00 call 10c988 <_Thread_Stack_Free> return false; 10c3b5: 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 */ 10c3b8: 31 c0 xor %eax,%eax _Thread_Stack_Free( the_thread ); return false; } 10c3ba: 8d 65 f4 lea -0xc(%ebp),%esp 10c3bd: 5b pop %ebx 10c3be: 5e pop %esi 10c3bf: 5f pop %edi 10c3c0: c9 leave 10c3c1: c3 ret =============================================================================== 0010f5f0 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10f5f0: 55 push %ebp 10f5f1: 89 e5 mov %esp,%ebp 10f5f3: 53 push %ebx 10f5f4: 83 ec 04 sub $0x4,%esp 10f5f7: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10f5fa: 9c pushf 10f5fb: fa cli 10f5fc: 5b pop %ebx current_state = the_thread->current_state; 10f5fd: 8b 50 10 mov 0x10(%eax),%edx if ( current_state & STATES_SUSPENDED ) { 10f600: f6 c2 02 test $0x2,%dl 10f603: 74 1b je 10f620 <_Thread_Resume+0x30> <== NEVER TAKEN 10f605: 83 e2 fd and $0xfffffffd,%edx current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); 10f608: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 10f60b: 85 d2 test %edx,%edx 10f60d: 75 11 jne 10f620 <_Thread_Resume+0x30> RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { the_scheduler->Operations.unblock( the_scheduler, the_thread ); 10f60f: 52 push %edx 10f610: 52 push %edx 10f611: 50 push %eax 10f612: 68 30 74 12 00 push $0x127430 10f617: ff 15 40 74 12 00 call *0x127440 10f61d: 83 c4 10 add $0x10,%esp _Scheduler_Unblock( &_Scheduler, the_thread ); } } _ISR_Enable( level ); 10f620: 53 push %ebx 10f621: 9d popf } 10f622: 8b 5d fc mov -0x4(%ebp),%ebx 10f625: c9 leave 10f626: c3 ret =============================================================================== 0010ca70 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10ca70: 55 push %ebp 10ca71: 89 e5 mov %esp,%ebp 10ca73: 53 push %ebx 10ca74: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10ca77: 8b 1d 28 48 12 00 mov 0x124828,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10ca7d: 80 7b 74 00 cmpb $0x0,0x74(%ebx) 10ca81: 74 55 je 10cad8 <_Thread_Tickle_timeslice+0x68> return; if ( !_States_Is_ready( executing->current_state ) ) 10ca83: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10ca87: 75 4f jne 10cad8 <_Thread_Tickle_timeslice+0x68> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10ca89: 8b 43 7c mov 0x7c(%ebx),%eax 10ca8c: 83 f8 01 cmp $0x1,%eax 10ca8f: 72 47 jb 10cad8 <_Thread_Tickle_timeslice+0x68> 10ca91: 83 f8 02 cmp $0x2,%eax 10ca94: 76 07 jbe 10ca9d <_Thread_Tickle_timeslice+0x2d> 10ca96: 83 f8 03 cmp $0x3,%eax 10ca99: 75 3d jne 10cad8 <_Thread_Tickle_timeslice+0x68><== NEVER TAKEN 10ca9b: eb 23 jmp 10cac0 <_Thread_Tickle_timeslice+0x50> case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: #endif if ( (int)(--executing->cpu_time_budget) <= 0 ) { 10ca9d: 8b 43 78 mov 0x78(%ebx),%eax 10caa0: 48 dec %eax 10caa1: 89 43 78 mov %eax,0x78(%ebx) 10caa4: 85 c0 test %eax,%eax 10caa6: 7f 30 jg 10cad8 <_Thread_Tickle_timeslice+0x68> * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield( &_Scheduler ); 10caa8: 83 ec 0c sub $0xc,%esp 10caab: 68 68 43 12 00 push $0x124368 10cab0: ff 15 70 43 12 00 call *0x124370 * executing thread's timeslice is reset. Otherwise, the * currently executing thread is placed at the rear of the * FIFO for this priority and a new heir is selected. */ _Scheduler_Yield( ); executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10cab6: a1 b0 42 12 00 mov 0x1242b0,%eax 10cabb: 89 43 78 mov %eax,0x78(%ebx) 10cabe: eb 15 jmp 10cad5 <_Thread_Tickle_timeslice+0x65> } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10cac0: 8b 43 78 mov 0x78(%ebx),%eax 10cac3: 48 dec %eax 10cac4: 89 43 78 mov %eax,0x78(%ebx) 10cac7: 85 c0 test %eax,%eax 10cac9: 75 0d jne 10cad8 <_Thread_Tickle_timeslice+0x68> (*executing->budget_callout)( executing ); 10cacb: 83 ec 0c sub $0xc,%esp 10cace: 53 push %ebx 10cacf: ff 93 80 00 00 00 call *0x80(%ebx) 10cad5: 83 c4 10 add $0x10,%esp break; #endif } } 10cad8: 8b 5d fc mov -0x4(%ebp),%ebx 10cadb: c9 leave 10cadc: c3 ret =============================================================================== 0010c7e0 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10c7e0: 55 push %ebp 10c7e1: 89 e5 mov %esp,%ebp 10c7e3: 57 push %edi 10c7e4: 56 push %esi 10c7e5: 53 push %ebx 10c7e6: 83 ec 1c sub $0x1c,%esp 10c7e9: 8b 75 08 mov 0x8(%ebp),%esi 10c7ec: 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 ) 10c7ef: 85 f6 test %esi,%esi 10c7f1: 74 36 je 10c829 <_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 ) { 10c7f3: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10c7f7: 75 30 jne 10c829 <_Thread_queue_Requeue+0x49><== NEVER TAKEN Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10c7f9: 9c pushf 10c7fa: fa cli 10c7fb: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10c7fc: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10c803: 74 22 je 10c827 <_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; 10c805: 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 ); 10c80c: 50 push %eax 10c80d: 6a 01 push $0x1 10c80f: 57 push %edi 10c810: 56 push %esi 10c811: e8 0a 32 00 00 call 10fa20 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10c816: 83 c4 0c add $0xc,%esp 10c819: 8d 45 e4 lea -0x1c(%ebp),%eax 10c81c: 50 push %eax 10c81d: 57 push %edi 10c81e: 56 push %esi 10c81f: e8 c0 fd ff ff call 10c5e4 <_Thread_queue_Enqueue_priority> 10c824: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10c827: 53 push %ebx 10c828: 9d popf } } 10c829: 8d 65 f4 lea -0xc(%ebp),%esp 10c82c: 5b pop %ebx 10c82d: 5e pop %esi 10c82e: 5f pop %edi 10c82f: c9 leave 10c830: c3 ret =============================================================================== 0010c834 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c834: 55 push %ebp 10c835: 89 e5 mov %esp,%ebp 10c837: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c83a: 8d 45 f4 lea -0xc(%ebp),%eax 10c83d: 50 push %eax 10c83e: ff 75 08 pushl 0x8(%ebp) 10c841: e8 b2 f8 ff ff call 10c0f8 <_Thread_Get> switch ( location ) { 10c846: 83 c4 10 add $0x10,%esp 10c849: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c84d: 75 17 jne 10c866 <_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 ); 10c84f: 83 ec 0c sub $0xc,%esp 10c852: 50 push %eax 10c853: e8 80 32 00 00 call 10fad8 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10c858: a1 e0 42 12 00 mov 0x1242e0,%eax 10c85d: 48 dec %eax 10c85e: a3 e0 42 12 00 mov %eax,0x1242e0 10c863: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10c866: c9 leave 10c867: c3 ret =============================================================================== 00116978 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 116978: 55 push %ebp 116979: 89 e5 mov %esp,%ebp 11697b: 57 push %edi 11697c: 56 push %esi 11697d: 53 push %ebx 11697e: 83 ec 4c sub $0x4c,%esp 116981: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116984: 8d 55 dc lea -0x24(%ebp),%edx 116987: 8d 45 e0 lea -0x20(%ebp),%eax 11698a: 89 45 dc mov %eax,-0x24(%ebp) head->previous = NULL; 11698d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 116994: 89 55 e4 mov %edx,-0x1c(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116997: 8d 7d d0 lea -0x30(%ebp),%edi 11699a: 8d 4d d4 lea -0x2c(%ebp),%ecx 11699d: 89 4d d0 mov %ecx,-0x30(%ebp) head->previous = NULL; 1169a0: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 1169a7: 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 ); 1169aa: 8d 53 30 lea 0x30(%ebx),%edx 1169ad: 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 ); 1169b0: 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; 1169b3: 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; 1169b6: 8d 4d dc lea -0x24(%ebp),%ecx 1169b9: 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; 1169bc: a1 28 e8 13 00 mov 0x13e828,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 1169c1: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 1169c4: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169c7: 51 push %ecx 1169c8: 57 push %edi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 1169c9: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169cb: 50 push %eax 1169cc: ff 75 c0 pushl -0x40(%ebp) 1169cf: e8 88 39 00 00 call 11a35c <_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(); 1169d4: a1 a0 e7 13 00 mov 0x13e7a0,%eax 1169d9: 89 45 c4 mov %eax,-0x3c(%ebp) Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 1169dc: 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 ) { 1169df: 83 c4 10 add $0x10,%esp 1169e2: 39 45 c4 cmp %eax,-0x3c(%ebp) 1169e5: 76 10 jbe 1169f7 <_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 ); 1169e7: 52 push %edx 1169e8: 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; 1169e9: 8b 55 c4 mov -0x3c(%ebp),%edx 1169ec: 29 c2 sub %eax,%edx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169ee: 52 push %edx 1169ef: 56 push %esi 1169f0: e8 67 39 00 00 call 11a35c <_Watchdog_Adjust_to_chain> 1169f5: eb 0f jmp 116a06 <_Timer_server_Body+0x8e> } else if ( snapshot < last_snapshot ) { 1169f7: 73 10 jae 116a09 <_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 ); 1169f9: 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; 1169fa: 2b 45 c4 sub -0x3c(%ebp),%eax _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 1169fd: 50 push %eax 1169fe: 6a 01 push $0x1 116a00: 56 push %esi 116a01: e8 ea 38 00 00 call 11a2f0 <_Watchdog_Adjust> 116a06: 83 c4 10 add $0x10,%esp } watchdogs->last_snapshot = snapshot; 116a09: 8b 4d c4 mov -0x3c(%ebp),%ecx 116a0c: 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 ); 116a0f: 8b 43 78 mov 0x78(%ebx),%eax 116a12: 83 ec 0c sub $0xc,%esp 116a15: 50 push %eax 116a16: e8 f5 08 00 00 call 117310 <_Chain_Get> if ( timer == NULL ) { 116a1b: 83 c4 10 add $0x10,%esp 116a1e: 85 c0 test %eax,%eax 116a20: 74 29 je 116a4b <_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 ) { 116a22: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 116a25: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 116a28: 75 0b jne 116a35 <_Timer_server_Body+0xbd><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116a2a: 52 push %edx <== NOT EXECUTED 116a2b: 52 push %edx <== NOT EXECUTED 116a2c: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 116a2f: 50 push %eax <== NOT EXECUTED 116a30: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 116a33: eb 0c jmp 116a41 <_Timer_server_Body+0xc9><== NOT EXECUTED } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116a35: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 116a38: 75 d5 jne 116a0f <_Timer_server_Body+0x97><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116a3a: 51 push %ecx <== NOT EXECUTED 116a3b: 51 push %ecx <== NOT EXECUTED 116a3c: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 116a3f: 50 push %eax <== NOT EXECUTED 116a40: 56 push %esi <== NOT EXECUTED 116a41: e8 9e 39 00 00 call 11a3e4 <_Watchdog_Insert> <== NOT EXECUTED 116a46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116a49: eb c4 jmp 116a0f <_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 ); 116a4b: 9c pushf 116a4c: fa cli 116a4d: 5a pop %edx tmp = ts->insert_chain; 116a4e: 8b 43 78 mov 0x78(%ebx),%eax if ( _Chain_Is_empty( insert_chain ) ) { 116a51: b0 01 mov $0x1,%al 116a53: 8b 4d b4 mov -0x4c(%ebp),%ecx 116a56: 39 4d dc cmp %ecx,-0x24(%ebp) 116a59: 75 09 jne 116a64 <_Timer_server_Body+0xec><== NEVER TAKEN ts->insert_chain = NULL; 116a5b: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) do_loop = false; 116a62: 31 c0 xor %eax,%eax } _ISR_Enable( level ); 116a64: 52 push %edx 116a65: 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 ) { 116a66: 84 c0 test %al,%al 116a68: 0f 85 4e ff ff ff jne 1169bc <_Timer_server_Body+0x44><== NEVER TAKEN 116a6e: 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 ) ) { 116a71: 39 45 d0 cmp %eax,-0x30(%ebp) 116a74: 74 3a je 116ab0 <_Timer_server_Body+0x138> 116a76: 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 ); 116a79: 9c pushf 116a7a: fa cli 116a7b: 59 pop %ecx initialized = false; } #endif return status; } 116a7c: 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)) 116a7f: 3b 45 b0 cmp -0x50(%ebp),%eax 116a82: 74 25 je 116aa9 <_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; 116a84: 8b 10 mov (%eax),%edx head->next = new_first; 116a86: 89 55 d0 mov %edx,-0x30(%ebp) new_first->previous = head; 116a89: 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 ) { 116a8c: 85 c0 test %eax,%eax 116a8e: 74 19 je 116aa9 <_Timer_server_Body+0x131><== NEVER TAKEN watchdog->state = WATCHDOG_INACTIVE; 116a90: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 116a97: 51 push %ecx 116a98: 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 ); 116a99: 52 push %edx 116a9a: 52 push %edx 116a9b: ff 70 24 pushl 0x24(%eax) 116a9e: ff 70 20 pushl 0x20(%eax) 116aa1: ff 50 1c call *0x1c(%eax) } 116aa4: 83 c4 10 add $0x10,%esp 116aa7: eb d0 jmp 116a79 <_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 ); 116aa9: 51 push %ecx 116aaa: 9d popf 116aab: e9 06 ff ff ff jmp 1169b6 <_Timer_server_Body+0x3e> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 116ab0: c6 43 7c 00 movb $0x0,0x7c(%ebx) /* * Block until there is something to do. */ _Thread_Disable_dispatch(); 116ab4: e8 23 fe ff ff call 1168dc <_Thread_Disable_dispatch> _Thread_Set_state( ts->thread, STATES_DELAYING ); 116ab9: 51 push %ecx 116aba: 51 push %ecx 116abb: 6a 08 push $0x8 116abd: ff 33 pushl (%ebx) 116abf: e8 7c 32 00 00 call 119d40 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 116ac4: 89 d8 mov %ebx,%eax 116ac6: e8 21 fe ff ff call 1168ec <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 116acb: 89 d8 mov %ebx,%eax 116acd: e8 60 fe ff ff call 116932 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 116ad2: e8 f7 29 00 00 call 1194ce <_Thread_Enable_dispatch> ts->active = true; 116ad7: 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 ); 116adb: 8d 43 08 lea 0x8(%ebx),%eax 116ade: 89 04 24 mov %eax,(%esp) 116ae1: e8 1e 3a 00 00 call 11a504 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 116ae6: 8d 43 40 lea 0x40(%ebx),%eax 116ae9: 89 04 24 mov %eax,(%esp) 116aec: e8 13 3a 00 00 call 11a504 <_Watchdog_Remove> 116af1: 83 c4 10 add $0x10,%esp 116af4: e9 bd fe ff ff jmp 1169b6 <_Timer_server_Body+0x3e> =============================================================================== 00116af9 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 116af9: 55 push %ebp 116afa: 89 e5 mov %esp,%ebp 116afc: 57 push %edi 116afd: 56 push %esi 116afe: 53 push %ebx 116aff: 83 ec 2c sub $0x2c,%esp 116b02: 8b 5d 08 mov 0x8(%ebp),%ebx 116b05: 8b 75 0c mov 0xc(%ebp),%esi if ( ts->insert_chain == NULL ) { 116b08: 8b 43 78 mov 0x78(%ebx),%eax 116b0b: 85 c0 test %eax,%eax 116b0d: 0f 85 de 00 00 00 jne 116bf1 <_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(); 116b13: e8 c4 fd ff ff call 1168dc <_Thread_Disable_dispatch> if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116b18: 8b 46 38 mov 0x38(%esi),%eax 116b1b: 83 f8 01 cmp $0x1,%eax 116b1e: 75 5a jne 116b7a <_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 ); 116b20: 9c pushf 116b21: fa cli 116b22: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116b25: 8b 15 28 e8 13 00 mov 0x13e828,%edx last_snapshot = ts->Interval_watchdogs.last_snapshot; 116b2b: 8b 4b 3c mov 0x3c(%ebx),%ecx initialized = false; } #endif return status; } 116b2e: 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 ); 116b31: 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 ) ) { 116b34: 39 f8 cmp %edi,%eax 116b36: 74 19 je 116b51 <_Timer_server_Schedule_operation_method+0x58> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116b38: 89 d7 mov %edx,%edi 116b3a: 29 cf sub %ecx,%edi 116b3c: 89 7d e4 mov %edi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 116b3f: 8b 78 10 mov 0x10(%eax),%edi if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116b42: 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) { 116b44: 3b 7d e4 cmp -0x1c(%ebp),%edi 116b47: 76 05 jbe 116b4e <_Timer_server_Schedule_operation_method+0x55> delta_interval -= delta; 116b49: 89 f9 mov %edi,%ecx 116b4b: 2b 4d e4 sub -0x1c(%ebp),%ecx } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 116b4e: 89 48 10 mov %ecx,0x10(%eax) } ts->Interval_watchdogs.last_snapshot = snapshot; 116b51: 89 53 3c mov %edx,0x3c(%ebx) _ISR_Enable( level ); 116b54: ff 75 e0 pushl -0x20(%ebp) 116b57: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116b58: 50 push %eax 116b59: 50 push %eax 116b5a: 83 c6 10 add $0x10,%esi 116b5d: 56 push %esi 116b5e: 8d 43 30 lea 0x30(%ebx),%eax 116b61: 50 push %eax 116b62: e8 7d 38 00 00 call 11a3e4 <_Watchdog_Insert> if ( !ts->active ) { 116b67: 8a 43 7c mov 0x7c(%ebx),%al 116b6a: 83 c4 10 add $0x10,%esp 116b6d: 84 c0 test %al,%al 116b6f: 75 74 jne 116be5 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_interval_system_watchdog( ts ); 116b71: 89 d8 mov %ebx,%eax 116b73: e8 74 fd ff ff call 1168ec <_Timer_server_Reset_interval_system_watchdog> 116b78: eb 6b jmp 116be5 <_Timer_server_Schedule_operation_method+0xec> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116b7a: 83 f8 03 cmp $0x3,%eax 116b7d: 75 66 jne 116be5 <_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 ); 116b7f: 9c pushf 116b80: fa cli 116b81: 8f 45 e0 popl -0x20(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 116b84: 8b 15 a0 e7 13 00 mov 0x13e7a0,%edx last_snapshot = ts->TOD_watchdogs.last_snapshot; 116b8a: 8b 43 74 mov 0x74(%ebx),%eax initialized = false; } #endif return status; } 116b8d: 8b 4b 68 mov 0x68(%ebx),%ecx 116b90: 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 ) ) { 116b93: 39 f9 cmp %edi,%ecx 116b95: 74 27 je 116bbe <_Timer_server_Schedule_operation_method+0xc5> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 116b97: 8b 79 10 mov 0x10(%ecx),%edi 116b9a: 89 7d d4 mov %edi,-0x2c(%ebp) if ( snapshot > last_snapshot ) { 116b9d: 39 c2 cmp %eax,%edx 116b9f: 76 15 jbe 116bb6 <_Timer_server_Schedule_operation_method+0xbd> /* * We advanced in time. */ delta = snapshot - last_snapshot; 116ba1: 89 d7 mov %edx,%edi 116ba3: 29 c7 sub %eax,%edi 116ba5: 89 7d e4 mov %edi,-0x1c(%ebp) if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116ba8: 31 c0 xor %eax,%eax if ( snapshot > last_snapshot ) { /* * We advanced in time. */ delta = snapshot - last_snapshot; if (delta_interval > delta) { 116baa: 39 7d d4 cmp %edi,-0x2c(%ebp) 116bad: 76 0c jbe 116bbb <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN delta_interval -= delta; 116baf: 8b 45 d4 mov -0x2c(%ebp),%eax 116bb2: 29 f8 sub %edi,%eax 116bb4: eb 05 jmp 116bbb <_Timer_server_Schedule_operation_method+0xc2> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 116bb6: 03 45 d4 add -0x2c(%ebp),%eax delta_interval += delta; 116bb9: 29 d0 sub %edx,%eax } first_watchdog->delta_interval = delta_interval; 116bbb: 89 41 10 mov %eax,0x10(%ecx) } ts->TOD_watchdogs.last_snapshot = snapshot; 116bbe: 89 53 74 mov %edx,0x74(%ebx) _ISR_Enable( level ); 116bc1: ff 75 e0 pushl -0x20(%ebp) 116bc4: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116bc5: 57 push %edi 116bc6: 57 push %edi 116bc7: 83 c6 10 add $0x10,%esi 116bca: 56 push %esi 116bcb: 8d 43 68 lea 0x68(%ebx),%eax 116bce: 50 push %eax 116bcf: e8 10 38 00 00 call 11a3e4 <_Watchdog_Insert> if ( !ts->active ) { 116bd4: 8a 43 7c mov 0x7c(%ebx),%al 116bd7: 83 c4 10 add $0x10,%esp 116bda: 84 c0 test %al,%al 116bdc: 75 07 jne 116be5 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_tod_system_watchdog( ts ); 116bde: 89 d8 mov %ebx,%eax 116be0: e8 4d fd ff ff call 116932 <_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 ); } } 116be5: 8d 65 f4 lea -0xc(%ebp),%esp 116be8: 5b pop %ebx 116be9: 5e pop %esi 116bea: 5f pop %edi 116beb: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 116bec: e9 dd 28 00 00 jmp 1194ce <_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 ); 116bf1: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 116bf4: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 116bf7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } 116bfa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116bfd: 5b pop %ebx <== NOT EXECUTED 116bfe: 5e pop %esi <== NOT EXECUTED 116bff: 5f pop %edi <== NOT EXECUTED 116c00: 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 ); 116c01: e9 ce 06 00 00 jmp 1172d4 <_Chain_Append> <== NOT EXECUTED =============================================================================== 0010cc5b <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10cc5b: 55 push %ebp 10cc5c: 89 e5 mov %esp,%ebp 10cc5e: 57 push %edi 10cc5f: 56 push %esi 10cc60: 53 push %ebx 10cc61: 83 ec 0c sub $0xc,%esp 10cc64: 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 ); } } 10cc67: 8b 1d d4 44 12 00 mov 0x1244d4,%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 ); 10cc6d: 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 ); 10cc71: eb 15 jmp 10cc88 <_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 ) 10cc73: 8b 43 30 mov 0x30(%ebx),%eax 10cc76: 85 c0 test %eax,%eax 10cc78: 74 0b je 10cc85 <_User_extensions_Fatal+0x2a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10cc7a: 52 push %edx 10cc7b: 57 push %edi 10cc7c: 56 push %esi 10cc7d: ff 75 08 pushl 0x8(%ebp) 10cc80: ff d0 call *%eax 10cc82: 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 ) { 10cc85: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10cc88: 81 fb cc 44 12 00 cmp $0x1244cc,%ebx 10cc8e: 75 e3 jne 10cc73 <_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 ); } } 10cc90: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cc93: 5b pop %ebx <== NOT EXECUTED 10cc94: 5e pop %esi <== NOT EXECUTED 10cc95: 5f pop %edi <== NOT EXECUTED 10cc96: c9 leave <== NOT EXECUTED 10cc97: c3 ret <== NOT EXECUTED =============================================================================== 0010cb44 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10cb44: 55 push %ebp 10cb45: 89 e5 mov %esp,%ebp 10cb47: 57 push %edi 10cb48: 56 push %esi 10cb49: 53 push %ebx 10cb4a: 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; 10cb4d: a1 34 02 12 00 mov 0x120234,%eax 10cb52: 89 45 e4 mov %eax,-0x1c(%ebp) initial_extensions = Configuration.User_extension_table; 10cb55: 8b 35 38 02 12 00 mov 0x120238,%esi ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10cb5b: c7 05 cc 44 12 00 d0 movl $0x1244d0,0x1244cc 10cb62: 44 12 00 head->previous = NULL; 10cb65: c7 05 d0 44 12 00 00 movl $0x0,0x1244d0 10cb6c: 00 00 00 tail->previous = head; 10cb6f: c7 05 d4 44 12 00 cc movl $0x1244cc,0x1244d4 10cb76: 44 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10cb79: c7 05 e4 42 12 00 e8 movl $0x1242e8,0x1242e4 10cb80: 42 12 00 head->previous = NULL; 10cb83: c7 05 e8 42 12 00 00 movl $0x0,0x1242e8 10cb8a: 00 00 00 tail->previous = head; 10cb8d: c7 05 ec 42 12 00 e4 movl $0x1242e4,0x1242ec 10cb94: 42 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10cb97: 85 f6 test %esi,%esi 10cb99: 74 53 je 10cbee <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10cb9b: 6b c8 34 imul $0x34,%eax,%ecx 10cb9e: 83 ec 0c sub $0xc,%esp 10cba1: 51 push %ecx 10cba2: 89 4d e0 mov %ecx,-0x20(%ebp) 10cba5: e8 3a 04 00 00 call 10cfe4 <_Workspace_Allocate_or_fatal_error> 10cbaa: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10cbac: 31 c0 xor %eax,%eax 10cbae: 8b 4d e0 mov -0x20(%ebp),%ecx 10cbb1: 89 df mov %ebx,%edi 10cbb3: f3 aa rep stos %al,%es:(%edi) 10cbb5: 89 f0 mov %esi,%eax extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cbb7: 83 c4 10 add $0x10,%esp 10cbba: 31 d2 xor %edx,%edx 10cbbc: eb 2b jmp 10cbe9 <_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; 10cbbe: 8d 7b 14 lea 0x14(%ebx),%edi 10cbc1: 89 c6 mov %eax,%esi 10cbc3: b9 08 00 00 00 mov $0x8,%ecx 10cbc8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10cbca: 83 ec 0c sub $0xc,%esp 10cbcd: 53 push %ebx 10cbce: 89 45 dc mov %eax,-0x24(%ebp) 10cbd1: 89 55 e0 mov %edx,-0x20(%ebp) 10cbd4: e8 ef 2f 00 00 call 10fbc8 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10cbd9: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cbdc: 8b 55 e0 mov -0x20(%ebp),%edx 10cbdf: 42 inc %edx 10cbe0: 8b 45 dc mov -0x24(%ebp),%eax 10cbe3: 83 c0 20 add $0x20,%eax 10cbe6: 83 c4 10 add $0x10,%esp 10cbe9: 3b 55 e4 cmp -0x1c(%ebp),%edx 10cbec: 72 d0 jb 10cbbe <_User_extensions_Handler_initialization+0x7a> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10cbee: 8d 65 f4 lea -0xc(%ebp),%esp 10cbf1: 5b pop %ebx 10cbf2: 5e pop %esi 10cbf3: 5f pop %edi 10cbf4: c9 leave 10cbf5: c3 ret =============================================================================== 0010e4a4 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10e4a4: 55 push %ebp 10e4a5: 89 e5 mov %esp,%ebp 10e4a7: 57 push %edi 10e4a8: 56 push %esi 10e4a9: 53 push %ebx 10e4aa: 83 ec 1c sub $0x1c,%esp 10e4ad: 8b 75 08 mov 0x8(%ebp),%esi 10e4b0: 8b 7d 0c mov 0xc(%ebp),%edi 10e4b3: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10e4b6: 9c pushf 10e4b7: fa cli 10e4b8: 58 pop %eax } } _ISR_Enable( level ); } 10e4b9: 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 ); 10e4bb: 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 ) ) { 10e4be: 39 ca cmp %ecx,%edx 10e4c0: 74 44 je 10e506 <_Watchdog_Adjust+0x62> switch ( direction ) { 10e4c2: 85 ff test %edi,%edi 10e4c4: 74 3c je 10e502 <_Watchdog_Adjust+0x5e> 10e4c6: 4f dec %edi 10e4c7: 75 3d jne 10e506 <_Watchdog_Adjust+0x62> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10e4c9: 01 5a 10 add %ebx,0x10(%edx) break; 10e4cc: eb 38 jmp 10e506 <_Watchdog_Adjust+0x62> RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 10e4ce: 8b 16 mov (%esi),%edx case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10e4d0: 8b 7a 10 mov 0x10(%edx),%edi 10e4d3: 39 fb cmp %edi,%ebx 10e4d5: 73 07 jae 10e4de <_Watchdog_Adjust+0x3a> _Watchdog_First( header )->delta_interval -= units; 10e4d7: 29 df sub %ebx,%edi 10e4d9: 89 7a 10 mov %edi,0x10(%edx) break; 10e4dc: eb 28 jmp 10e506 <_Watchdog_Adjust+0x62> } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10e4de: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 10e4e5: 50 push %eax 10e4e6: 9d popf _Watchdog_Tickle( header ); 10e4e7: 83 ec 0c sub $0xc,%esp 10e4ea: 56 push %esi 10e4eb: 89 4d e4 mov %ecx,-0x1c(%ebp) 10e4ee: e8 a5 01 00 00 call 10e698 <_Watchdog_Tickle> _ISR_Disable( level ); 10e4f3: 9c pushf 10e4f4: fa cli 10e4f5: 58 pop %eax if ( _Chain_Is_empty( header ) ) 10e4f6: 83 c4 10 add $0x10,%esp 10e4f9: 8b 4d e4 mov -0x1c(%ebp),%ecx 10e4fc: 39 0e cmp %ecx,(%esi) 10e4fe: 74 06 je 10e506 <_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; 10e500: 29 fb sub %edi,%ebx switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e502: 85 db test %ebx,%ebx 10e504: 75 c8 jne 10e4ce <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN } break; } } _ISR_Enable( level ); 10e506: 50 push %eax 10e507: 9d popf } 10e508: 8d 65 f4 lea -0xc(%ebp),%esp 10e50b: 5b pop %ebx 10e50c: 5e pop %esi 10e50d: 5f pop %edi 10e50e: c9 leave 10e50f: c3 ret =============================================================================== 0010ce9c <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10ce9c: 55 push %ebp 10ce9d: 89 e5 mov %esp,%ebp 10ce9f: 56 push %esi 10cea0: 53 push %ebx 10cea1: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10cea4: 9c pushf 10cea5: fa cli 10cea6: 5e pop %esi previous_state = the_watchdog->state; 10cea7: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10ceaa: 83 f8 01 cmp $0x1,%eax 10cead: 74 09 je 10ceb8 <_Watchdog_Remove+0x1c> 10ceaf: 72 42 jb 10cef3 <_Watchdog_Remove+0x57> 10ceb1: 83 f8 03 cmp $0x3,%eax 10ceb4: 77 3d ja 10cef3 <_Watchdog_Remove+0x57> <== NEVER TAKEN 10ceb6: eb 09 jmp 10cec1 <_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; 10ceb8: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10cebf: eb 32 jmp 10cef3 <_Watchdog_Remove+0x57> case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10cec1: 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 ); } 10cec8: 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) ) 10ceca: 83 39 00 cmpl $0x0,(%ecx) 10cecd: 74 06 je 10ced5 <_Watchdog_Remove+0x39> next_watchdog->delta_interval += the_watchdog->delta_interval; 10cecf: 8b 5a 10 mov 0x10(%edx),%ebx 10ced2: 01 59 10 add %ebx,0x10(%ecx) if ( _Watchdog_Sync_count ) 10ced5: 8b 1d 10 44 12 00 mov 0x124410,%ebx 10cedb: 85 db test %ebx,%ebx 10cedd: 74 0c je 10ceeb <_Watchdog_Remove+0x4f> _Watchdog_Sync_level = _ISR_Nest_level; 10cedf: 8b 1d 24 48 12 00 mov 0x124824,%ebx 10cee5: 89 1d a8 43 12 00 mov %ebx,0x1243a8 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10ceeb: 8b 5a 04 mov 0x4(%edx),%ebx next->previous = previous; 10ceee: 89 59 04 mov %ebx,0x4(%ecx) previous->next = next; 10cef1: 89 0b mov %ecx,(%ebx) _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10cef3: 8b 0d 14 44 12 00 mov 0x124414,%ecx 10cef9: 89 4a 18 mov %ecx,0x18(%edx) _ISR_Enable( level ); 10cefc: 56 push %esi 10cefd: 9d popf return( previous_state ); } 10cefe: 5b pop %ebx 10ceff: 5e pop %esi 10cf00: c9 leave 10cf01: c3 ret =============================================================================== 0010e030 <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10e030: 55 push %ebp 10e031: 89 e5 mov %esp,%ebp 10e033: 57 push %edi 10e034: 56 push %esi 10e035: 53 push %ebx 10e036: 83 ec 20 sub $0x20,%esp 10e039: 8b 7d 08 mov 0x8(%ebp),%edi 10e03c: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10e03f: 9c pushf 10e040: fa cli 10e041: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10e044: 56 push %esi 10e045: 57 push %edi 10e046: 68 c8 0f 12 00 push $0x120fc8 10e04b: e8 88 aa ff ff call 108ad8 printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); } 10e050: 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 ); 10e052: 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 ) ) { 10e055: 83 c4 10 add $0x10,%esp 10e058: 39 f3 cmp %esi,%ebx 10e05a: 74 1d je 10e079 <_Watchdog_Report_chain+0x49> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10e05c: 52 push %edx 10e05d: 52 push %edx 10e05e: 53 push %ebx 10e05f: 6a 00 push $0x0 10e061: e8 32 00 00 00 call 10e098 <_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 ) 10e066: 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 ) ; 10e068: 83 c4 10 add $0x10,%esp 10e06b: 39 f3 cmp %esi,%ebx 10e06d: 75 ed jne 10e05c <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10e06f: 50 push %eax 10e070: 50 push %eax 10e071: 57 push %edi 10e072: 68 df 0f 12 00 push $0x120fdf 10e077: eb 08 jmp 10e081 <_Watchdog_Report_chain+0x51> } else { printk( "Chain is empty\n" ); 10e079: 83 ec 0c sub $0xc,%esp 10e07c: 68 ee 0f 12 00 push $0x120fee 10e081: e8 52 aa ff ff call 108ad8 10e086: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10e089: ff 75 e4 pushl -0x1c(%ebp) 10e08c: 9d popf } 10e08d: 8d 65 f4 lea -0xc(%ebp),%esp 10e090: 5b pop %ebx 10e091: 5e pop %esi 10e092: 5f pop %edi 10e093: c9 leave 10e094: c3 ret =============================================================================== 0010a7b4 : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 10a7b4: 55 push %ebp 10a7b5: 89 e5 mov %esp,%ebp 10a7b7: 57 push %edi 10a7b8: 56 push %esi 10a7b9: 53 push %ebx 10a7ba: 83 ec 18 sub $0x18,%esp 10a7bd: 8b 5d 08 mov 0x8(%ebp),%ebx 10a7c0: 8b 75 0c mov 0xc(%ebp),%esi rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 10a7c3: 68 78 72 12 00 push $0x127278 10a7c8: e8 07 10 00 00 call 10b7d4 if (fcntl (fildes, F_GETFD) < 0) { 10a7cd: 58 pop %eax 10a7ce: 5a pop %edx 10a7cf: 6a 01 push $0x1 10a7d1: 53 push %ebx 10a7d2: e8 85 60 00 00 call 11085c 10a7d7: 83 c4 10 add $0x10,%esp 10a7da: 85 c0 test %eax,%eax 10a7dc: 79 1d jns 10a7fb pthread_mutex_unlock(&aio_request_queue.mutex); 10a7de: 83 ec 0c sub $0xc,%esp 10a7e1: 68 78 72 12 00 push $0x127278 10a7e6: e8 69 10 00 00 call 10b854 rtems_set_errno_and_return_minus_one (EBADF); 10a7eb: e8 dc 8e 00 00 call 1136cc <__errno> 10a7f0: c7 00 09 00 00 00 movl $0x9,(%eax) 10a7f6: e9 fd 00 00 00 jmp 10a8f8 } /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { 10a7fb: 85 f6 test %esi,%esi 10a7fd: 0f 85 d7 00 00 00 jne 10a8da AIO_printf ("Cancel all requests\n"); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10a803: 57 push %edi 10a804: 6a 00 push $0x0 10a806: 53 push %ebx 10a807: 68 c0 72 12 00 push $0x1272c0 10a80c: e8 0b 03 00 00 call 10ab1c 10a811: 89 c6 mov %eax,%esi if (r_chain == NULL) { 10a813: 83 c4 10 add $0x10,%esp 10a816: 85 c0 test %eax,%eax 10a818: 0f 85 82 00 00 00 jne 10a8a0 AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10a81e: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc 10a825: 72 12 00 10a828: 74 5c je 10a886 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10a82a: 56 push %esi 10a82b: 6a 00 push $0x0 10a82d: 53 push %ebx 10a82e: 68 cc 72 12 00 push $0x1272cc 10a833: e8 e4 02 00 00 call 10ab1c 10a838: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10a83a: 83 c4 10 add $0x10,%esp 10a83d: 85 c0 test %eax,%eax 10a83f: 75 17 jne 10a858 pthread_mutex_unlock(&aio_request_queue.mutex); 10a841: 83 ec 0c sub $0xc,%esp 10a844: 68 78 72 12 00 push $0x127278 10a849: e8 06 10 00 00 call 10b854 return AIO_ALLDONE; 10a84e: 83 c4 10 add $0x10,%esp 10a851: b3 02 mov $0x2,%bl 10a853: e9 04 01 00 00 jmp 10a95c */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10a858: 83 ec 0c sub $0xc,%esp 10a85b: 50 push %eax 10a85c: e8 db 26 00 00 call 10cf3c <_Chain_Extract> } AIO_printf ("Request chain on [IQ]\n"); rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a861: 89 1c 24 mov %ebx,(%esp) 10a864: e8 f2 05 00 00 call 10ae5b pthread_mutex_destroy (&r_chain->mutex); 10a869: 8d 73 1c lea 0x1c(%ebx),%esi 10a86c: 89 34 24 mov %esi,(%esp) 10a86f: e8 40 0d 00 00 call 10b5b4 pthread_cond_destroy (&r_chain->mutex); 10a874: 89 34 24 mov %esi,(%esp) 10a877: e8 44 0a 00 00 call 10b2c0 free (r_chain); 10a87c: 89 1c 24 mov %ebx,(%esp) 10a87f: e8 ac d4 ff ff call 107d30 10a884: eb 3e jmp 10a8c4 pthread_mutex_unlock (&aio_request_queue.mutex); return AIO_CANCELED; } pthread_mutex_unlock (&aio_request_queue.mutex); 10a886: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a889: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10a88e: e8 c1 0f 00 00 call 10b854 <== NOT EXECUTED return AIO_ALLDONE; 10a893: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a896: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10a89b: e9 bc 00 00 00 jmp 10a95c <== NOT EXECUTED } AIO_printf ("Request chain on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10a8a0: 8d 58 1c lea 0x1c(%eax),%ebx 10a8a3: 83 ec 0c sub $0xc,%esp 10a8a6: 53 push %ebx 10a8a7: e8 28 0f 00 00 call 10b7d4 10a8ac: 89 34 24 mov %esi,(%esp) 10a8af: e8 88 26 00 00 call 10cf3c <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a8b4: 89 34 24 mov %esi,(%esp) 10a8b7: e8 9f 05 00 00 call 10ae5b pthread_mutex_unlock (&r_chain->mutex); 10a8bc: 89 1c 24 mov %ebx,(%esp) 10a8bf: e8 90 0f 00 00 call 10b854 pthread_mutex_unlock (&aio_request_queue.mutex); 10a8c4: c7 04 24 78 72 12 00 movl $0x127278,(%esp) 10a8cb: e8 84 0f 00 00 call 10b854 return AIO_CANCELED; 10a8d0: 83 c4 10 add $0x10,%esp 10a8d3: 31 db xor %ebx,%ebx 10a8d5: e9 82 00 00 00 jmp 10a95c } else { AIO_printf ("Cancel request\n"); if (aiocbp->aio_fildes != fildes) { 10a8da: 8b 3e mov (%esi),%edi 10a8dc: 39 df cmp %ebx,%edi 10a8de: 74 20 je 10a900 pthread_mutex_unlock (&aio_request_queue.mutex); 10a8e0: 83 ec 0c sub $0xc,%esp 10a8e3: 68 78 72 12 00 push $0x127278 10a8e8: e8 67 0f 00 00 call 10b854 rtems_set_errno_and_return_minus_one (EINVAL); 10a8ed: e8 da 8d 00 00 call 1136cc <__errno> 10a8f2: c7 00 16 00 00 00 movl $0x16,(%eax) 10a8f8: 83 c4 10 add $0x10,%esp 10a8fb: 83 cb ff or $0xffffffff,%ebx 10a8fe: eb 5c jmp 10a95c } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10a900: 53 push %ebx 10a901: 6a 00 push $0x0 10a903: 57 push %edi 10a904: 68 c0 72 12 00 push $0x1272c0 10a909: e8 0e 02 00 00 call 10ab1c if (r_chain == NULL) { 10a90e: 83 c4 10 add $0x10,%esp pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_unlock (&aio_request_queue.mutex); return result; } } return AIO_ALLDONE; 10a911: bb 02 00 00 00 mov $0x2,%ebx pthread_mutex_unlock (&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EINVAL); } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); if (r_chain == NULL) { 10a916: 85 c0 test %eax,%eax 10a918: 75 42 jne 10a95c if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10a91a: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc 10a921: 72 12 00 10a924: 74 26 je 10a94c <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10a926: 51 push %ecx 10a927: 6a 00 push $0x0 10a929: 57 push %edi 10a92a: 68 cc 72 12 00 push $0x1272cc 10a92f: e8 e8 01 00 00 call 10ab1c if (r_chain == NULL) { 10a934: 83 c4 10 add $0x10,%esp 10a937: 85 c0 test %eax,%eax 10a939: 74 a5 je 10a8e0 rtems_set_errno_and_return_minus_one (EINVAL); } AIO_printf ("Request on [IQ]\n"); result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10a93b: 52 push %edx 10a93c: 52 push %edx 10a93d: 56 push %esi 10a93e: 83 c0 08 add $0x8,%eax 10a941: 50 push %eax 10a942: e8 5d 05 00 00 call 10aea4 10a947: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&aio_request_queue.mutex); 10a949: 58 pop %eax 10a94a: eb 03 jmp 10a94f return result; } else { pthread_mutex_unlock (&aio_request_queue.mutex); 10a94c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a94f: 68 78 72 12 00 push $0x127278 10a954: e8 fb 0e 00 00 call 10b854 return AIO_ALLDONE; 10a959: 83 c4 10 add $0x10,%esp pthread_mutex_unlock (&aio_request_queue.mutex); return result; } } return AIO_ALLDONE; } 10a95c: 89 d8 mov %ebx,%eax 10a95e: 8d 65 f4 lea -0xc(%ebp),%esp 10a961: 5b pop %ebx 10a962: 5e pop %esi 10a963: 5f pop %edi 10a964: c9 leave 10a965: c3 ret =============================================================================== 0010a974 : int aio_fsync( int op, struct aiocb *aiocbp ) { 10a974: 55 push %ebp 10a975: 89 e5 mov %esp,%ebp 10a977: 53 push %ebx 10a978: 83 ec 04 sub $0x4,%esp 10a97b: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 10a97e: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 10a985: 74 1b je 10a9a2 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10a987: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10a98e: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a995: e8 32 8d 00 00 call 1136cc <__errno> 10a99a: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9a0: eb 74 jmp 10aa16 mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a9a2: 50 push %eax 10a9a3: 50 push %eax 10a9a4: 6a 03 push $0x3 10a9a6: ff 33 pushl (%ebx) 10a9a8: e8 af 5e 00 00 call 11085c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10a9ad: 83 e0 03 and $0x3,%eax 10a9b0: 48 dec %eax 10a9b1: 83 c4 10 add $0x10,%esp 10a9b4: 83 f8 01 cmp $0x1,%eax 10a9b7: 76 1b jbe 10a9d4 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10a9b9: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10a9c0: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a9c7: e8 00 8d 00 00 call 1136cc <__errno> 10a9cc: c7 00 09 00 00 00 movl $0x9,(%eax) 10a9d2: eb 42 jmp 10aa16 req = malloc (sizeof (rtems_aio_request)); 10a9d4: 83 ec 0c sub $0xc,%esp 10a9d7: 6a 18 push $0x18 10a9d9: e8 d6 d7 ff ff call 1081b4 if (req == NULL) 10a9de: 83 c4 10 add $0x10,%esp 10a9e1: 85 c0 test %eax,%eax 10a9e3: 75 1b jne 10aa00 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10a9e5: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10a9ec: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10a9f3: e8 d4 8c 00 00 call 1136cc <__errno> <== NOT EXECUTED 10a9f8: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10a9fe: eb 16 jmp 10aa16 <== NOT EXECUTED req->aiocbp = aiocbp; 10aa00: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_SYNC; 10aa03: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) return rtems_aio_enqueue (req); 10aa0a: 89 45 08 mov %eax,0x8(%ebp) } 10aa0d: 8b 5d fc mov -0x4(%ebp),%ebx 10aa10: 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); 10aa11: e9 eb 04 00 00 jmp 10af01 } 10aa16: 83 c8 ff or $0xffffffff,%eax 10aa19: 8b 5d fc mov -0x4(%ebp),%ebx 10aa1c: c9 leave 10aa1d: c3 ret =============================================================================== 0010b0fc : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10b0fc: 55 push %ebp 10b0fd: 89 e5 mov %esp,%ebp 10b0ff: 53 push %ebx 10b100: 83 ec 0c sub $0xc,%esp 10b103: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b106: 6a 03 push $0x3 10b108: ff 33 pushl (%ebx) 10b10a: e8 4d 57 00 00 call 11085c if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b10f: 83 e0 03 and $0x3,%eax 10b112: 83 c4 10 add $0x10,%esp 10b115: 83 f8 02 cmp $0x2,%eax 10b118: 74 1f je 10b139 10b11a: 85 c0 test %eax,%eax 10b11c: 74 1b je 10b139 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b11e: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b125: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b12c: e8 9b 85 00 00 call 1136cc <__errno> 10b131: c7 00 09 00 00 00 movl $0x9,(%eax) 10b137: eb 69 jmp 10b1a2 if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b139: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b13d: 75 06 jne 10b145 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b13f: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b143: 79 1b jns 10b160 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b145: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b14c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b153: e8 74 85 00 00 call 1136cc <__errno> 10b158: c7 00 16 00 00 00 movl $0x16,(%eax) 10b15e: eb 42 jmp 10b1a2 req = malloc (sizeof (rtems_aio_request)); 10b160: 83 ec 0c sub $0xc,%esp 10b163: 6a 18 push $0x18 10b165: e8 4a d0 ff ff call 1081b4 if (req == NULL) 10b16a: 83 c4 10 add $0x10,%esp 10b16d: 85 c0 test %eax,%eax 10b16f: 75 1b jne 10b18c <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b171: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b178: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b17f: e8 48 85 00 00 call 1136cc <__errno> <== NOT EXECUTED 10b184: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b18a: eb 16 jmp 10b1a2 <== NOT EXECUTED req->aiocbp = aiocbp; 10b18c: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10b18f: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10b196: 89 45 08 mov %eax,0x8(%ebp) } 10b199: 8b 5d fc mov -0x4(%ebp),%ebx 10b19c: 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); 10b19d: e9 5f fd ff ff jmp 10af01 } 10b1a2: 83 c8 ff or $0xffffffff,%eax 10b1a5: 8b 5d fc mov -0x4(%ebp),%ebx 10b1a8: c9 leave 10b1a9: c3 ret =============================================================================== 0010b1b8 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10b1b8: 55 push %ebp 10b1b9: 89 e5 mov %esp,%ebp 10b1bb: 53 push %ebx 10b1bc: 83 ec 0c sub $0xc,%esp 10b1bf: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b1c2: 6a 03 push $0x3 10b1c4: ff 33 pushl (%ebx) 10b1c6: e8 91 56 00 00 call 11085c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b1cb: 83 e0 03 and $0x3,%eax 10b1ce: 48 dec %eax 10b1cf: 83 c4 10 add $0x10,%esp 10b1d2: 83 f8 01 cmp $0x1,%eax 10b1d5: 76 1b jbe 10b1f2 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b1d7: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b1de: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b1e5: e8 e2 84 00 00 call 1136cc <__errno> 10b1ea: c7 00 09 00 00 00 movl $0x9,(%eax) 10b1f0: eb 69 jmp 10b25b if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b1f2: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b1f6: 75 06 jne 10b1fe rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b1f8: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b1fc: 79 1b jns 10b219 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b1fe: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b205: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b20c: e8 bb 84 00 00 call 1136cc <__errno> 10b211: c7 00 16 00 00 00 movl $0x16,(%eax) 10b217: eb 42 jmp 10b25b req = malloc (sizeof (rtems_aio_request)); 10b219: 83 ec 0c sub $0xc,%esp 10b21c: 6a 18 push $0x18 10b21e: e8 91 cf ff ff call 1081b4 if (req == NULL) 10b223: 83 c4 10 add $0x10,%esp 10b226: 85 c0 test %eax,%eax 10b228: 75 1b jne 10b245 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b22a: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b231: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b238: e8 8f 84 00 00 call 1136cc <__errno> <== NOT EXECUTED 10b23d: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b243: eb 16 jmp 10b25b <== NOT EXECUTED req->aiocbp = aiocbp; 10b245: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10b248: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10b24f: 89 45 08 mov %eax,0x8(%ebp) } 10b252: 8b 5d fc mov -0x4(%ebp),%ebx 10b255: 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); 10b256: e9 a6 fc ff ff jmp 10af01 } 10b25b: 83 c8 ff or $0xffffffff,%eax 10b25e: 8b 5d fc mov -0x4(%ebp),%ebx 10b261: c9 leave 10b262: c3 ret =============================================================================== 00109f98 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 109f98: 55 push %ebp 109f99: 89 e5 mov %esp,%ebp 109f9b: 83 ec 08 sub $0x8,%esp 109f9e: 8b 45 08 mov 0x8(%ebp),%eax 109fa1: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109fa4: 85 d2 test %edx,%edx 109fa6: 74 3c je 109fe4 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 109fa8: 83 f8 01 cmp $0x1,%eax 109fab: 75 0b jne 109fb8 _TOD_Get(tp); 109fad: 83 ec 0c sub $0xc,%esp 109fb0: 52 push %edx 109fb1: e8 b6 1b 00 00 call 10bb6c <_TOD_Get> 109fb6: eb 13 jmp 109fcb return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 109fb8: 83 f8 04 cmp $0x4,%eax 109fbb: 74 05 je 109fc2 <== NEVER TAKEN return 0; } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { 109fbd: 83 f8 02 cmp $0x2,%eax 109fc0: 75 10 jne 109fd2 _TOD_Get_uptime_as_timespec( tp ); 109fc2: 83 ec 0c sub $0xc,%esp 109fc5: 52 push %edx 109fc6: e8 f5 1b 00 00 call 10bbc0 <_TOD_Get_uptime_as_timespec> return 0; 109fcb: 83 c4 10 add $0x10,%esp 109fce: 31 c0 xor %eax,%eax 109fd0: eb 20 jmp 109ff2 } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) 109fd2: 83 f8 03 cmp $0x3,%eax 109fd5: 75 0d jne 109fe4 rtems_set_errno_and_return_minus_one( ENOSYS ); 109fd7: e8 14 80 00 00 call 111ff0 <__errno> 109fdc: c7 00 58 00 00 00 movl $0x58,(%eax) 109fe2: eb 0b jmp 109fef #endif rtems_set_errno_and_return_minus_one( EINVAL ); 109fe4: e8 07 80 00 00 call 111ff0 <__errno> 109fe9: c7 00 16 00 00 00 movl $0x16,(%eax) 109fef: 83 c8 ff or $0xffffffff,%eax return 0; } 109ff2: c9 leave 109ff3: c3 ret =============================================================================== 00109ff4 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 109ff4: 55 push %ebp 109ff5: 89 e5 mov %esp,%ebp 109ff7: 83 ec 08 sub $0x8,%esp 109ffa: 8b 45 08 mov 0x8(%ebp),%eax 109ffd: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 10a000: 85 d2 test %edx,%edx 10a002: 74 44 je 10a048 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10a004: 83 f8 01 cmp $0x1,%eax 10a007: 75 28 jne 10a031 if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 10a009: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) 10a00f: 76 37 jbe 10a048 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a011: a1 20 63 12 00 mov 0x126320,%eax 10a016: 40 inc %eax 10a017: a3 20 63 12 00 mov %eax,0x126320 rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 10a01c: 83 ec 0c sub $0xc,%esp 10a01f: 52 push %edx 10a020: e8 f3 1b 00 00 call 10bc18 <_TOD_Set> _Thread_Enable_dispatch(); 10a025: e8 78 2e 00 00 call 10cea2 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 10a02a: 83 c4 10 add $0x10,%esp 10a02d: 31 c0 xor %eax,%eax 10a02f: eb 25 jmp 10a056 _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10a031: 83 f8 02 cmp $0x2,%eax 10a034: 74 05 je 10a03b rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10a036: 83 f8 03 cmp $0x3,%eax 10a039: 75 0d jne 10a048 rtems_set_errno_and_return_minus_one( ENOSYS ); 10a03b: e8 b0 7f 00 00 call 111ff0 <__errno> 10a040: c7 00 58 00 00 00 movl $0x58,(%eax) 10a046: eb 0b jmp 10a053 #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10a048: e8 a3 7f 00 00 call 111ff0 <__errno> 10a04d: c7 00 16 00 00 00 movl $0x16,(%eax) 10a053: 83 c8 ff or $0xffffffff,%eax return 0; } 10a056: c9 leave 10a057: c3 ret =============================================================================== 001216c4 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 1216c4: 55 push %ebp 1216c5: 89 e5 mov %esp,%ebp 1216c7: 57 push %edi 1216c8: 56 push %esi 1216c9: 53 push %ebx 1216ca: 83 ec 4c sub $0x4c,%esp 1216cd: 8b 5d 0c mov 0xc(%ebp),%ebx 1216d0: 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() ) 1216d3: e8 64 fd ff ff call 12143c 1216d8: 39 45 08 cmp %eax,0x8(%ebp) 1216db: 74 0d je 1216ea rtems_set_errno_and_return_minus_one( ESRCH ); 1216dd: e8 02 43 ff ff call 1159e4 <__errno> 1216e2: c7 00 03 00 00 00 movl $0x3,(%eax) 1216e8: eb 0f jmp 1216f9 /* * Validate the signal passed. */ if ( !sig ) 1216ea: 85 db test %ebx,%ebx 1216ec: 75 13 jne 121701 rtems_set_errno_and_return_minus_one( EINVAL ); 1216ee: e8 f1 42 ff ff call 1159e4 <__errno> 1216f3: c7 00 16 00 00 00 movl $0x16,(%eax) 1216f9: 83 c8 ff or $0xffffffff,%eax 1216fc: e9 ef 01 00 00 jmp 1218f0 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 121701: 8d 4b ff lea -0x1(%ebx),%ecx if ( !is_valid_signo(sig) ) 121704: 83 f9 1f cmp $0x1f,%ecx 121707: 77 e5 ja 1216ee 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 ) 121709: 6b d3 0c imul $0xc,%ebx,%edx return 0; 12170c: 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 ) 12170e: 83 ba d8 a9 12 00 01 cmpl $0x1,0x12a9d8(%edx) 121715: 0f 84 d5 01 00 00 je 1218f0 /* * 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 ) ) 12171b: 83 fb 04 cmp $0x4,%ebx 12171e: 74 0a je 12172a 121720: 83 fb 08 cmp $0x8,%ebx 121723: 74 05 je 12172a 121725: 83 fb 0b cmp $0xb,%ebx 121728: 75 16 jne 121740 return pthread_kill( pthread_self(), sig ); 12172a: e8 89 03 00 00 call 121ab8 12172f: 56 push %esi 121730: 56 push %esi 121731: 53 push %ebx 121732: 50 push %eax 121733: e8 d8 02 00 00 call 121a10 121738: 83 c4 10 add $0x10,%esp 12173b: e9 b0 01 00 00 jmp 1218f0 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 121740: be 01 00 00 00 mov $0x1,%esi 121745: d3 e6 shl %cl,%esi /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 121747: 89 5d dc mov %ebx,-0x24(%ebp) siginfo->si_code = SI_USER; 12174a: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 121751: 85 ff test %edi,%edi 121753: 75 09 jne 12175e siginfo->si_value.sival_int = 0; 121755: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 12175c: eb 05 jmp 121763 } else { siginfo->si_value = *value; 12175e: 8b 07 mov (%edi),%eax 121760: 89 45 e4 mov %eax,-0x1c(%ebp) 121763: a1 54 a4 12 00 mov 0x12a454,%eax 121768: 40 inc %eax 121769: a3 54 a4 12 00 mov %eax,0x12a454 /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 12176e: a1 9c a9 12 00 mov 0x12a99c,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 121773: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx 121779: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 12177f: f7 d2 not %edx 121781: 85 d6 test %edx,%esi 121783: 0f 85 ed 00 00 00 jne 121876 } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 121789: 8b 15 5c ab 12 00 mov 0x12ab5c,%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 ); 12178f: eb 23 jmp 1217b4 !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 121791: 89 d0 mov %edx,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 121793: 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) 121799: 85 72 30 test %esi,0x30(%edx) 12179c: 0f 85 d4 00 00 00 jne 121876 /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 1217a2: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 1217a8: f7 d1 not %ecx 1217aa: 85 ce test %ecx,%esi 1217ac: 0f 85 c4 00 00 00 jne 121876 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 ) { 1217b2: 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 ); 1217b4: 81 fa 60 ab 12 00 cmp $0x12ab60,%edx 1217ba: 75 d5 jne 121791 * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 1217bc: 0f b6 0d f4 61 12 00 movzbl 0x1261f4,%ecx 1217c3: 41 inc %ecx * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 1217c4: 31 c0 xor %eax,%eax interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 1217c6: 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 ] ) 1217cd: 8b 7d cc mov -0x34(%ebp),%edi 1217d0: 8b 14 bd 2c a4 12 00 mov 0x12a42c(,%edi,4),%edx 1217d7: 85 d2 test %edx,%edx 1217d9: 0f 84 86 00 00 00 je 121865 <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 1217df: 8b 52 04 mov 0x4(%edx),%edx */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 1217e2: 0f b7 7a 10 movzwl 0x10(%edx),%edi 1217e6: 89 7d c4 mov %edi,-0x3c(%ebp) object_table = the_info->local_table; 1217e9: 8b 52 1c mov 0x1c(%edx),%edx 1217ec: 89 55 c0 mov %edx,-0x40(%ebp) for ( index = 1 ; index <= maximum ; index++ ) { 1217ef: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) 1217f6: 89 5d b4 mov %ebx,-0x4c(%ebp) 1217f9: eb 5f jmp 12185a the_thread = (Thread_Control *) object_table[ index ]; 1217fb: 8b 5d d0 mov -0x30(%ebp),%ebx 1217fe: 8b 7d c0 mov -0x40(%ebp),%edi 121801: 8b 14 9f mov (%edi,%ebx,4),%edx if ( !the_thread ) 121804: 85 d2 test %edx,%edx 121806: 74 4f je 121857 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 121808: 8b 5a 14 mov 0x14(%edx),%ebx 12180b: 89 5d d4 mov %ebx,-0x2c(%ebp) 12180e: 39 cb cmp %ecx,%ebx 121810: 77 45 ja 121857 #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 121812: 8b ba ec 00 00 00 mov 0xec(%edx),%edi 121818: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi 12181e: f7 d7 not %edi 121820: 85 fe test %edi,%esi 121822: 74 33 je 121857 * * 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 ) { 121824: 39 cb cmp %ecx,%ebx 121826: 72 2a jb 121852 * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 121828: 85 c0 test %eax,%eax 12182a: 74 2b je 121857 <== NEVER TAKEN 12182c: 8b 78 10 mov 0x10(%eax),%edi 12182f: 89 7d c8 mov %edi,-0x38(%ebp) 121832: 85 ff test %edi,%edi 121834: 74 21 je 121857 <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 121836: 8b 7a 10 mov 0x10(%edx),%edi 121839: 85 ff test %edi,%edi 12183b: 74 15 je 121852 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 12183d: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp) 121844: 75 11 jne 121857 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 121846: 81 e7 00 00 00 10 and $0x10000000,%edi 12184c: 74 09 je 121857 12184e: 89 d9 mov %ebx,%ecx 121850: eb 03 jmp 121855 */ if ( interested && !_States_Is_ready( interested->current_state ) ) { /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 121852: 8b 4d d4 mov -0x2c(%ebp),%ecx 121855: 89 d0 mov %edx,%eax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 121857: ff 45 d0 incl -0x30(%ebp) 12185a: 8b 55 c4 mov -0x3c(%ebp),%edx 12185d: 39 55 d0 cmp %edx,-0x30(%ebp) 121860: 76 99 jbe 1217fb 121862: 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++) { 121865: ff 45 cc incl -0x34(%ebp) 121868: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 12186c: 0f 85 5b ff ff ff jne 1217cd } } } } if ( interested ) { 121872: 85 c0 test %eax,%eax 121874: 74 13 je 121889 /* * 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 ) ) { 121876: 51 push %ecx mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 121877: 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 ) ) { 12187a: 52 push %edx 12187b: 53 push %ebx 12187c: 50 push %eax 12187d: e8 8a 00 00 00 call 12190c <_POSIX_signals_Unblock_thread> 121882: 83 c4 10 add $0x10,%esp 121885: 84 c0 test %al,%al 121887: 75 60 jne 1218e9 /* * 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 ); 121889: 83 ec 0c sub $0xc,%esp 12188c: 56 push %esi 12188d: e8 66 00 00 00 call 1218f8 <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 121892: 6b db 0c imul $0xc,%ebx,%ebx 121895: 83 c4 10 add $0x10,%esp 121898: 83 bb d0 a9 12 00 02 cmpl $0x2,0x12a9d0(%ebx) 12189f: 75 48 jne 1218e9 psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); 1218a1: 83 ec 0c sub $0xc,%esp 1218a4: 68 50 ab 12 00 push $0x12ab50 1218a9: e8 8e d8 fe ff call 10f13c <_Chain_Get> if ( !psiginfo ) { 1218ae: 83 c4 10 add $0x10,%esp 1218b1: 85 c0 test %eax,%eax 1218b3: 75 15 jne 1218ca _Thread_Enable_dispatch(); 1218b5: e8 dc ef fe ff call 110896 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 1218ba: e8 25 41 ff ff call 1159e4 <__errno> 1218bf: c7 00 0b 00 00 00 movl $0xb,(%eax) 1218c5: e9 2f fe ff ff jmp 1216f9 } psiginfo->Info = *siginfo; 1218ca: 8d 78 08 lea 0x8(%eax),%edi 1218cd: 8d 75 dc lea -0x24(%ebp),%esi 1218d0: b9 03 00 00 00 mov $0x3,%ecx 1218d5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 1218d7: 52 push %edx 1218d8: 52 push %edx 1218d9: 50 push %eax 1218da: 81 c3 c8 ab 12 00 add $0x12abc8,%ebx 1218e0: 53 push %ebx 1218e1: e8 1a d8 fe ff call 10f100 <_Chain_Append> 1218e6: 83 c4 10 add $0x10,%esp } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 1218e9: e8 a8 ef fe ff call 110896 <_Thread_Enable_dispatch> return 0; 1218ee: 31 c0 xor %eax,%eax } 1218f0: 8d 65 f4 lea -0xc(%ebp),%esp 1218f3: 5b pop %ebx 1218f4: 5e pop %esi 1218f5: 5f pop %edi 1218f6: c9 leave 1218f7: c3 ret =============================================================================== 0010efdc : int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { 10efdc: 55 push %ebp 10efdd: 89 e5 mov %esp,%ebp 10efdf: 8b 55 08 mov 0x8(%ebp),%edx 10efe2: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; 10efe5: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { if ( !attr || !attr->is_initialized || !inheritsched ) 10efea: 85 d2 test %edx,%edx 10efec: 74 17 je 10f005 <== NEVER TAKEN 10efee: 85 c9 test %ecx,%ecx 10eff0: 74 0e je 10f000 <== NEVER TAKEN 10eff2: 83 3a 00 cmpl $0x0,(%edx) 10eff5: 74 09 je 10f000 <== NEVER TAKEN return EINVAL; *inheritsched = attr->inheritsched; 10eff7: 8b 42 10 mov 0x10(%edx),%eax 10effa: 89 01 mov %eax,(%ecx) return 0; 10effc: 31 c0 xor %eax,%eax 10effe: eb 05 jmp 10f005 const pthread_attr_t *attr, int *inheritsched ) { if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; 10f000: b8 16 00 00 00 mov $0x16,%eax *inheritsched = attr->inheritsched; return 0; } 10f005: c9 leave 10f006: c3 ret =============================================================================== 0010f1f8 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10f1f8: 55 push %ebp 10f1f9: 89 e5 mov %esp,%ebp 10f1fb: 8b 55 08 mov 0x8(%ebp),%edx 10f1fe: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10f201: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { if ( !attr || !attr->is_initialized ) 10f206: 85 d2 test %edx,%edx 10f208: 74 1e je 10f228 10f20a: 83 3a 00 cmpl $0x0,(%edx) 10f20d: 74 19 je 10f228 return EINVAL; switch ( policy ) { 10f20f: 83 f9 04 cmp $0x4,%ecx 10f212: 77 0f ja 10f223 10f214: b0 01 mov $0x1,%al 10f216: d3 e0 shl %cl,%eax 10f218: a8 17 test $0x17,%al 10f21a: 74 07 je 10f223 <== NEVER TAKEN case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10f21c: 89 4a 14 mov %ecx,0x14(%edx) return 0; 10f21f: 31 c0 xor %eax,%eax 10f221: eb 05 jmp 10f228 default: return ENOTSUP; 10f223: b8 86 00 00 00 mov $0x86,%eax } } 10f228: c9 leave 10f229: c3 ret =============================================================================== 0010a518 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10a518: 55 push %ebp 10a519: 89 e5 mov %esp,%ebp 10a51b: 57 push %edi 10a51c: 56 push %esi 10a51d: 53 push %ebx 10a51e: 83 ec 1c sub $0x1c,%esp 10a521: 8b 5d 08 mov 0x8(%ebp),%ebx 10a524: 8b 75 10 mov 0x10(%ebp),%esi /* * Error check parameters */ if ( !barrier ) return EINVAL; 10a527: b8 16 00 00 00 mov $0x16,%eax const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10a52c: 85 db test %ebx,%ebx 10a52e: 0f 84 96 00 00 00 je 10a5ca return EINVAL; if ( count == 0 ) 10a534: 85 f6 test %esi,%esi 10a536: 0f 84 8e 00 00 00 je 10a5ca return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10a53c: 8b 7d 0c mov 0xc(%ebp),%edi 10a53f: 85 ff test %edi,%edi 10a541: 75 0f jne 10a552 the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10a543: 83 ec 0c sub $0xc,%esp 10a546: 8d 7d d8 lea -0x28(%ebp),%edi 10a549: 57 push %edi 10a54a: e8 19 ff ff ff call 10a468 10a54f: 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; 10a552: 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 ) 10a557: 83 3f 00 cmpl $0x0,(%edi) 10a55a: 74 6e je 10a5ca return EINVAL; switch ( the_attr->process_shared ) { 10a55c: 83 7f 04 00 cmpl $0x0,0x4(%edi) 10a560: 75 68 jne 10a5ca <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a562: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_attributes.maximum_count = count; 10a569: 89 75 e4 mov %esi,-0x1c(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a56c: a1 d0 64 12 00 mov 0x1264d0,%eax 10a571: 40 inc %eax 10a572: a3 d0 64 12 00 mov %eax,0x1264d0 * 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 ); 10a577: 83 ec 0c sub $0xc,%esp 10a57a: 68 94 68 12 00 push $0x126894 10a57f: e8 0c 1e 00 00 call 10c390 <_Objects_Allocate> 10a584: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10a586: 83 c4 10 add $0x10,%esp 10a589: 85 c0 test %eax,%eax 10a58b: 75 0c jne 10a599 _Thread_Enable_dispatch(); 10a58d: e8 0c 2c 00 00 call 10d19e <_Thread_Enable_dispatch> return EAGAIN; 10a592: b8 0b 00 00 00 mov $0xb,%eax 10a597: eb 31 jmp 10a5ca } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a599: 50 push %eax 10a59a: 50 push %eax 10a59b: 8d 45 e0 lea -0x20(%ebp),%eax 10a59e: 50 push %eax 10a59f: 8d 46 10 lea 0x10(%esi),%eax 10a5a2: 50 push %eax 10a5a3: e8 a8 14 00 00 call 10ba50 <_CORE_barrier_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a5a8: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a5ab: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a5ae: 8b 15 b0 68 12 00 mov 0x1268b0,%edx 10a5b4: 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; 10a5b7: 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; 10a5be: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10a5c0: e8 d9 2b 00 00 call 10d19e <_Thread_Enable_dispatch> return 0; 10a5c5: 83 c4 10 add $0x10,%esp 10a5c8: 31 c0 xor %eax,%eax } 10a5ca: 8d 65 f4 lea -0xc(%ebp),%esp 10a5cd: 5b pop %ebx 10a5ce: 5e pop %esi 10a5cf: 5f pop %edi 10a5d0: c9 leave 10a5d1: c3 ret =============================================================================== 00109ed0 : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 109ed0: 55 push %ebp 109ed1: 89 e5 mov %esp,%ebp 109ed3: 56 push %esi 109ed4: 53 push %ebx 109ed5: 8b 5d 08 mov 0x8(%ebp),%ebx 109ed8: 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 ) 109edb: 85 db test %ebx,%ebx 109edd: 74 4b je 109f2a rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 109edf: a1 c8 62 12 00 mov 0x1262c8,%eax 109ee4: 40 inc %eax 109ee5: a3 c8 62 12 00 mov %eax,0x1262c8 return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 109eea: 83 ec 0c sub $0xc,%esp 109eed: 6a 10 push $0x10 109eef: e8 02 3c 00 00 call 10daf6 <_Workspace_Allocate> if ( handler ) { 109ef4: 83 c4 10 add $0x10,%esp 109ef7: 85 c0 test %eax,%eax 109ef9: 74 24 je 109f1f <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109efb: 8b 15 10 68 12 00 mov 0x126810,%edx handler_stack = &thread_support->Cancellation_Handlers; 109f01: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx 109f07: 81 c2 e4 00 00 00 add $0xe4,%edx handler->routine = routine; 109f0d: 89 58 08 mov %ebx,0x8(%eax) handler->arg = arg; 109f10: 89 70 0c mov %esi,0xc(%eax) _Chain_Append( handler_stack, &handler->Node ); 109f13: 51 push %ecx 109f14: 51 push %ecx 109f15: 50 push %eax 109f16: 52 push %edx 109f17: e8 88 15 00 00 call 10b4a4 <_Chain_Append> 109f1c: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 109f1f: 8d 65 f8 lea -0x8(%ebp),%esp 109f22: 5b pop %ebx 109f23: 5e pop %esi 109f24: c9 leave handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 109f25: e9 70 2c 00 00 jmp 10cb9a <_Thread_Enable_dispatch> } 109f2a: 8d 65 f8 lea -0x8(%ebp),%esp 109f2d: 5b pop %ebx 109f2e: 5e pop %esi 109f2f: c9 leave 109f30: c3 ret =============================================================================== 0010ac40 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10ac40: 55 push %ebp 10ac41: 89 e5 mov %esp,%ebp 10ac43: 56 push %esi 10ac44: 53 push %ebx POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10ac45: 8b 5d 0c mov 0xc(%ebp),%ebx 10ac48: 85 db test %ebx,%ebx 10ac4a: 75 05 jne 10ac51 else the_attr = &_POSIX_Condition_variables_Default_attributes; 10ac4c: bb f0 0c 12 00 mov $0x120cf0,%ebx /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return EINVAL; 10ac51: 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 ) 10ac56: 83 7b 04 01 cmpl $0x1,0x4(%ebx) 10ac5a: 74 76 je 10acd2 <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 10ac5c: 83 3b 00 cmpl $0x0,(%ebx) 10ac5f: 74 71 je 10acd2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10ac61: a1 80 73 12 00 mov 0x127380,%eax 10ac66: 40 inc %eax 10ac67: a3 80 73 12 00 mov %eax,0x127380 RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) _Objects_Allocate( &_POSIX_Condition_variables_Information ); 10ac6c: 83 ec 0c sub $0xc,%esp 10ac6f: 68 dc 77 12 00 push $0x1277dc 10ac74: e8 f7 22 00 00 call 10cf70 <_Objects_Allocate> 10ac79: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10ac7b: 83 c4 10 add $0x10,%esp 10ac7e: 85 c0 test %eax,%eax 10ac80: 75 0c jne 10ac8e _Thread_Enable_dispatch(); 10ac82: e8 f7 30 00 00 call 10dd7e <_Thread_Enable_dispatch> return ENOMEM; 10ac87: b8 0c 00 00 00 mov $0xc,%eax 10ac8c: eb 44 jmp 10acd2 } the_cond->process_shared = the_attr->process_shared; 10ac8e: 8b 43 04 mov 0x4(%ebx),%eax 10ac91: 89 46 10 mov %eax,0x10(%esi) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10ac94: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) _Thread_queue_Initialize( 10ac9b: 6a 74 push $0x74 10ac9d: 68 00 08 00 10 push $0x10000800 10aca2: 6a 00 push $0x0 10aca4: 8d 46 18 lea 0x18(%esi),%eax 10aca7: 50 push %eax 10aca8: e8 c7 37 00 00 call 10e474 <_Thread_queue_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10acad: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10acb0: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10acb3: 8b 15 f8 77 12 00 mov 0x1277f8,%edx 10acb9: 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; 10acbc: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10acc3: 8b 55 08 mov 0x8(%ebp),%edx 10acc6: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 10acc8: e8 b1 30 00 00 call 10dd7e <_Thread_Enable_dispatch> return 0; 10accd: 83 c4 10 add $0x10,%esp 10acd0: 31 c0 xor %eax,%eax } 10acd2: 8d 65 f8 lea -0x8(%ebp),%esp 10acd5: 5b pop %ebx 10acd6: 5e pop %esi 10acd7: c9 leave 10acd8: c3 ret =============================================================================== 0010aaf4 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10aaf4: 55 push %ebp 10aaf5: 89 e5 mov %esp,%ebp 10aaf7: 8b 55 08 mov 0x8(%ebp),%edx if ( !attr || attr->is_initialized == false ) return EINVAL; 10aafa: b8 16 00 00 00 mov $0x16,%eax int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == false ) 10aaff: 85 d2 test %edx,%edx 10ab01: 74 0d je 10ab10 10ab03: 83 3a 00 cmpl $0x0,(%edx) 10ab06: 74 08 je 10ab10 <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 10ab08: c7 02 00 00 00 00 movl $0x0,(%edx) return 0; 10ab0e: 30 c0 xor %al,%al } 10ab10: c9 leave 10ab11: c3 ret =============================================================================== 0010a228 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10a228: 55 push %ebp 10a229: 89 e5 mov %esp,%ebp 10a22b: 57 push %edi 10a22c: 56 push %esi 10a22d: 53 push %ebx 10a22e: 83 ec 5c sub $0x5c,%esp struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) return EFAULT; 10a231: 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 ) 10a238: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a23c: 0f 84 0f 02 00 00 je 10a451 return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10a242: 8b 5d 0c mov 0xc(%ebp),%ebx 10a245: 85 db test %ebx,%ebx 10a247: 75 05 jne 10a24e 10a249: bb 5c f9 11 00 mov $0x11f95c,%ebx if ( !the_attr->is_initialized ) return EINVAL; 10a24e: 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 ) 10a255: 83 3b 00 cmpl $0x0,(%ebx) 10a258: 0f 84 f3 01 00 00 je 10a451 * 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) ) 10a25e: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a262: 74 0e je 10a272 10a264: a1 14 12 12 00 mov 0x121214,%eax 10a269: 39 43 08 cmp %eax,0x8(%ebx) 10a26c: 0f 82 df 01 00 00 jb 10a451 * 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 ) { 10a272: 8b 43 10 mov 0x10(%ebx),%eax 10a275: 83 f8 01 cmp $0x1,%eax 10a278: 74 0b je 10a285 10a27a: 83 f8 02 cmp $0x2,%eax 10a27d: 0f 85 c7 01 00 00 jne 10a44a 10a283: eb 1f jmp 10a2a4 case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a285: a1 18 58 12 00 mov 0x125818,%eax 10a28a: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi schedpolicy = api->schedpolicy; 10a290: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10a296: 89 45 ac mov %eax,-0x54(%ebp) schedparam = api->schedparam; 10a299: 8d 7d c4 lea -0x3c(%ebp),%edi 10a29c: 81 c6 88 00 00 00 add $0x88,%esi 10a2a2: eb 0c jmp 10a2b0 break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10a2a4: 8b 43 14 mov 0x14(%ebx),%eax 10a2a7: 89 45 ac mov %eax,-0x54(%ebp) schedparam = the_attr->schedparam; 10a2aa: 8d 7d c4 lea -0x3c(%ebp),%edi 10a2ad: 8d 73 18 lea 0x18(%ebx),%esi 10a2b0: b9 07 00 00 00 mov $0x7,%ecx 10a2b5: 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; 10a2b7: 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 ) 10a2be: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10a2c2: 0f 85 89 01 00 00 jne 10a451 return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10a2c8: 83 ec 0c sub $0xc,%esp 10a2cb: ff 75 c4 pushl -0x3c(%ebp) 10a2ce: e8 f1 58 00 00 call 10fbc4 <_POSIX_Priority_Is_valid> 10a2d3: 83 c4 10 add $0x10,%esp return EINVAL; 10a2d6: 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 ) ) 10a2dd: 84 c0 test %al,%al 10a2df: 0f 84 6c 01 00 00 je 10a451 <== NEVER TAKEN return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 10a2e5: 8b 45 c4 mov -0x3c(%ebp),%eax 10a2e8: 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); 10a2eb: 0f b6 3d 18 12 12 00 movzbl 0x121218,%edi /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 10a2f2: 8d 45 e0 lea -0x20(%ebp),%eax 10a2f5: 50 push %eax 10a2f6: 8d 45 e4 lea -0x1c(%ebp),%eax 10a2f9: 50 push %eax 10a2fa: 8d 45 c4 lea -0x3c(%ebp),%eax 10a2fd: 50 push %eax 10a2fe: ff 75 ac pushl -0x54(%ebp) 10a301: e8 de 58 00 00 call 10fbe4 <_POSIX_Thread_Translate_sched_param> 10a306: 89 45 b4 mov %eax,-0x4c(%ebp) schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 10a309: 83 c4 10 add $0x10,%esp 10a30c: 85 c0 test %eax,%eax 10a30e: 0f 85 3d 01 00 00 jne 10a451 #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10a314: 83 ec 0c sub $0xc,%esp 10a317: ff 35 94 53 12 00 pushl 0x125394 10a31d: e8 56 15 00 00 call 10b878 <_API_Mutex_Lock> * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 10a322: c7 04 24 14 55 12 00 movl $0x125514,(%esp) 10a329: e8 aa 1e 00 00 call 10c1d8 <_Objects_Allocate> 10a32e: 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 ) { 10a331: 83 c4 10 add $0x10,%esp 10a334: 85 c0 test %eax,%eax 10a336: 75 05 jne 10a33d _RTEMS_Unlock_allocator(); 10a338: 83 ec 0c sub $0xc,%esp 10a33b: eb 53 jmp 10a390 /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10a33d: 8b 4d e0 mov -0x20(%ebp),%ecx 10a340: 8b 75 e4 mov -0x1c(%ebp),%esi 10a343: 8b 53 08 mov 0x8(%ebx),%edx 10a346: a1 14 12 12 00 mov 0x121214,%eax 10a34b: d1 e0 shl %eax 10a34d: 39 d0 cmp %edx,%eax 10a34f: 73 02 jae 10a353 10a351: 89 d0 mov %edx,%eax 10a353: 52 push %edx 10a354: 6a 00 push $0x0 10a356: 6a 00 push $0x0 10a358: 51 push %ecx 10a359: 56 push %esi 10a35a: 6a 01 push $0x1 10a35c: 81 e7 ff 00 00 00 and $0xff,%edi 10a362: 2b 7d a8 sub -0x58(%ebp),%edi 10a365: 57 push %edi 10a366: 6a 01 push $0x1 10a368: 50 push %eax 10a369: ff 73 04 pushl 0x4(%ebx) 10a36c: ff 75 b0 pushl -0x50(%ebp) 10a36f: 68 14 55 12 00 push $0x125514 10a374: e8 ff 2c 00 00 call 10d078 <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10a379: 83 c4 30 add $0x30,%esp 10a37c: 84 c0 test %al,%al 10a37e: 75 2a jne 10a3aa RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 10a380: 56 push %esi 10a381: 56 push %esi 10a382: ff 75 b0 pushl -0x50(%ebp) 10a385: 68 14 55 12 00 push $0x125514 10a38a: e8 41 21 00 00 call 10c4d0 <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a38f: 5b pop %ebx 10a390: ff 35 94 53 12 00 pushl 0x125394 10a396: e8 25 15 00 00 call 10b8c0 <_API_Mutex_Unlock> return EAGAIN; 10a39b: 83 c4 10 add $0x10,%esp 10a39e: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp) 10a3a5: e9 a7 00 00 00 jmp 10a451 } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10a3aa: 8b 45 b0 mov -0x50(%ebp),%eax 10a3ad: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx api->Attributes = *the_attr; 10a3b3: b9 10 00 00 00 mov $0x10,%ecx 10a3b8: 89 d7 mov %edx,%edi 10a3ba: 89 de mov %ebx,%esi 10a3bc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 10a3be: 8b 43 3c mov 0x3c(%ebx),%eax 10a3c1: 89 42 40 mov %eax,0x40(%edx) api->schedpolicy = schedpolicy; 10a3c4: 8b 45 ac mov -0x54(%ebp),%eax 10a3c7: 89 82 84 00 00 00 mov %eax,0x84(%edx) api->schedparam = schedparam; 10a3cd: 8d ba 88 00 00 00 lea 0x88(%edx),%edi 10a3d3: 8d 75 c4 lea -0x3c(%ebp),%esi 10a3d6: b1 07 mov $0x7,%cl 10a3d8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10a3da: 83 ec 0c sub $0xc,%esp 10a3dd: 6a 00 push $0x0 10a3df: ff 75 14 pushl 0x14(%ebp) 10a3e2: ff 75 10 pushl 0x10(%ebp) 10a3e5: 6a 01 push $0x1 10a3e7: ff 75 b0 pushl -0x50(%ebp) 10a3ea: 89 55 a4 mov %edx,-0x5c(%ebp) 10a3ed: e8 32 35 00 00 call 10d924 <_Thread_Start> _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 10a3f2: 83 c4 20 add $0x20,%esp 10a3f5: 83 7d ac 04 cmpl $0x4,-0x54(%ebp) 10a3f9: 8b 55 a4 mov -0x5c(%ebp),%edx 10a3fc: 75 2e jne 10a42c _Watchdog_Insert_ticks( 10a3fe: 83 ec 0c sub $0xc,%esp &api->Sporadic_timer, _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ) 10a401: 8d 82 90 00 00 00 lea 0x90(%edx),%eax return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10a407: 50 push %eax 10a408: e8 6f 36 00 00 call 10da7c <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a40d: 8b 55 a4 mov -0x5c(%ebp),%edx 10a410: 89 82 b4 00 00 00 mov %eax,0xb4(%edx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a416: 58 pop %eax 10a417: 59 pop %ecx 10a418: 81 c2 a8 00 00 00 add $0xa8,%edx 10a41e: 52 push %edx 10a41f: 68 b4 53 12 00 push $0x1253b4 10a424: e8 07 39 00 00 call 10dd30 <_Watchdog_Insert> 10a429: 83 c4 10 add $0x10,%esp } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10a42c: 8b 45 b0 mov -0x50(%ebp),%eax 10a42f: 8b 50 08 mov 0x8(%eax),%edx 10a432: 8b 45 08 mov 0x8(%ebp),%eax 10a435: 89 10 mov %edx,(%eax) _RTEMS_Unlock_allocator(); 10a437: 83 ec 0c sub $0xc,%esp 10a43a: ff 35 94 53 12 00 pushl 0x125394 10a440: e8 7b 14 00 00 call 10b8c0 <_API_Mutex_Unlock> return 0; 10a445: 83 c4 10 add $0x10,%esp 10a448: eb 07 jmp 10a451 schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; break; default: return EINVAL; 10a44a: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10a451: 8b 45 b4 mov -0x4c(%ebp),%eax 10a454: 8d 65 f4 lea -0xc(%ebp),%esp 10a457: 5b pop %ebx 10a458: 5e pop %esi 10a459: 5f pop %edi 10a45a: c9 leave 10a45b: c3 ret =============================================================================== 00110d60 : } void pthread_exit( void *value_ptr ) { 110d60: 55 push %ebp 110d61: 89 e5 mov %esp,%ebp 110d63: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 110d66: ff 75 08 pushl 0x8(%ebp) 110d69: ff 35 28 48 12 00 pushl 0x124828 110d6f: e8 88 ff ff ff call 110cfc <_POSIX_Thread_Exit> 110d74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110d77: c9 leave <== NOT EXECUTED 110d78: c3 ret <== NOT EXECUTED =============================================================================== 0010bf24 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10bf24: 55 push %ebp 10bf25: 89 e5 mov %esp,%ebp 10bf27: 53 push %ebx 10bf28: 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 ); 10bf2b: 8d 45 f4 lea -0xc(%ebp),%eax 10bf2e: 50 push %eax 10bf2f: ff 75 0c pushl 0xc(%ebp) 10bf32: e8 b9 00 00 00 call 10bff0 <_POSIX_Absolute_timeout_to_ticks> 10bf37: 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, 10bf39: 83 c4 0c add $0xc,%esp 10bf3c: 83 f8 03 cmp $0x3,%eax 10bf3f: 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 ); 10bf42: ff 75 f4 pushl -0xc(%ebp) 10bf45: 0f b6 c2 movzbl %dl,%eax 10bf48: 50 push %eax 10bf49: ff 75 08 pushl 0x8(%ebp) 10bf4c: 88 55 e4 mov %dl,-0x1c(%ebp) 10bf4f: e8 e8 fe ff ff call 10be3c <_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) ) { 10bf54: 83 c4 10 add $0x10,%esp 10bf57: 8a 55 e4 mov -0x1c(%ebp),%dl 10bf5a: 84 d2 test %dl,%dl 10bf5c: 75 1d jne 10bf7b 10bf5e: 83 f8 10 cmp $0x10,%eax 10bf61: 75 18 jne 10bf7b <== NEVER TAKEN if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10bf63: 85 db test %ebx,%ebx 10bf65: 74 08 je 10bf6f <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10bf67: 4b dec %ebx 10bf68: 83 fb 01 cmp $0x1,%ebx 10bf6b: 77 0e ja 10bf7b <== NEVER TAKEN 10bf6d: eb 07 jmp 10bf76 * 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; 10bf6f: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10bf74: eb 05 jmp 10bf7b <== NOT EXECUTED if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10bf76: b8 74 00 00 00 mov $0x74,%eax } return lock_status; } 10bf7b: 8b 5d fc mov -0x4(%ebp),%ebx 10bf7e: c9 leave 10bf7f: c3 ret =============================================================================== 0010bb9c : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10bb9c: 55 push %ebp 10bb9d: 89 e5 mov %esp,%ebp 10bb9f: 8b 55 08 mov 0x8(%ebp),%edx 10bba2: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10bba5: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { if ( !attr || !attr->is_initialized ) 10bbaa: 85 d2 test %edx,%edx 10bbac: 74 0f je 10bbbd 10bbae: 83 3a 00 cmpl $0x0,(%edx) 10bbb1: 74 0a je 10bbbd return EINVAL; switch ( pshared ) { 10bbb3: 83 f9 01 cmp $0x1,%ecx 10bbb6: 77 05 ja 10bbbd <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bbb8: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10bbbb: 30 c0 xor %al,%al default: return EINVAL; } } 10bbbd: c9 leave 10bbbe: c3 ret =============================================================================== 00109dc4 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 109dc4: 55 push %ebp 109dc5: 89 e5 mov %esp,%ebp 109dc7: 8b 55 08 mov 0x8(%ebp),%edx 109dca: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 109dcd: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { if ( !attr || !attr->is_initialized ) 109dd2: 85 d2 test %edx,%edx 109dd4: 74 0f je 109de5 109dd6: 83 3a 00 cmpl $0x0,(%edx) 109dd9: 74 0a je 109de5 <== NEVER TAKEN return EINVAL; switch ( type ) { 109ddb: 83 f9 03 cmp $0x3,%ecx 109dde: 77 05 ja 109de5 case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 109de0: 89 4a 10 mov %ecx,0x10(%edx) return 0; 109de3: 30 c0 xor %al,%al default: return EINVAL; } } 109de5: c9 leave 109de6: c3 ret =============================================================================== 0010a874 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10a874: 55 push %ebp 10a875: 89 e5 mov %esp,%ebp 10a877: 56 push %esi 10a878: 53 push %ebx 10a879: 83 ec 10 sub $0x10,%esp 10a87c: 8b 5d 08 mov 0x8(%ebp),%ebx 10a87f: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10a882: 85 f6 test %esi,%esi 10a884: 74 51 je 10a8d7 10a886: 85 db test %ebx,%ebx 10a888: 74 4d je 10a8d7 once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; 10a88a: 31 c0 xor %eax,%eax ) { if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { 10a88c: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a890: 75 4a jne 10a8dc rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10a892: 52 push %edx 10a893: 8d 45 f4 lea -0xc(%ebp),%eax 10a896: 50 push %eax 10a897: 68 00 01 00 00 push $0x100 10a89c: 68 00 01 00 00 push $0x100 10a8a1: e8 a6 0a 00 00 call 10b34c if ( !once_control->init_executed ) { 10a8a6: 83 c4 10 add $0x10,%esp 10a8a9: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a8ad: 75 0f jne 10a8be <== NEVER TAKEN once_control->is_initialized = true; 10a8af: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = true; 10a8b5: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10a8bc: ff d6 call *%esi } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10a8be: 50 push %eax 10a8bf: 8d 45 f4 lea -0xc(%ebp),%eax 10a8c2: 50 push %eax 10a8c3: 68 00 01 00 00 push $0x100 10a8c8: ff 75 f4 pushl -0xc(%ebp) 10a8cb: e8 7c 0a 00 00 call 10b34c 10a8d0: 83 c4 10 add $0x10,%esp } return 0; 10a8d3: 31 c0 xor %eax,%eax 10a8d5: eb 05 jmp 10a8dc pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) return EINVAL; 10a8d7: b8 16 00 00 00 mov $0x16,%eax (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10a8dc: 8d 65 f8 lea -0x8(%ebp),%esp 10a8df: 5b pop %ebx 10a8e0: 5e pop %esi 10a8e1: c9 leave 10a8e2: c3 ret =============================================================================== 0010b0a0 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10b0a0: 55 push %ebp 10b0a1: 89 e5 mov %esp,%ebp 10b0a3: 56 push %esi 10b0a4: 53 push %ebx 10b0a5: 83 ec 10 sub $0x10,%esp 10b0a8: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Error check parameters */ if ( !rwlock ) return EINVAL; 10b0ab: b8 16 00 00 00 mov $0x16,%eax const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10b0b0: 85 db test %ebx,%ebx 10b0b2: 0f 84 8b 00 00 00 je 10b143 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10b0b8: 8b 75 0c mov 0xc(%ebp),%esi 10b0bb: 85 f6 test %esi,%esi 10b0bd: 75 0f jne 10b0ce the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10b0bf: 83 ec 0c sub $0xc,%esp 10b0c2: 8d 75 ec lea -0x14(%ebp),%esi 10b0c5: 56 push %esi 10b0c6: e8 5d 09 00 00 call 10ba28 10b0cb: 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; 10b0ce: 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 ) 10b0d3: 83 3e 00 cmpl $0x0,(%esi) 10b0d6: 74 6b je 10b143 <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 10b0d8: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b0dc: 75 65 jne 10b143 <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 10b0de: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b0e5: a1 f0 82 12 00 mov 0x1282f0,%eax 10b0ea: 40 inc %eax 10b0eb: a3 f0 82 12 00 mov %eax,0x1282f0 * the inactive chain of free RWLock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void ) { return (POSIX_RWLock_Control *) _Objects_Allocate( &_POSIX_RWLock_Information ); 10b0f0: 83 ec 0c sub $0xc,%esp 10b0f3: 68 f4 84 12 00 push $0x1284f4 10b0f8: e8 33 23 00 00 call 10d430 <_Objects_Allocate> 10b0fd: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10b0ff: 83 c4 10 add $0x10,%esp 10b102: 85 c0 test %eax,%eax 10b104: 75 0c jne 10b112 _Thread_Enable_dispatch(); 10b106: e8 33 31 00 00 call 10e23e <_Thread_Enable_dispatch> return EAGAIN; 10b10b: b8 0b 00 00 00 mov $0xb,%eax 10b110: eb 31 jmp 10b143 } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10b112: 50 push %eax 10b113: 50 push %eax 10b114: 8d 45 f4 lea -0xc(%ebp),%eax 10b117: 50 push %eax 10b118: 8d 46 10 lea 0x10(%esi),%eax 10b11b: 50 push %eax 10b11c: e8 7b 1b 00 00 call 10cc9c <_CORE_RWLock_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b121: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b124: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b127: 8b 15 10 85 12 00 mov 0x128510,%edx 10b12d: 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; 10b130: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10b137: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10b139: e8 00 31 00 00 call 10e23e <_Thread_Enable_dispatch> return 0; 10b13e: 83 c4 10 add $0x10,%esp 10b141: 31 c0 xor %eax,%eax } 10b143: 8d 65 f8 lea -0x8(%ebp),%esp 10b146: 5b pop %ebx 10b147: 5e pop %esi 10b148: c9 leave 10b149: c3 ret =============================================================================== 0010b1b4 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b1b4: 55 push %ebp 10b1b5: 89 e5 mov %esp,%ebp 10b1b7: 57 push %edi 10b1b8: 56 push %esi 10b1b9: 53 push %ebx 10b1ba: 83 ec 2c sub $0x2c,%esp 10b1bd: 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; 10b1c0: 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 ) 10b1c5: 85 ff test %edi,%edi 10b1c7: 0f 84 87 00 00 00 je 10b254 * * 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 ); 10b1cd: 50 push %eax 10b1ce: 50 push %eax 10b1cf: 8d 45 e0 lea -0x20(%ebp),%eax 10b1d2: 50 push %eax 10b1d3: ff 75 0c pushl 0xc(%ebp) 10b1d6: e8 29 59 00 00 call 110b04 <_POSIX_Absolute_timeout_to_ticks> 10b1db: 89 c6 mov %eax,%esi 10b1dd: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b1e0: 8d 45 e4 lea -0x1c(%ebp),%eax 10b1e3: 50 push %eax 10b1e4: ff 37 pushl (%edi) 10b1e6: 68 f4 84 12 00 push $0x1284f4 10b1eb: e8 70 26 00 00 call 10d860 <_Objects_Get> switch ( location ) { 10b1f0: 83 c4 10 add $0x10,%esp 10b1f3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b1f7: 75 5b jne 10b254 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, 10b1f9: 83 fe 03 cmp $0x3,%esi 10b1fc: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10b1ff: 83 ec 0c sub $0xc,%esp 10b202: 6a 00 push $0x0 10b204: ff 75 e0 pushl -0x20(%ebp) 10b207: 0f b6 ca movzbl %dl,%ecx 10b20a: 51 push %ecx 10b20b: ff 37 pushl (%edi) 10b20d: 83 c0 10 add $0x10,%eax 10b210: 50 push %eax 10b211: 88 55 d4 mov %dl,-0x2c(%ebp) 10b214: e8 b7 1a 00 00 call 10ccd0 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b219: 83 c4 20 add $0x20,%esp 10b21c: e8 1d 30 00 00 call 10e23e <_Thread_Enable_dispatch> if ( !do_wait ) { 10b221: 8a 55 d4 mov -0x2c(%ebp),%dl 10b224: 84 d2 test %dl,%dl 10b226: 75 17 jne 10b23f if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 10b228: a1 38 88 12 00 mov 0x128838,%eax 10b22d: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b231: 75 0c jne 10b23f if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b233: 85 f6 test %esi,%esi 10b235: 74 1d je 10b254 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b237: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b238: 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 || 10b23a: 83 fe 01 cmp $0x1,%esi 10b23d: 76 15 jbe 10b254 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b23f: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b242: a1 38 88 12 00 mov 0x128838,%eax status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b247: ff 70 34 pushl 0x34(%eax) 10b24a: e8 bd 00 00 00 call 10b30c <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b24f: 89 c3 mov %eax,%ebx 10b251: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b254: 89 d8 mov %ebx,%eax 10b256: 8d 65 f4 lea -0xc(%ebp),%esp 10b259: 5b pop %ebx 10b25a: 5e pop %esi 10b25b: 5f pop %edi 10b25c: c9 leave 10b25d: c3 ret =============================================================================== 0010b260 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b260: 55 push %ebp 10b261: 89 e5 mov %esp,%ebp 10b263: 57 push %edi 10b264: 56 push %esi 10b265: 53 push %ebx 10b266: 83 ec 2c sub $0x2c,%esp 10b269: 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; 10b26c: 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 ) 10b271: 85 ff test %edi,%edi 10b273: 0f 84 87 00 00 00 je 10b300 * * 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 ); 10b279: 50 push %eax 10b27a: 50 push %eax 10b27b: 8d 45 e0 lea -0x20(%ebp),%eax 10b27e: 50 push %eax 10b27f: ff 75 0c pushl 0xc(%ebp) 10b282: e8 7d 58 00 00 call 110b04 <_POSIX_Absolute_timeout_to_ticks> 10b287: 89 c6 mov %eax,%esi 10b289: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b28c: 8d 45 e4 lea -0x1c(%ebp),%eax 10b28f: 50 push %eax 10b290: ff 37 pushl (%edi) 10b292: 68 f4 84 12 00 push $0x1284f4 10b297: e8 c4 25 00 00 call 10d860 <_Objects_Get> switch ( location ) { 10b29c: 83 c4 10 add $0x10,%esp 10b29f: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b2a3: 75 5b jne 10b300 (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, 10b2a5: 83 fe 03 cmp $0x3,%esi 10b2a8: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10b2ab: 83 ec 0c sub $0xc,%esp 10b2ae: 6a 00 push $0x0 10b2b0: ff 75 e0 pushl -0x20(%ebp) 10b2b3: 0f b6 ca movzbl %dl,%ecx 10b2b6: 51 push %ecx 10b2b7: ff 37 pushl (%edi) 10b2b9: 83 c0 10 add $0x10,%eax 10b2bc: 50 push %eax 10b2bd: 88 55 d4 mov %dl,-0x2c(%ebp) 10b2c0: e8 c3 1a 00 00 call 10cd88 <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b2c5: 83 c4 20 add $0x20,%esp 10b2c8: e8 71 2f 00 00 call 10e23e <_Thread_Enable_dispatch> if ( !do_wait && 10b2cd: 8a 55 d4 mov -0x2c(%ebp),%dl 10b2d0: 84 d2 test %dl,%dl 10b2d2: 75 17 jne 10b2eb (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 10b2d4: a1 38 88 12 00 mov 0x128838,%eax ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10b2d9: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b2dd: 75 0c jne 10b2eb (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b2df: 85 f6 test %esi,%esi 10b2e1: 74 1d je 10b300 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b2e3: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b2e4: 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 || 10b2e6: 83 fe 01 cmp $0x1,%esi 10b2e9: 76 15 jbe 10b300 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b2eb: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b2ee: a1 38 88 12 00 mov 0x128838,%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( 10b2f3: ff 70 34 pushl 0x34(%eax) 10b2f6: e8 11 00 00 00 call 10b30c <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b2fb: 89 c3 mov %eax,%ebx 10b2fd: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b300: 89 d8 mov %ebx,%eax 10b302: 8d 65 f4 lea -0xc(%ebp),%esp 10b305: 5b pop %ebx 10b306: 5e pop %esi 10b307: 5f pop %edi 10b308: c9 leave 10b309: c3 ret =============================================================================== 0010ba48 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10ba48: 55 push %ebp 10ba49: 89 e5 mov %esp,%ebp 10ba4b: 8b 55 08 mov 0x8(%ebp),%edx 10ba4e: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr ) return EINVAL; 10ba51: b8 16 00 00 00 mov $0x16,%eax int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { if ( !attr ) 10ba56: 85 d2 test %edx,%edx 10ba58: 74 0f je 10ba69 return EINVAL; if ( !attr->is_initialized ) 10ba5a: 83 3a 00 cmpl $0x0,(%edx) 10ba5d: 74 0a je 10ba69 return EINVAL; switch ( pshared ) { 10ba5f: 83 f9 01 cmp $0x1,%ecx 10ba62: 77 05 ja 10ba69 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10ba64: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10ba67: 30 c0 xor %al,%al default: return EINVAL; } } 10ba69: c9 leave 10ba6a: c3 ret =============================================================================== 0010c748 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10c748: 55 push %ebp 10c749: 89 e5 mov %esp,%ebp 10c74b: 57 push %edi 10c74c: 56 push %esi 10c74d: 53 push %ebx 10c74e: 83 ec 2c sub $0x2c,%esp 10c751: 8b 75 10 mov 0x10(%ebp),%esi /* * Check all the parameters */ if ( !param ) return EINVAL; 10c754: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp) int rc; /* * Check all the parameters */ if ( !param ) 10c75b: 85 f6 test %esi,%esi 10c75d: 0f 84 00 01 00 00 je 10c863 return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 10c763: 8d 45 e0 lea -0x20(%ebp),%eax 10c766: 50 push %eax 10c767: 8d 45 e4 lea -0x1c(%ebp),%eax 10c76a: 50 push %eax 10c76b: 56 push %esi 10c76c: ff 75 0c pushl 0xc(%ebp) 10c76f: e8 e0 52 00 00 call 111a54 <_POSIX_Thread_Translate_sched_param> 10c774: 89 45 d4 mov %eax,-0x2c(%ebp) policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 10c777: 83 c4 10 add $0x10,%esp 10c77a: 85 c0 test %eax,%eax 10c77c: 0f 85 e1 00 00 00 jne 10c863 10c782: 53 push %ebx return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); 10c783: 8d 45 dc lea -0x24(%ebp),%eax 10c786: 50 push %eax 10c787: ff 75 08 pushl 0x8(%ebp) 10c78a: 68 74 95 12 00 push $0x129574 10c78f: e8 84 1c 00 00 call 10e418 <_Objects_Get> 10c794: 89 c2 mov %eax,%edx switch ( location ) { 10c796: 83 c4 10 add $0x10,%esp 10c799: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) 10c79d: 0f 85 b9 00 00 00 jne 10c85c case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c7a3: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx if ( api->schedpolicy == SCHED_SPORADIC ) 10c7a9: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx) 10c7b0: 75 18 jne 10c7ca (void) _Watchdog_Remove( &api->Sporadic_timer ); 10c7b2: 83 ec 0c sub $0xc,%esp 10c7b5: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax 10c7bb: 50 push %eax 10c7bc: 89 55 d0 mov %edx,-0x30(%ebp) 10c7bf: e8 28 35 00 00 call 10fcec <_Watchdog_Remove> 10c7c4: 83 c4 10 add $0x10,%esp 10c7c7: 8b 55 d0 mov -0x30(%ebp),%edx api->schedpolicy = policy; 10c7ca: 8b 45 0c mov 0xc(%ebp),%eax 10c7cd: 89 83 84 00 00 00 mov %eax,0x84(%ebx) api->schedparam = *param; 10c7d3: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 10c7d9: b9 07 00 00 00 mov $0x7,%ecx 10c7de: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10c7e0: 8b 45 e4 mov -0x1c(%ebp),%eax 10c7e3: 89 42 7c mov %eax,0x7c(%edx) the_thread->budget_callout = budget_callout; 10c7e6: 8b 45 e0 mov -0x20(%ebp),%eax 10c7e9: 89 82 80 00 00 00 mov %eax,0x80(%edx) switch ( api->schedpolicy ) { 10c7ef: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10c7f3: 78 60 js 10c855 <== NEVER TAKEN 10c7f5: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10c7f9: 7e 08 jle 10c803 10c7fb: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10c7ff: 75 54 jne 10c855 <== NEVER TAKEN 10c801: eb 24 jmp 10c827 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c803: a1 00 93 12 00 mov 0x129300,%eax 10c808: 89 42 78 mov %eax,0x78(%edx) 10c80b: 0f b6 05 18 52 12 00 movzbl 0x125218,%eax 10c812: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax the_thread->real_priority = 10c818: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10c81b: 51 push %ecx 10c81c: 6a 01 push $0x1 10c81e: 50 push %eax 10c81f: 52 push %edx 10c820: e8 8b 21 00 00 call 10e9b0 <_Thread_Change_priority> 10c825: eb 2b jmp 10c852 true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10c827: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10c82d: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) _Watchdog_Remove( &api->Sporadic_timer ); 10c833: 83 ec 0c sub $0xc,%esp 10c836: 81 c3 a8 00 00 00 add $0xa8,%ebx 10c83c: 53 push %ebx 10c83d: 89 55 d0 mov %edx,-0x30(%ebp) 10c840: e8 a7 34 00 00 call 10fcec <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10c845: 58 pop %eax 10c846: 5a pop %edx 10c847: 8b 55 d0 mov -0x30(%ebp),%edx 10c84a: 52 push %edx 10c84b: 6a 00 push $0x0 10c84d: e8 e1 fd ff ff call 10c633 <_POSIX_Threads_Sporadic_budget_TSR> break; 10c852: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10c855: e8 9c 25 00 00 call 10edf6 <_Thread_Enable_dispatch> return 0; 10c85a: eb 07 jmp 10c863 #endif case OBJECTS_ERROR: break; } return ESRCH; 10c85c: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp) } 10c863: 8b 45 d4 mov -0x2c(%ebp),%eax 10c866: 8d 65 f4 lea -0xc(%ebp),%esp 10c869: 5b pop %ebx 10c86a: 5e pop %esi 10c86b: 5f pop %edi 10c86c: c9 leave 10c86d: c3 ret =============================================================================== 0010a644 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a644: 55 push %ebp 10a645: 89 e5 mov %esp,%ebp 10a647: 53 push %ebx 10a648: 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() ) 10a64b: 83 3d 0c 68 12 00 00 cmpl $0x0,0x12680c 10a652: 75 48 jne 10a69c <== NEVER TAKEN return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a654: a1 10 68 12 00 mov 0x126810,%eax 10a659: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10a65f: 8b 15 c8 62 12 00 mov 0x1262c8,%edx 10a665: 42 inc %edx 10a666: 89 15 c8 62 12 00 mov %edx,0x1262c8 */ void pthread_testcancel( void ) { POSIX_API_Control *thread_support; bool cancel = false; 10a66c: 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 && 10a66e: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10a675: 75 0a jne 10a681 <== 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)); 10a677: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10a67e: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a681: e8 14 25 00 00 call 10cb9a <_Thread_Enable_dispatch> if ( cancel ) 10a686: 84 db test %bl,%bl 10a688: 74 12 je 10a69c _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a68a: 50 push %eax 10a68b: 50 push %eax 10a68c: 6a ff push $0xffffffff 10a68e: ff 35 10 68 12 00 pushl 0x126810 10a694: e8 7b 52 00 00 call 10f914 <_POSIX_Thread_Exit> 10a699: 83 c4 10 add $0x10,%esp } 10a69c: 8b 5d fc mov -0x4(%ebp),%ebx 10a69f: c9 leave 10a6a0: c3 ret =============================================================================== 0010af01 : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10af01: 55 push %ebp 10af02: 89 e5 mov %esp,%ebp 10af04: 57 push %edi 10af05: 56 push %esi 10af06: 53 push %ebx 10af07: 83 ec 58 sub $0x58,%esp 10af0a: 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); 10af0d: 68 78 72 12 00 push $0x127278 10af12: e8 bd 08 00 00 call 10b7d4 10af17: 89 45 b4 mov %eax,-0x4c(%ebp) if (result != 0) { 10af1a: 83 c4 10 add $0x10,%esp 10af1d: 85 c0 test %eax,%eax 10af1f: 74 0e je 10af2f <== ALWAYS TAKEN free (req); 10af21: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af24: 53 push %ebx <== NOT EXECUTED 10af25: e8 06 ce ff ff call 107d30 <== NOT EXECUTED 10af2a: e9 bf 01 00 00 jmp 10b0ee <== 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); 10af2f: e8 a0 10 00 00 call 10bfd4 10af34: 57 push %edi 10af35: 8d 55 c4 lea -0x3c(%ebp),%edx 10af38: 52 push %edx 10af39: 8d 55 e0 lea -0x20(%ebp),%edx 10af3c: 52 push %edx 10af3d: 50 push %eax 10af3e: e8 95 0c 00 00 call 10bbd8 req->caller_thread = pthread_self (); 10af43: e8 8c 10 00 00 call 10bfd4 10af48: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10af4b: 8b 43 14 mov 0x14(%ebx),%eax 10af4e: 8b 55 c4 mov -0x3c(%ebp),%edx 10af51: 2b 50 14 sub 0x14(%eax),%edx 10af54: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10af57: 8b 55 e0 mov -0x20(%ebp),%edx 10af5a: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10af5d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10af64: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10af6b: 83 c4 10 add $0x10,%esp 10af6e: 83 3d e0 72 12 00 00 cmpl $0x0,0x1272e0 10af75: 0f 85 b7 00 00 00 jne 10b032 10af7b: 83 3d dc 72 12 00 04 cmpl $0x4,0x1272dc 10af82: 0f 8f aa 00 00 00 jg 10b032 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); 10af88: 56 push %esi 10af89: 6a 01 push $0x1 10af8b: ff 30 pushl (%eax) 10af8d: 68 c0 72 12 00 push $0x1272c0 10af92: e8 85 fb ff ff call 10ab1c 10af97: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10af99: 83 c4 10 add $0x10,%esp 10af9c: 83 78 18 01 cmpl $0x1,0x18(%eax) 10afa0: 8d 50 08 lea 0x8(%eax),%edx 10afa3: 8d 78 1c lea 0x1c(%eax),%edi 10afa6: 8d 40 20 lea 0x20(%eax),%eax 10afa9: 89 45 b0 mov %eax,-0x50(%ebp) 10afac: 75 66 jne 10b014 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10afae: 51 push %ecx 10afaf: 51 push %ecx 10afb0: 53 push %ebx 10afb1: 52 push %edx 10afb2: e8 c1 1f 00 00 call 10cf78 <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10afb7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10afbe: 58 pop %eax 10afbf: 5a pop %edx 10afc0: 6a 00 push $0x0 10afc2: 57 push %edi 10afc3: e8 ec 06 00 00 call 10b6b4 pthread_cond_init (&r_chain->cond, NULL); 10afc8: 5b pop %ebx 10afc9: 5f pop %edi 10afca: 6a 00 push $0x0 10afcc: ff 75 b0 pushl -0x50(%ebp) 10afcf: e8 a0 03 00 00 call 10b374 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10afd4: 56 push %esi 10afd5: 68 c7 ab 10 00 push $0x10abc7 10afda: 68 80 72 12 00 push $0x127280 10afdf: 8d 45 e4 lea -0x1c(%ebp),%eax 10afe2: 50 push %eax 10afe3: e8 bc 09 00 00 call 10b9a4 10afe8: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10afea: 83 c4 20 add $0x20,%esp 10afed: 85 c0 test %eax,%eax 10afef: 74 18 je 10b009 <== ALWAYS TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10aff1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aff4: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10aff9: e8 56 08 00 00 call 10b854 <== NOT EXECUTED return result; 10affe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b001: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED 10b004: e9 e8 00 00 00 jmp 10b0f1 <== NOT EXECUTED } ++aio_request_queue.active_threads; 10b009: ff 05 dc 72 12 00 incl 0x1272dc 10b00f: e9 cd 00 00 00 jmp 10b0e1 } else { /* put request in the fd chain it belongs to */ pthread_mutex_lock (&r_chain->mutex); 10b014: 83 ec 0c sub $0xc,%esp 10b017: 57 push %edi 10b018: 89 55 ac mov %edx,-0x54(%ebp) 10b01b: e8 b4 07 00 00 call 10b7d4 rtems_aio_insert_prio (&r_chain->perfd, req); 10b020: 5a pop %edx 10b021: 59 pop %ecx 10b022: 53 push %ebx 10b023: 8b 55 ac mov -0x54(%ebp),%edx 10b026: 52 push %edx 10b027: e8 ec fd ff ff call 10ae18 pthread_cond_signal (&r_chain->cond); 10b02c: 58 pop %eax 10b02d: ff 75 b0 pushl -0x50(%ebp) 10b030: eb 36 jmp 10b068 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, 10b032: 56 push %esi 10b033: 6a 00 push $0x0 10b035: ff 30 pushl (%eax) 10b037: 68 c0 72 12 00 push $0x1272c0 10b03c: e8 db fa ff ff call 10ab1c 10b041: 89 c6 mov %eax,%esi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10b043: 83 c4 10 add $0x10,%esp 10b046: 85 c0 test %eax,%eax 10b048: 74 2d je 10b077 { pthread_mutex_lock (&r_chain->mutex); 10b04a: 8d 78 1c lea 0x1c(%eax),%edi 10b04d: 83 ec 0c sub $0xc,%esp 10b050: 57 push %edi 10b051: e8 7e 07 00 00 call 10b7d4 rtems_aio_insert_prio (&r_chain->perfd, req); 10b056: 5a pop %edx 10b057: 59 pop %ecx 10b058: 53 push %ebx 10b059: 8d 46 08 lea 0x8(%esi),%eax 10b05c: 50 push %eax 10b05d: e8 b6 fd ff ff call 10ae18 pthread_cond_signal (&r_chain->cond); 10b062: 83 c6 20 add $0x20,%esi 10b065: 89 34 24 mov %esi,(%esp) 10b068: e8 a3 03 00 00 call 10b410 pthread_mutex_unlock (&r_chain->mutex); 10b06d: 89 3c 24 mov %edi,(%esp) 10b070: e8 df 07 00 00 call 10b854 10b075: eb 67 jmp 10b0de } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10b077: 50 push %eax 10b078: 6a 01 push $0x1 10b07a: 8b 43 14 mov 0x14(%ebx),%eax 10b07d: ff 30 pushl (%eax) 10b07f: 68 cc 72 12 00 push $0x1272cc 10b084: e8 93 fa ff ff call 10ab1c 10b089: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10b08b: 83 c4 10 add $0x10,%esp 10b08e: 83 78 18 01 cmpl $0x1,0x18(%eax) 10b092: 8d 40 08 lea 0x8(%eax),%eax 10b095: 75 3e jne 10b0d5 10b097: 57 push %edi 10b098: 57 push %edi 10b099: 53 push %ebx 10b09a: 50 push %eax 10b09b: e8 d8 1e 00 00 call 10cf78 <_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; 10b0a0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10b0a7: 5a pop %edx 10b0a8: 59 pop %ecx 10b0a9: 6a 00 push $0x0 10b0ab: 8d 46 1c lea 0x1c(%esi),%eax 10b0ae: 50 push %eax 10b0af: e8 00 06 00 00 call 10b6b4 pthread_cond_init (&r_chain->cond, NULL); 10b0b4: 5f pop %edi 10b0b5: 58 pop %eax 10b0b6: 6a 00 push $0x0 10b0b8: 83 c6 20 add $0x20,%esi 10b0bb: 56 push %esi 10b0bc: e8 b3 02 00 00 call 10b374 pthread_cond_signal (&aio_request_queue.new_req); 10b0c1: c7 04 24 7c 72 12 00 movl $0x12727c,(%esp) 10b0c8: e8 43 03 00 00 call 10b410 ++aio_request_queue.idle_threads; 10b0cd: ff 05 e0 72 12 00 incl 0x1272e0 10b0d3: eb 09 jmp 10b0de } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10b0d5: 56 push %esi 10b0d6: 56 push %esi 10b0d7: 53 push %ebx 10b0d8: 50 push %eax 10b0d9: e8 3a fd ff ff call 10ae18 10b0de: 83 c4 10 add $0x10,%esp } } pthread_mutex_unlock (&aio_request_queue.mutex); 10b0e1: 83 ec 0c sub $0xc,%esp 10b0e4: 68 78 72 12 00 push $0x127278 10b0e9: e8 66 07 00 00 call 10b854 return 0; 10b0ee: 83 c4 10 add $0x10,%esp } 10b0f1: 8b 45 b4 mov -0x4c(%ebp),%eax 10b0f4: 8d 65 f4 lea -0xc(%ebp),%esp 10b0f7: 5b pop %ebx 10b0f8: 5e pop %esi 10b0f9: 5f pop %edi 10b0fa: c9 leave 10b0fb: c3 ret =============================================================================== 0010abc7 : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10abc7: 55 push %ebp <== NOT EXECUTED 10abc8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abca: 57 push %edi <== NOT EXECUTED 10abcb: 56 push %esi <== NOT EXECUTED 10abcc: 53 push %ebx <== NOT EXECUTED 10abcd: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED rtems_aio_request_chain *r_chain = arg; 10abd0: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* acquire the mutex of the current fd chain. we don't need to lock the queue mutex since we can add requests to idle fd chains or even active ones if the working request has been extracted from the chain */ result = pthread_mutex_lock (&r_chain->mutex); 10abd3: 8d 7b 1c lea 0x1c(%ebx),%edi <== NOT EXECUTED 10abd6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10abd9: 57 push %edi <== NOT EXECUTED 10abda: e8 f5 0b 00 00 call 10b7d4 <== NOT EXECUTED if (result != 0) 10abdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10abe2: 85 c0 test %eax,%eax <== NOT EXECUTED 10abe4: 0f 85 24 02 00 00 jne 10ae0e <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10abea: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10abed: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED /* If the locked chain is not empty, take the first request extract it, unlock the chain and process the request, in this way the user can supply more requests to this fd chain */ if (!rtems_chain_is_empty (chain)) { 10abf0: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10abf2: 0f 84 cc 00 00 00 je 10acc4 <== NOT EXECUTED node = rtems_chain_first (chain); req = (rtems_aio_request *) node; /* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING discussion in rtems_aio_enqueue () */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10abf8: e8 d7 13 00 00 call 10bfd4 <== NOT EXECUTED 10abfd: 51 push %ecx <== NOT EXECUTED 10abfe: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED 10ac01: 52 push %edx <== NOT EXECUTED 10ac02: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED 10ac05: 51 push %ecx <== NOT EXECUTED 10ac06: 50 push %eax <== NOT EXECUTED 10ac07: e8 cc 0f 00 00 call 10bbd8 <== NOT EXECUTED param.sched_priority = req->priority; 10ac0c: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 10ac0f: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED pthread_setschedparam (pthread_self(), req->policy, ¶m); 10ac12: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED 10ac15: 89 55 b4 mov %edx,-0x4c(%ebp) <== NOT EXECUTED 10ac18: e8 b7 13 00 00 call 10bfd4 <== NOT EXECUTED 10ac1d: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ac20: 8d 4d c0 lea -0x40(%ebp),%ecx <== NOT EXECUTED 10ac23: 51 push %ecx <== NOT EXECUTED 10ac24: 8b 55 b4 mov -0x4c(%ebp),%edx <== NOT EXECUTED 10ac27: 52 push %edx <== NOT EXECUTED 10ac28: 50 push %eax <== NOT EXECUTED 10ac29: e8 b6 13 00 00 call 10bfe4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10ac2e: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10ac31: e8 06 23 00 00 call 10cf3c <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10ac36: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10ac39: e8 16 0c 00 00 call 10b854 <== NOT EXECUTED switch (req->aiocbp->aio_lio_opcode) { 10ac3e: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10ac41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac44: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED 10ac47: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10ac4a: 74 20 je 10ac6c <== NOT EXECUTED 10ac4c: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10ac4f: 74 36 je 10ac87 <== NOT EXECUTED 10ac51: 4a dec %edx <== NOT EXECUTED 10ac52: 75 45 jne 10ac99 <== NOT EXECUTED case LIO_READ: result = pread (req->aiocbp->aio_fildes, 10ac54: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac57: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ac5a: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10ac5d: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED 10ac60: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10ac63: ff 30 pushl (%eax) <== NOT EXECUTED 10ac65: e8 9a 94 00 00 call 114104 <== NOT EXECUTED 10ac6a: eb 16 jmp 10ac82 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: result = pwrite (req->aiocbp->aio_fildes, 10ac6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac6f: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ac72: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10ac75: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED 10ac78: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10ac7b: ff 30 pushl (%eax) <== NOT EXECUTED 10ac7d: e8 36 95 00 00 call 1141b8 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10ac82: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ac85: eb 0d jmp 10ac94 <== NOT EXECUTED case LIO_SYNC: result = fsync (req->aiocbp->aio_fildes); 10ac87: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac8a: ff 30 pushl (%eax) <== NOT EXECUTED 10ac8c: e8 1b 5d 00 00 call 1109ac <== NOT EXECUTED break; 10ac91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: result = -1; } if (result == -1) { 10ac94: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10ac97: 75 19 jne 10acb2 <== NOT EXECUTED req->aiocbp->return_value = -1; 10ac99: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10ac9c: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10aca3: e8 24 8a 00 00 call 1136cc <__errno> <== NOT EXECUTED 10aca8: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10acaa: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10acad: e9 21 ff ff ff jmp 10abd3 <== NOT EXECUTED } else { req->aiocbp->return_value = result; 10acb2: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED 10acb5: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED req->aiocbp->error_code = 0; 10acb8: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED 10acbf: e9 0f ff ff ff jmp 10abd3 <== NOT EXECUTED wait for a signal on chain, this will unlock the queue. The fd chain is already unlocked */ struct timespec timeout; pthread_mutex_unlock (&r_chain->mutex); 10acc4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10acc7: 57 push %edi <== NOT EXECUTED 10acc8: e8 87 0b 00 00 call 10b854 <== NOT EXECUTED pthread_mutex_lock (&aio_request_queue.mutex); 10accd: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED 10acd4: e8 fb 0a 00 00 call 10b7d4 <== NOT EXECUTED if (rtems_chain_is_empty (chain)) 10acd9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10acdc: 39 73 08 cmp %esi,0x8(%ebx) <== NOT EXECUTED 10acdf: 0f 85 ee fe ff ff jne 10abd3 <== NOT EXECUTED { clock_gettime (CLOCK_REALTIME, &timeout); 10ace5: 52 push %edx <== NOT EXECUTED 10ace6: 52 push %edx <== NOT EXECUTED 10ace7: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10acea: 50 push %eax <== NOT EXECUTED 10aceb: 6a 01 push $0x1 <== NOT EXECUTED 10aced: e8 72 05 00 00 call 10b264 <== NOT EXECUTED timeout.tv_sec += 3; 10acf2: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10acf6: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&r_chain->cond, 10acfd: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10ad00: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad03: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED 10ad06: 52 push %edx <== NOT EXECUTED 10ad07: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ad0c: 56 push %esi <== NOT EXECUTED 10ad0d: e8 6e 07 00 00 call 10b480 <== NOT EXECUTED &aio_request_queue.mutex, &timeout); /* If no requests were added to the chain we delete the fd chain from the queue and start working with idle fd chains */ if (result == ETIMEDOUT) { 10ad12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad15: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10ad18: 0f 85 b5 fe ff ff jne 10abd3 <== NOT EXECUTED 10ad1e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad21: 53 push %ebx <== NOT EXECUTED 10ad22: e8 15 22 00 00 call 10cf3c <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10ad27: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10ad2a: e8 85 08 00 00 call 10b5b4 <== NOT EXECUTED pthread_cond_destroy (&r_chain->cond); 10ad2f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10ad32: e8 89 05 00 00 call 10b2c0 <== NOT EXECUTED free (r_chain); 10ad37: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ad3a: e8 f1 cf ff ff call 107d30 <== NOT EXECUTED /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10ad3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad42: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED 10ad49: 72 12 00 10ad4c: 0f 85 a7 00 00 00 jne 10adf9 <== NOT EXECUTED ++aio_request_queue.idle_threads; 10ad52: ff 05 e0 72 12 00 incl 0x1272e0 <== NOT EXECUTED clock_gettime (CLOCK_REALTIME, &timeout); 10ad58: 50 push %eax <== NOT EXECUTED 10ad59: 50 push %eax <== NOT EXECUTED 10ad5a: 8d 4d dc lea -0x24(%ebp),%ecx <== NOT EXECUTED 10ad5d: 51 push %ecx <== NOT EXECUTED 10ad5e: 6a 01 push $0x1 <== NOT EXECUTED 10ad60: e8 ff 04 00 00 call 10b264 <== NOT EXECUTED timeout.tv_sec += 3; 10ad65: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10ad69: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&aio_request_queue.new_req, 10ad70: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad73: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10ad76: 50 push %eax <== NOT EXECUTED 10ad77: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ad7c: 68 7c 72 12 00 push $0x12727c <== NOT EXECUTED 10ad81: e8 fa 06 00 00 call 10b480 <== NOT EXECUTED &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 10ad86: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad89: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10ad8c: 75 12 jne 10ada0 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10ad8e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad91: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ad96: e8 b9 0a 00 00 call 10b854 <== NOT EXECUTED return NULL; 10ad9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad9e: eb 6e jmp 10ae0e <== NOT EXECUTED } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; 10ada0: ff 0d e0 72 12 00 decl 0x1272e0 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10ada6: 8b 35 cc 72 12 00 mov 0x1272cc,%esi <== NOT EXECUTED 10adac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adaf: 56 push %esi <== NOT EXECUTED 10adb0: e8 87 21 00 00 call 10cf3c <_Chain_Extract> <== NOT EXECUTED /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10adb5: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10adb8: 6a 01 push $0x1 <== NOT EXECUTED 10adba: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 10adbd: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10adc2: e8 55 fd ff ff call 10ab1c <== NOT EXECUTED 10adc7: 89 c3 mov %eax,%ebx <== NOT EXECUTED ((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; 10adc9: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED pthread_mutex_init (&r_chain->mutex, NULL); 10add0: 59 pop %ecx <== NOT EXECUTED 10add1: 5f pop %edi <== NOT EXECUTED 10add2: 6a 00 push $0x0 <== NOT EXECUTED 10add4: 8d 40 1c lea 0x1c(%eax),%eax <== NOT EXECUTED 10add7: 50 push %eax <== NOT EXECUTED 10add8: e8 d7 08 00 00 call 10b6b4 <== NOT EXECUTED pthread_cond_init (&r_chain->cond, NULL); 10addd: 58 pop %eax <== NOT EXECUTED 10adde: 5a pop %edx <== NOT EXECUTED 10addf: 6a 00 push $0x0 <== NOT EXECUTED 10ade1: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10ade4: 50 push %eax <== NOT EXECUTED 10ade5: e8 8a 05 00 00 call 10b374 <== NOT EXECUTED r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; 10adea: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED 10aded: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 10adf0: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10adf5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10adf7: eb 0d jmp 10ae06 <== NOT EXECUTED } else /* If there was a request added in the initial fd chain then release the mutex and process it */ pthread_mutex_unlock (&aio_request_queue.mutex); 10adf9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adfc: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ae01: e8 4e 0a 00 00 call 10b854 <== NOT EXECUTED 10ae06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae09: e9 c5 fd ff ff jmp 10abd3 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10ae0e: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ae10: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae13: 5b pop %ebx <== NOT EXECUTED 10ae14: 5e pop %esi <== NOT EXECUTED 10ae15: 5f pop %edi <== NOT EXECUTED 10ae16: c9 leave <== NOT EXECUTED 10ae17: c3 ret <== NOT EXECUTED =============================================================================== 0010aa20 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10aa20: 55 push %ebp 10aa21: 89 e5 mov %esp,%ebp 10aa23: 53 push %ebx 10aa24: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10aa27: 68 80 72 12 00 push $0x127280 10aa2c: e8 27 0f 00 00 call 10b958 10aa31: 89 c3 mov %eax,%ebx if (result != 0) 10aa33: 83 c4 10 add $0x10,%esp 10aa36: 85 c0 test %eax,%eax 10aa38: 0f 85 d7 00 00 00 jne 10ab15 <== NEVER TAKEN return result; result = 10aa3e: 51 push %ecx 10aa3f: 51 push %ecx 10aa40: 6a 00 push $0x0 10aa42: 68 80 72 12 00 push $0x127280 10aa47: e8 34 0f 00 00 call 10b980 pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10aa4c: 83 c4 10 add $0x10,%esp 10aa4f: 85 c0 test %eax,%eax 10aa51: 74 10 je 10aa63 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aa53: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa56: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED 10aa5b: e8 d8 0e 00 00 call 10b938 <== NOT EXECUTED 10aa60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10aa63: 52 push %edx 10aa64: 52 push %edx 10aa65: 6a 00 push $0x0 10aa67: 68 78 72 12 00 push $0x127278 10aa6c: e8 43 0c 00 00 call 10b6b4 if (result != 0) 10aa71: 83 c4 10 add $0x10,%esp 10aa74: 85 c0 test %eax,%eax 10aa76: 74 10 je 10aa88 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aa78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa7b: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED 10aa80: e8 b3 0e 00 00 call 10b938 <== NOT EXECUTED 10aa85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10aa88: 50 push %eax 10aa89: 50 push %eax 10aa8a: 6a 00 push $0x0 10aa8c: 68 7c 72 12 00 push $0x12727c 10aa91: e8 de 08 00 00 call 10b374 10aa96: 89 c3 mov %eax,%ebx if (result != 0) { 10aa98: 83 c4 10 add $0x10,%esp 10aa9b: 85 c0 test %eax,%eax 10aa9d: 74 1c je 10aabb <== ALWAYS TAKEN pthread_mutex_destroy (&aio_request_queue.mutex); 10aa9f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aaa2: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10aaa7: e8 08 0b 00 00 call 10b5b4 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10aaac: c7 04 24 80 72 12 00 movl $0x127280,(%esp) <== NOT EXECUTED 10aab3: e8 80 0e 00 00 call 10b938 <== NOT EXECUTED 10aab8: 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; 10aabb: c7 05 c0 72 12 00 c4 movl $0x1272c4,0x1272c0 10aac2: 72 12 00 head->previous = NULL; 10aac5: c7 05 c4 72 12 00 00 movl $0x0,0x1272c4 10aacc: 00 00 00 tail->previous = head; 10aacf: c7 05 c8 72 12 00 c0 movl $0x1272c0,0x1272c8 10aad6: 72 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10aad9: c7 05 cc 72 12 00 d0 movl $0x1272d0,0x1272cc 10aae0: 72 12 00 head->previous = NULL; 10aae3: c7 05 d0 72 12 00 00 movl $0x0,0x1272d0 10aaea: 00 00 00 tail->previous = head; 10aaed: c7 05 d4 72 12 00 cc movl $0x1272cc,0x1272d4 10aaf4: 72 12 00 } rtems_chain_initialize_empty (&aio_request_queue.work_req); rtems_chain_initialize_empty (&aio_request_queue.idle_req); aio_request_queue.active_threads = 0; 10aaf7: c7 05 dc 72 12 00 00 movl $0x0,0x1272dc 10aafe: 00 00 00 aio_request_queue.idle_threads = 0; 10ab01: c7 05 e0 72 12 00 00 movl $0x0,0x1272e0 10ab08: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10ab0b: c7 05 d8 72 12 00 0b movl $0xb00b,0x1272d8 10ab12: b0 00 00 return result; } 10ab15: 89 d8 mov %ebx,%eax 10ab17: 8b 5d fc mov -0x4(%ebp),%ebx 10ab1a: c9 leave 10ab1b: c3 ret =============================================================================== 0010ae18 : * NONE */ void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10ae18: 55 push %ebp 10ae19: 89 e5 mov %esp,%ebp 10ae1b: 56 push %esi 10ae1c: 53 push %ebx 10ae1d: 8b 4d 08 mov 0x8(%ebp),%ecx 10ae20: 8b 55 0c mov 0xc(%ebp),%edx } AIO_printf ("Thread finished\n"); return NULL; } 10ae23: 8b 01 mov (%ecx),%eax 10ae25: 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)) { 10ae28: 39 d8 cmp %ebx,%eax 10ae2a: 74 27 je 10ae53 <== 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; 10ae2c: 8b 48 14 mov 0x14(%eax),%ecx 10ae2f: 8b 49 14 mov 0x14(%ecx),%ecx while (req->aiocbp->aio_reqprio > prio && 10ae32: 8b 72 14 mov 0x14(%edx),%esi 10ae35: 8b 76 14 mov 0x14(%esi),%esi 10ae38: eb 08 jmp 10ae42 } AIO_printf ("Thread finished\n"); return NULL; } 10ae3a: 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; 10ae3c: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10ae3f: 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 && 10ae42: 39 ce cmp %ecx,%esi 10ae44: 7e 04 jle 10ae4a <== ALWAYS TAKEN 10ae46: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10ae48: 75 f0 jne 10ae3a <== 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 ); 10ae4a: 89 55 0c mov %edx,0xc(%ebp) 10ae4d: 8b 40 04 mov 0x4(%eax),%eax 10ae50: 89 45 08 mov %eax,0x8(%ebp) } rtems_chain_insert (node->previous, &req->next_prio); } } 10ae53: 5b pop %ebx 10ae54: 5e pop %esi 10ae55: c9 leave 10ae56: e9 1d 21 00 00 jmp 10cf78 <_Chain_Insert> =============================================================================== 0010aea4 : * 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) { 10aea4: 55 push %ebp 10aea5: 89 e5 mov %esp,%ebp 10aea7: 53 push %ebx 10aea8: 83 ec 04 sub $0x4,%esp 10aeab: 8b 55 08 mov 0x8(%ebp),%edx 10aeae: 8b 4d 0c mov 0xc(%ebp),%ecx } AIO_printf ("Thread finished\n"); return NULL; } 10aeb1: 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 ); 10aeb3: 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; 10aeb6: 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)) 10aebb: 39 d3 cmp %edx,%ebx 10aebd: 75 08 jne 10aec7 <== ALWAYS TAKEN 10aebf: eb 3b jmp 10aefc } AIO_printf ("Thread finished\n"); return NULL; } 10aec1: 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) { 10aec3: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10aec5: 74 30 je 10aef7 <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; 10aec7: 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) { 10aec9: 39 4b 14 cmp %ecx,0x14(%ebx) 10aecc: 75 f3 jne 10aec1 <== NEVER TAKEN 10aece: 83 ec 0c sub $0xc,%esp 10aed1: 53 push %ebx 10aed2: e8 65 20 00 00 call 10cf3c <_Chain_Extract> if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10aed7: 8b 43 14 mov 0x14(%ebx),%eax 10aeda: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) current->aiocbp->return_value = -1; 10aee1: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (current); 10aee8: 89 1c 24 mov %ebx,(%esp) 10aeeb: e8 40 ce ff ff call 107d30 } return AIO_CANCELED; 10aef0: 83 c4 10 add $0x10,%esp 10aef3: 31 c0 xor %eax,%eax 10aef5: eb 05 jmp 10aefc node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10aef7: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10aefc: 8b 5d fc mov -0x4(%ebp),%ebx 10aeff: c9 leave 10af00: c3 ret =============================================================================== 0010ab34 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10ab34: 55 push %ebp 10ab35: 89 e5 mov %esp,%ebp 10ab37: 56 push %esi 10ab38: 53 push %ebx 10ab39: 8b 5d 10 mov 0x10(%ebp),%ebx 10ab3c: 8b 75 14 mov 0x14(%ebp),%esi RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check( rtems_chain_control *chain, rtems_chain_node *node ) { return _Chain_Append_with_empty_check( chain, node ); 10ab3f: 50 push %eax 10ab40: 50 push %eax 10ab41: ff 75 0c pushl 0xc(%ebp) 10ab44: ff 75 08 pushl 0x8(%ebp) 10ab47: e8 8c 04 00 00 call 10afd8 <_Chain_Append_with_empty_check> rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { 10ab4c: 83 c4 10 add $0x10,%esp 10ab4f: 84 c0 test %al,%al 10ab51: 74 11 je 10ab64 <== NEVER TAKEN sc = rtems_event_send( task, events ); 10ab53: 89 75 0c mov %esi,0xc(%ebp) 10ab56: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10ab59: 8d 65 f8 lea -0x8(%ebp),%esp 10ab5c: 5b pop %ebx 10ab5d: 5e pop %esi 10ab5e: c9 leave { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { sc = rtems_event_send( task, events ); 10ab5f: e9 cc f6 ff ff jmp 10a230 } return sc; } 10ab64: 31 c0 xor %eax,%eax 10ab66: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ab69: 5b pop %ebx <== NOT EXECUTED 10ab6a: 5e pop %esi <== NOT EXECUTED 10ab6b: c9 leave <== NOT EXECUTED 10ab6c: c3 ret <== NOT EXECUTED =============================================================================== 0010abac : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10abac: 55 push %ebp 10abad: 89 e5 mov %esp,%ebp 10abaf: 57 push %edi 10abb0: 56 push %esi 10abb1: 53 push %ebx 10abb2: 83 ec 1c sub $0x1c,%esp 10abb5: 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( 10abb8: 8d 75 e4 lea -0x1c(%ebp),%esi 10abbb: eb 13 jmp 10abd0 10abbd: 56 push %esi 10abbe: ff 75 10 pushl 0x10(%ebp) 10abc1: 6a 00 push $0x0 10abc3: 57 push %edi 10abc4: e8 07 f5 ff ff call 10a0d0 ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10abc9: 83 c4 10 add $0x10,%esp 10abcc: 85 c0 test %eax,%eax 10abce: 75 16 jne 10abe6 <== ALWAYS TAKEN */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10abd0: 83 ec 0c sub $0xc,%esp 10abd3: ff 75 08 pushl 0x8(%ebp) 10abd6: e8 9d 04 00 00 call 10b078 <_Chain_Get> 10abdb: 89 c3 mov %eax,%ebx sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10abdd: 83 c4 10 add $0x10,%esp 10abe0: 85 c0 test %eax,%eax 10abe2: 74 d9 je 10abbd 10abe4: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10abe6: 8b 55 14 mov 0x14(%ebp),%edx 10abe9: 89 1a mov %ebx,(%edx) return sc; } 10abeb: 8d 65 f4 lea -0xc(%ebp),%esp 10abee: 5b pop %ebx 10abef: 5e pop %esi 10abf0: 5f pop %edi 10abf1: c9 leave 10abf2: c3 ret =============================================================================== 0010abf4 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10abf4: 55 push %ebp 10abf5: 89 e5 mov %esp,%ebp 10abf7: 56 push %esi 10abf8: 53 push %ebx 10abf9: 8b 5d 10 mov 0x10(%ebp),%ebx 10abfc: 8b 75 14 mov 0x14(%ebp),%esi RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check( rtems_chain_control *chain, rtems_chain_node *node ) { return _Chain_Prepend_with_empty_check( chain, node ); 10abff: 50 push %eax 10ac00: 50 push %eax 10ac01: ff 75 0c pushl 0xc(%ebp) 10ac04: ff 75 08 pushl 0x8(%ebp) 10ac07: e8 b0 04 00 00 call 10b0bc <_Chain_Prepend_with_empty_check> rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { 10ac0c: 83 c4 10 add $0x10,%esp 10ac0f: 84 c0 test %al,%al 10ac11: 74 11 je 10ac24 <== NEVER TAKEN sc = rtems_event_send( task, events ); 10ac13: 89 75 0c mov %esi,0xc(%ebp) 10ac16: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10ac19: 8d 65 f8 lea -0x8(%ebp),%esp 10ac1c: 5b pop %ebx 10ac1d: 5e pop %esi 10ac1e: c9 leave { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { sc = rtems_event_send( task, events ); 10ac1f: e9 0c f6 ff ff jmp 10a230 } return sc; } 10ac24: 31 c0 xor %eax,%eax 10ac26: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ac29: 5b pop %ebx <== NOT EXECUTED 10ac2a: 5e pop %esi <== NOT EXECUTED 10ac2b: c9 leave <== NOT EXECUTED 10ac2c: c3 ret <== NOT EXECUTED =============================================================================== 0010b71c : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 10b71c: 55 push %ebp 10b71d: 89 e5 mov %esp,%ebp 10b71f: 57 push %edi 10b720: 56 push %esi 10b721: 53 push %ebx 10b722: 83 ec 0c sub $0xc,%esp 10b725: 8b 5d 08 mov 0x8(%ebp),%ebx 10b728: 8b 75 0c mov 0xc(%ebp),%esi 10b72b: 8b 45 10 mov 0x10(%ebp),%eax rtems_device_major_number major_limit = _IO_Number_of_drivers; 10b72e: 8b 15 b8 8d 12 00 mov 0x128db8,%edx if ( rtems_interrupt_is_in_progress() ) 10b734: 83 3d 5c 89 12 00 00 cmpl $0x0,0x12895c 10b73b: 0f 85 cc 00 00 00 jne 10b80d <== NEVER TAKEN return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 10b741: 85 c0 test %eax,%eax 10b743: 0f 84 cb 00 00 00 je 10b814 return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 10b749: 89 10 mov %edx,(%eax) if ( driver_table == NULL ) 10b74b: 85 f6 test %esi,%esi 10b74d: 0f 84 c1 00 00 00 je 10b814 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b753: 83 3e 00 cmpl $0x0,(%esi) 10b756: 0f 85 cc 00 00 00 jne 10b828 10b75c: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b760: 0f 85 c2 00 00 00 jne 10b828 10b766: e9 a9 00 00 00 jmp 10b814 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b76b: 8b 15 18 84 12 00 mov 0x128418,%edx 10b771: 42 inc %edx 10b772: 89 15 18 84 12 00 mov %edx,0x128418 if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 10b778: 85 db test %ebx,%ebx 10b77a: 75 32 jne 10b7ae static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 10b77c: 8b 0d b8 8d 12 00 mov 0x128db8,%ecx 10b782: 8b 15 bc 8d 12 00 mov 0x128dbc,%edx 10b788: eb 15 jmp 10b79f static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b78a: 83 3a 00 cmpl $0x0,(%edx) 10b78d: 0f 85 9f 00 00 00 jne 10b832 10b793: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10b797: 0f 85 95 00 00 00 jne 10b832 10b79d: eb 04 jmp 10b7a3 rtems_device_major_number n = _IO_Number_of_drivers; rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10b79f: 39 cb cmp %ecx,%ebx 10b7a1: 72 e7 jb 10b78a if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10b7a3: 89 18 mov %ebx,(%eax) if ( m != n ) 10b7a5: 39 cb cmp %ecx,%ebx 10b7a7: 75 30 jne 10b7d9 10b7a9: e9 8d 00 00 00 jmp 10b83b _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 10b7ae: 6b d3 18 imul $0x18,%ebx,%edx 10b7b1: 03 15 bc 8d 12 00 add 0x128dbc,%edx static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b7b7: 31 c9 xor %ecx,%ecx 10b7b9: 83 3a 00 cmpl $0x0,(%edx) 10b7bc: 75 09 jne 10b7c7 10b7be: 31 c9 xor %ecx,%ecx 10b7c0: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10b7c4: 0f 94 c1 sete %cl } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; if ( !rtems_io_is_empty_table( table ) ) { 10b7c7: 85 c9 test %ecx,%ecx 10b7c9: 75 0c jne 10b7d7 _Thread_Enable_dispatch(); 10b7cb: e8 22 1a 00 00 call 10d1f2 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10b7d0: b8 0c 00 00 00 mov $0xc,%eax 10b7d5: eb 49 jmp 10b820 } *registered_major = major; 10b7d7: 89 18 mov %ebx,(%eax) } _IO_Driver_address_table [major] = *driver_table; 10b7d9: 6b c3 18 imul $0x18,%ebx,%eax 10b7dc: 03 05 bc 8d 12 00 add 0x128dbc,%eax 10b7e2: b9 06 00 00 00 mov $0x6,%ecx 10b7e7: 89 c7 mov %eax,%edi 10b7e9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10b7eb: e8 02 1a 00 00 call 10d1f2 <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 10b7f0: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10b7f7: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10b7fe: 89 5d 08 mov %ebx,0x8(%ebp) } 10b801: 83 c4 0c add $0xc,%esp 10b804: 5b pop %ebx 10b805: 5e pop %esi 10b806: 5f pop %edi 10b807: c9 leave _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 10b808: e9 63 71 00 00 jmp 112970 ) { rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; 10b80d: b8 12 00 00 00 mov $0x12,%eax 10b812: eb 0c jmp 10b820 if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 10b814: b8 09 00 00 00 mov $0x9,%eax 10b819: eb 05 jmp 10b820 if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; 10b81b: b8 0a 00 00 00 mov $0xa,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10b820: 83 c4 0c add $0xc,%esp 10b823: 5b pop %ebx 10b824: 5e pop %esi 10b825: 5f pop %edi 10b826: c9 leave 10b827: c3 ret return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 10b828: 39 d3 cmp %edx,%ebx 10b82a: 0f 82 3b ff ff ff jb 10b76b 10b830: eb e9 jmp 10b81b rtems_device_major_number n = _IO_Number_of_drivers; rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10b832: 43 inc %ebx 10b833: 83 c2 18 add $0x18,%edx 10b836: e9 64 ff ff ff jmp 10b79f if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 10b83b: e8 b2 19 00 00 call 10d1f2 <_Thread_Enable_dispatch> *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 10b840: b8 05 00 00 00 mov $0x5,%eax if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); return sc; 10b845: eb d9 jmp 10b820 =============================================================================== 0010c744 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c744: 55 push %ebp 10c745: 89 e5 mov %esp,%ebp 10c747: 57 push %edi 10c748: 56 push %esi 10c749: 53 push %ebx 10c74a: 83 ec 0c sub $0xc,%esp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c74d: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10c751: 74 3d je 10c790 <== NEVER TAKEN 10c753: 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 ]; 10c758: 8b 04 9d 7c 01 13 00 mov 0x13017c(,%ebx,4),%eax 10c75f: 8b 78 04 mov 0x4(%eax),%edi if ( !information ) 10c762: be 01 00 00 00 mov $0x1,%esi 10c767: 85 ff test %edi,%edi 10c769: 75 17 jne 10c782 10c76b: eb 1d jmp 10c78a continue; for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10c76d: 8b 47 1c mov 0x1c(%edi),%eax 10c770: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !the_thread ) 10c773: 85 c0 test %eax,%eax 10c775: 74 0a je 10c781 <== NEVER TAKEN continue; (*routine)(the_thread); 10c777: 83 ec 0c sub $0xc,%esp 10c77a: 50 push %eax 10c77b: ff 55 08 call *0x8(%ebp) 10c77e: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10c781: 46 inc %esi 10c782: 0f b7 47 10 movzwl 0x10(%edi),%eax 10c786: 39 c6 cmp %eax,%esi 10c788: 76 e3 jbe 10c76d Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c78a: 43 inc %ebx 10c78b: 83 fb 04 cmp $0x4,%ebx 10c78e: 75 c8 jne 10c758 (*routine)(the_thread); } } } 10c790: 8d 65 f4 lea -0xc(%ebp),%esp 10c793: 5b pop %ebx 10c794: 5e pop %esi 10c795: 5f pop %edi 10c796: c9 leave 10c797: c3 ret =============================================================================== 001147ec : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 1147ec: 55 push %ebp 1147ed: 89 e5 mov %esp,%ebp 1147ef: 57 push %edi 1147f0: 56 push %esi 1147f1: 53 push %ebx 1147f2: 83 ec 1c sub $0x1c,%esp 1147f5: 8b 75 0c mov 0xc(%ebp),%esi 1147f8: 8b 55 10 mov 0x10(%ebp),%edx 1147fb: 8b 7d 14 mov 0x14(%ebp),%edi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 1147fe: b8 03 00 00 00 mov $0x3,%eax rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 114803: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 114807: 0f 84 ce 00 00 00 je 1148db return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 11480d: b0 09 mov $0x9,%al register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) 11480f: 85 f6 test %esi,%esi 114811: 0f 84 c4 00 00 00 je 1148db return RTEMS_INVALID_ADDRESS; if ( !id ) 114817: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 11481b: 0f 84 ba 00 00 00 je 1148db <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 114821: 85 ff test %edi,%edi 114823: 0f 84 ad 00 00 00 je 1148d6 114829: 85 d2 test %edx,%edx 11482b: 0f 84 a5 00 00 00 je 1148d6 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 114831: b0 08 mov $0x8,%al return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 114833: 39 fa cmp %edi,%edx 114835: 0f 82 a0 00 00 00 jb 1148db 11483b: f7 c7 03 00 00 00 test $0x3,%edi 114841: 0f 85 94 00 00 00 jne 1148db !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; 114847: 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 ) ) 114849: f7 c6 03 00 00 00 test $0x3,%esi 11484f: 0f 85 86 00 00 00 jne 1148db 114855: a1 f4 e6 13 00 mov 0x13e6f4,%eax 11485a: 40 inc %eax 11485b: a3 f4 e6 13 00 mov %eax,0x13e6f4 * 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 ); 114860: 83 ec 0c sub $0xc,%esp 114863: 68 84 e5 13 00 push $0x13e584 114868: 89 55 e4 mov %edx,-0x1c(%ebp) 11486b: e8 14 3e 00 00 call 118684 <_Objects_Allocate> 114870: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 114872: 83 c4 10 add $0x10,%esp 114875: 85 c0 test %eax,%eax 114877: 8b 55 e4 mov -0x1c(%ebp),%edx 11487a: 75 0c jne 114888 _Thread_Enable_dispatch(); 11487c: e8 4d 4c 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 114881: b8 05 00 00 00 mov $0x5,%eax 114886: eb 53 jmp 1148db _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 114888: 89 70 10 mov %esi,0x10(%eax) the_partition->length = length; 11488b: 89 50 14 mov %edx,0x14(%eax) the_partition->buffer_size = buffer_size; 11488e: 89 78 18 mov %edi,0x18(%eax) the_partition->attribute_set = attribute_set; 114891: 8b 45 18 mov 0x18(%ebp),%eax 114894: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 114897: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 11489e: 57 push %edi 11489f: 89 d0 mov %edx,%eax 1148a1: 31 d2 xor %edx,%edx 1148a3: f7 f7 div %edi 1148a5: 50 push %eax 1148a6: 56 push %esi 1148a7: 8d 43 24 lea 0x24(%ebx),%eax 1148aa: 50 push %eax 1148ab: e8 84 2a 00 00 call 117334 <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1148b0: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1148b3: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1148b6: 8b 15 a0 e5 13 00 mov 0x13e5a0,%edx 1148bc: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1148bf: 8b 55 08 mov 0x8(%ebp),%edx 1148c2: 89 53 0c mov %edx,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 1148c5: 8b 55 1c mov 0x1c(%ebp),%edx 1148c8: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1148ca: e8 ff 4b 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1148cf: 83 c4 10 add $0x10,%esp 1148d2: 31 c0 xor %eax,%eax 1148d4: eb 05 jmp 1148db 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; 1148d6: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1148db: 8d 65 f4 lea -0xc(%ebp),%esp 1148de: 5b pop %ebx 1148df: 5e pop %esi 1148e0: 5f pop %edi 1148e1: c9 leave 1148e2: c3 ret =============================================================================== 0010b031 : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 10b031: 55 push %ebp 10b032: 89 e5 mov %esp,%ebp 10b034: 57 push %edi 10b035: 56 push %esi 10b036: 53 push %ebx 10b037: 83 ec 30 sub $0x30,%esp 10b03a: 8b 75 08 mov 0x8(%ebp),%esi 10b03d: 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 ); 10b040: 8d 45 e4 lea -0x1c(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 10b043: 50 push %eax 10b044: 56 push %esi 10b045: 68 14 73 12 00 push $0x127314 10b04a: e8 3d 1e 00 00 call 10ce8c <_Objects_Get> 10b04f: 89 c7 mov %eax,%edi switch ( location ) { 10b051: 83 c4 10 add $0x10,%esp 10b054: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b058: 0f 85 3b 01 00 00 jne 10b199 <== NEVER TAKEN case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10b05e: a1 4c 79 12 00 mov 0x12794c,%eax 10b063: 39 47 40 cmp %eax,0x40(%edi) 10b066: 74 0f je 10b077 _Thread_Enable_dispatch(); 10b068: e8 fd 27 00 00 call 10d86a <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 10b06d: be 17 00 00 00 mov $0x17,%esi 10b072: e9 27 01 00 00 jmp 10b19e } if ( length == RTEMS_PERIOD_STATUS ) { 10b077: 85 db test %ebx,%ebx 10b079: 75 1b jne 10b096 switch ( the_period->state ) { 10b07b: 8b 47 38 mov 0x38(%edi),%eax 10b07e: 31 f6 xor %esi,%esi 10b080: 83 f8 04 cmp $0x4,%eax 10b083: 77 07 ja 10b08c <== NEVER TAKEN 10b085: 8b 34 85 a8 0d 12 00 mov 0x120da8(,%eax,4),%esi case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10b08c: e8 d9 27 00 00 call 10d86a <_Thread_Enable_dispatch> return( return_value ); 10b091: e9 08 01 00 00 jmp 10b19e } _ISR_Disable( level ); 10b096: 9c pushf 10b097: fa cli 10b098: 8f 45 d4 popl -0x2c(%ebp) if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 10b09b: 8b 47 38 mov 0x38(%edi),%eax 10b09e: 85 c0 test %eax,%eax 10b0a0: 75 4c jne 10b0ee _ISR_Enable( level ); 10b0a2: ff 75 d4 pushl -0x2c(%ebp) 10b0a5: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10b0a6: 83 ec 0c sub $0xc,%esp 10b0a9: 57 push %edi 10b0aa: e8 3f fe ff ff call 10aeee <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10b0af: 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; 10b0b6: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10b0bd: c7 47 2c a8 b3 10 00 movl $0x10b3a8,0x2c(%edi) the_watchdog->id = id; 10b0c4: 89 77 30 mov %esi,0x30(%edi) the_watchdog->user_data = user_data; 10b0c7: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10b0ce: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b0d1: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b0d4: 58 pop %eax 10b0d5: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b0d6: 83 c7 10 add $0x10,%edi 10b0d9: 57 push %edi 10b0da: 68 e8 74 12 00 push $0x1274e8 10b0df: e8 2c 35 00 00 call 10e610 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b0e4: e8 81 27 00 00 call 10d86a <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b0e9: 83 c4 10 add $0x10,%esp 10b0ec: eb 65 jmp 10b153 } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 10b0ee: 83 f8 02 cmp $0x2,%eax 10b0f1: 75 64 jne 10b157 /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10b0f3: 83 ec 0c sub $0xc,%esp 10b0f6: 57 push %edi 10b0f7: e8 5a fe ff ff call 10af56 <_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; 10b0fc: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) the_period->next_length = length; 10b103: 89 5f 3c mov %ebx,0x3c(%edi) _ISR_Enable( level ); 10b106: ff 75 d4 pushl -0x2c(%ebp) 10b109: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10b10a: a1 4c 79 12 00 mov 0x12794c,%eax 10b10f: 8b 57 08 mov 0x8(%edi),%edx 10b112: 89 50 20 mov %edx,0x20(%eax) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b115: 5b pop %ebx 10b116: 5e pop %esi 10b117: 68 00 40 00 00 push $0x4000 10b11c: 50 push %eax 10b11d: e8 fe 2e 00 00 call 10e020 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10b122: 9c pushf 10b123: fa cli 10b124: 5a pop %edx local_state = the_period->state; 10b125: 8b 47 38 mov 0x38(%edi),%eax the_period->state = RATE_MONOTONIC_ACTIVE; 10b128: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) _ISR_Enable( level ); 10b12f: 52 push %edx 10b130: 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 ) 10b131: 83 c4 10 add $0x10,%esp 10b134: 83 f8 03 cmp $0x3,%eax 10b137: 75 15 jne 10b14e _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b139: 51 push %ecx 10b13a: 51 push %ecx 10b13b: 68 00 40 00 00 push $0x4000 10b140: ff 35 4c 79 12 00 pushl 0x12794c 10b146: e8 ed 23 00 00 call 10d538 <_Thread_Clear_state> 10b14b: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 10b14e: e8 17 27 00 00 call 10d86a <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b153: 31 f6 xor %esi,%esi 10b155: eb 47 jmp 10b19e #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b157: be 04 00 00 00 mov $0x4,%esi _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 10b15c: 83 f8 04 cmp $0x4,%eax 10b15f: 75 3d jne 10b19e <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10b161: 83 ec 0c sub $0xc,%esp 10b164: 57 push %edi 10b165: e8 ec fd ff ff call 10af56 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10b16a: ff 75 d4 pushl -0x2c(%ebp) 10b16d: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10b16e: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) the_period->next_length = length; 10b175: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b178: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b17b: 58 pop %eax 10b17c: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b17d: 83 c7 10 add $0x10,%edi 10b180: 57 push %edi 10b181: 68 e8 74 12 00 push $0x1274e8 10b186: e8 85 34 00 00 call 10e610 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b18b: e8 da 26 00 00 call 10d86a <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 10b190: 83 c4 10 add $0x10,%esp 10b193: 66 be 06 00 mov $0x6,%si 10b197: eb 05 jmp 10b19e #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b199: be 04 00 00 00 mov $0x4,%esi } 10b19e: 89 f0 mov %esi,%eax 10b1a0: 8d 65 f4 lea -0xc(%ebp),%esp 10b1a3: 5b pop %ebx 10b1a4: 5e pop %esi 10b1a5: 5f pop %edi 10b1a6: c9 leave 10b1a7: c3 ret =============================================================================== 0010b1a8 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 10b1a8: 55 push %ebp 10b1a9: 89 e5 mov %esp,%ebp 10b1ab: 57 push %edi 10b1ac: 56 push %esi 10b1ad: 53 push %ebx 10b1ae: 83 ec 7c sub $0x7c,%esp 10b1b1: 8b 5d 08 mov 0x8(%ebp),%ebx 10b1b4: 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 ) 10b1b7: 85 ff test %edi,%edi 10b1b9: 0f 84 2b 01 00 00 je 10b2ea <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10b1bf: 52 push %edx 10b1c0: 52 push %edx 10b1c1: 68 bc 0d 12 00 push $0x120dbc 10b1c6: 53 push %ebx 10b1c7: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 10b1c9: 5e pop %esi 10b1ca: 58 pop %eax 10b1cb: 68 da 0d 12 00 push $0x120dda 10b1d0: 53 push %ebx 10b1d1: ff d7 call *%edi (*print)( context, "--- Wall times are in seconds ---\n" ); 10b1d3: 5a pop %edx 10b1d4: 59 pop %ecx 10b1d5: 68 fc 0d 12 00 push $0x120dfc 10b1da: 53 push %ebx 10b1db: ff d7 call *%edi Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10b1dd: 5e pop %esi 10b1de: 58 pop %eax 10b1df: 68 1f 0e 12 00 push $0x120e1f 10b1e4: 53 push %ebx 10b1e5: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 10b1e7: 5a pop %edx 10b1e8: 59 pop %ecx 10b1e9: 68 6a 0e 12 00 push $0x120e6a 10b1ee: 53 push %ebx 10b1ef: 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 ; 10b1f1: 8b 35 1c 73 12 00 mov 0x12731c,%esi 10b1f7: 83 c4 10 add $0x10,%esp 10b1fa: e9 df 00 00 00 jmp 10b2de id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10b1ff: 50 push %eax 10b200: 50 push %eax 10b201: 8d 45 88 lea -0x78(%ebp),%eax 10b204: 50 push %eax 10b205: 56 push %esi 10b206: e8 85 56 00 00 call 110890 if ( status != RTEMS_SUCCESSFUL ) 10b20b: 83 c4 10 add $0x10,%esp 10b20e: 85 c0 test %eax,%eax 10b210: 0f 85 c7 00 00 00 jne 10b2dd #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 ); 10b216: 51 push %ecx 10b217: 51 push %ecx 10b218: 8d 55 c0 lea -0x40(%ebp),%edx 10b21b: 52 push %edx 10b21c: 56 push %esi 10b21d: e8 12 57 00 00 call 110934 #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 10b222: 83 c4 0c add $0xc,%esp 10b225: 8d 45 e3 lea -0x1d(%ebp),%eax 10b228: 50 push %eax 10b229: 6a 05 push $0x5 10b22b: ff 75 c0 pushl -0x40(%ebp) 10b22e: e8 01 02 00 00 call 10b434 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10b233: 58 pop %eax 10b234: 5a pop %edx 10b235: ff 75 8c pushl -0x74(%ebp) 10b238: ff 75 88 pushl -0x78(%ebp) 10b23b: 8d 55 e3 lea -0x1d(%ebp),%edx 10b23e: 52 push %edx 10b23f: 56 push %esi 10b240: 68 b6 0e 12 00 push $0x120eb6 10b245: 53 push %ebx 10b246: ff d7 call *%edi ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10b248: 8b 45 88 mov -0x78(%ebp),%eax 10b24b: 83 c4 20 add $0x20,%esp 10b24e: 85 c0 test %eax,%eax 10b250: 75 0f jne 10b261 (*print)( context, "\n" ); 10b252: 51 push %ecx 10b253: 51 push %ecx 10b254: 68 30 11 12 00 push $0x121130 10b259: 53 push %ebx 10b25a: ff d7 call *%edi continue; 10b25c: 83 c4 10 add $0x10,%esp 10b25f: eb 7c jmp 10b2dd 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 ); 10b261: 52 push %edx 10b262: 8d 55 d8 lea -0x28(%ebp),%edx 10b265: 52 push %edx 10b266: 50 push %eax 10b267: 8d 45 a0 lea -0x60(%ebp),%eax 10b26a: 50 push %eax 10b26b: e8 74 30 00 00 call 10e2e4 <_Timespec_Divide_by_integer> (*print)( context, 10b270: 8b 45 dc mov -0x24(%ebp),%eax 10b273: b9 e8 03 00 00 mov $0x3e8,%ecx 10b278: 99 cltd 10b279: f7 f9 idiv %ecx 10b27b: 50 push %eax 10b27c: ff 75 d8 pushl -0x28(%ebp) 10b27f: 8b 45 9c mov -0x64(%ebp),%eax 10b282: 99 cltd 10b283: f7 f9 idiv %ecx 10b285: 50 push %eax 10b286: ff 75 98 pushl -0x68(%ebp) 10b289: 8b 45 94 mov -0x6c(%ebp),%eax 10b28c: 99 cltd 10b28d: f7 f9 idiv %ecx 10b28f: 50 push %eax 10b290: ff 75 90 pushl -0x70(%ebp) 10b293: 68 cd 0e 12 00 push $0x120ecd 10b298: 53 push %ebx 10b299: 89 4d 84 mov %ecx,-0x7c(%ebp) 10b29c: 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); 10b29e: 83 c4 2c add $0x2c,%esp 10b2a1: 8d 55 d8 lea -0x28(%ebp),%edx 10b2a4: 52 push %edx 10b2a5: 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; 10b2a8: 8d 45 b8 lea -0x48(%ebp),%eax _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 10b2ab: 50 push %eax 10b2ac: e8 33 30 00 00 call 10e2e4 <_Timespec_Divide_by_integer> (*print)( context, 10b2b1: 8b 45 dc mov -0x24(%ebp),%eax 10b2b4: 8b 4d 84 mov -0x7c(%ebp),%ecx 10b2b7: 99 cltd 10b2b8: f7 f9 idiv %ecx 10b2ba: 50 push %eax 10b2bb: ff 75 d8 pushl -0x28(%ebp) 10b2be: 8b 45 b4 mov -0x4c(%ebp),%eax 10b2c1: 99 cltd 10b2c2: f7 f9 idiv %ecx 10b2c4: 50 push %eax 10b2c5: ff 75 b0 pushl -0x50(%ebp) 10b2c8: 8b 45 ac mov -0x54(%ebp),%eax 10b2cb: 99 cltd 10b2cc: f7 f9 idiv %ecx 10b2ce: 50 push %eax 10b2cf: ff 75 a8 pushl -0x58(%ebp) 10b2d2: 68 ec 0e 12 00 push $0x120eec 10b2d7: 53 push %ebx 10b2d8: ff d7 call *%edi 10b2da: 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++ ) { 10b2dd: 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 ; 10b2de: 3b 35 20 73 12 00 cmp 0x127320,%esi 10b2e4: 0f 86 15 ff ff ff jbe 10b1ff the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10b2ea: 8d 65 f4 lea -0xc(%ebp),%esp 10b2ed: 5b pop %ebx 10b2ee: 5e pop %esi 10b2ef: 5f pop %edi 10b2f0: c9 leave 10b2f1: c3 ret =============================================================================== 00115b4c : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 115b4c: 55 push %ebp 115b4d: 89 e5 mov %esp,%ebp 115b4f: 53 push %ebx 115b50: 83 ec 14 sub $0x14,%esp 115b53: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; 115b56: 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 ) 115b5b: 85 db test %ebx,%ebx 115b5d: 74 6d je 115bcc return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 115b5f: 50 push %eax 115b60: 50 push %eax 115b61: 8d 45 f4 lea -0xc(%ebp),%eax 115b64: 50 push %eax 115b65: ff 75 08 pushl 0x8(%ebp) 115b68: e8 83 39 00 00 call 1194f0 <_Thread_Get> switch ( location ) { 115b6d: 83 c4 10 add $0x10,%esp 115b70: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 115b74: 75 51 jne 115bc7 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 115b76: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 115b7c: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 115b80: 74 39 je 115bbb if ( asr->is_enabled ) { 115b82: 80 7a 08 00 cmpb $0x0,0x8(%edx) 115b86: 74 22 je 115baa rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115b88: 9c pushf 115b89: fa cli 115b8a: 59 pop %ecx *signal_set |= signals; 115b8b: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 115b8e: 51 push %ecx 115b8f: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 115b90: 83 3d 40 ec 13 00 00 cmpl $0x0,0x13ec40 115b97: 74 19 je 115bb2 115b99: 3b 05 44 ec 13 00 cmp 0x13ec44,%eax 115b9f: 75 11 jne 115bb2 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 115ba1: c6 05 50 ec 13 00 01 movb $0x1,0x13ec50 115ba8: eb 08 jmp 115bb2 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115baa: 9c pushf 115bab: fa cli 115bac: 58 pop %eax *signal_set |= signals; 115bad: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 115bb0: 50 push %eax 115bb1: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 115bb2: e8 17 39 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115bb7: 31 c0 xor %eax,%eax 115bb9: eb 11 jmp 115bcc } _Thread_Enable_dispatch(); 115bbb: e8 0e 39 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 115bc0: b8 0b 00 00 00 mov $0xb,%eax 115bc5: eb 05 jmp 115bcc case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115bc7: b8 04 00 00 00 mov $0x4,%eax } 115bcc: 8b 5d fc mov -0x4(%ebp),%ebx 115bcf: c9 leave 115bd0: c3 ret =============================================================================== 00110d7c : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 110d7c: 55 push %ebp 110d7d: 89 e5 mov %esp,%ebp 110d7f: 57 push %edi 110d80: 56 push %esi 110d81: 53 push %ebx 110d82: 83 ec 1c sub $0x1c,%esp 110d85: 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; 110d88: 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 ) 110d8d: 85 c9 test %ecx,%ecx 110d8f: 0f 84 fb 00 00 00 je 110e90 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 110d95: 8b 35 28 48 12 00 mov 0x124828,%esi api = executing->API_Extensions[ THREAD_API_RTEMS ]; 110d9b: 8b 9e e8 00 00 00 mov 0xe8(%esi),%ebx asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 110da1: 80 7e 74 01 cmpb $0x1,0x74(%esi) 110da5: 19 ff sbb %edi,%edi 110da7: 81 e7 00 01 00 00 and $0x100,%edi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 110dad: 83 7e 7c 00 cmpl $0x0,0x7c(%esi) 110db1: 74 06 je 110db9 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 110db3: 81 cf 00 02 00 00 or $0x200,%edi old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 110db9: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 110dbd: 19 d2 sbb %edx,%edx 110dbf: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 110dc5: 89 55 e4 mov %edx,-0x1c(%ebp) 110dc8: 89 4d e0 mov %ecx,-0x20(%ebp) 110dcb: e8 a5 c5 ff ff call 10d375 <_CPU_ISR_Get_level> if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 110dd0: 8b 55 e4 mov -0x1c(%ebp),%edx 110dd3: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 110dd5: 09 f8 or %edi,%eax 110dd7: 8b 4d e0 mov -0x20(%ebp),%ecx 110dda: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 110ddc: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 110de3: 74 0b je 110df0 executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 110de5: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 110dec: 0f 94 46 74 sete 0x74(%esi) if ( mask & RTEMS_TIMESLICE_MASK ) { 110df0: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 110df7: 74 21 je 110e1a if ( _Modes_Is_timeslice(mode_set) ) { 110df9: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 110e00: 74 11 je 110e13 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 110e02: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 110e09: a1 b0 42 12 00 mov 0x1242b0,%eax 110e0e: 89 46 78 mov %eax,0x78(%esi) 110e11: eb 07 jmp 110e1a } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 110e13: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 110e1a: f6 45 0c 01 testb $0x1,0xc(%ebp) 110e1e: 74 0a je 110e2a */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 110e20: f6 45 08 01 testb $0x1,0x8(%ebp) 110e24: 74 03 je 110e29 110e26: fa cli 110e27: eb 01 jmp 110e2a 110e29: fb sti /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110e2a: 31 c9 xor %ecx,%ecx if ( mask & RTEMS_ASR_MASK ) { 110e2c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 110e33: 74 2a je 110e5f * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 110e35: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 110e3c: 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 ) { 110e3f: 3a 43 08 cmp 0x8(%ebx),%al 110e42: 74 1b je 110e5f asr->is_enabled = is_asr_enabled; 110e44: 88 43 08 mov %al,0x8(%ebx) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 110e47: 9c pushf 110e48: fa cli 110e49: 58 pop %eax _signals = information->signals_pending; 110e4a: 8b 53 18 mov 0x18(%ebx),%edx information->signals_pending = information->signals_posted; 110e4d: 8b 4b 14 mov 0x14(%ebx),%ecx 110e50: 89 4b 18 mov %ecx,0x18(%ebx) information->signals_posted = _signals; 110e53: 89 53 14 mov %edx,0x14(%ebx) _ISR_Enable( _level ); 110e56: 50 push %eax 110e57: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110e58: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 110e5c: 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; 110e5f: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 110e61: 83 3d 5c 44 12 00 03 cmpl $0x3,0x12445c 110e68: 75 26 jne 110e90 <== NEVER TAKEN bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 110e6a: 8b 15 28 48 12 00 mov 0x124828,%edx if ( are_signals_pending || 110e70: 84 c9 test %cl,%cl 110e72: 75 0e jne 110e82 110e74: 3b 15 2c 48 12 00 cmp 0x12482c,%edx 110e7a: 74 14 je 110e90 (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 110e7c: 80 7a 74 00 cmpb $0x0,0x74(%edx) 110e80: 74 0e je 110e90 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 110e82: c6 05 34 48 12 00 01 movb $0x1,0x124834 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 110e89: e8 0e b1 ff ff call 10bf9c <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 110e8e: 31 c0 xor %eax,%eax } 110e90: 83 c4 1c add $0x1c,%esp 110e93: 5b pop %ebx 110e94: 5e pop %esi 110e95: 5f pop %edi 110e96: c9 leave 110e97: c3 ret =============================================================================== 0010dd30 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10dd30: 55 push %ebp 10dd31: 89 e5 mov %esp,%ebp 10dd33: 56 push %esi 10dd34: 53 push %ebx 10dd35: 83 ec 10 sub $0x10,%esp 10dd38: 8b 5d 0c mov 0xc(%ebp),%ebx 10dd3b: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd3e: 85 db test %ebx,%ebx 10dd40: 74 10 je 10dd52 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 ) ); 10dd42: 0f b6 15 f4 41 12 00 movzbl 0x1241f4,%edx !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10dd49: b8 13 00 00 00 mov $0x13,%eax ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd4e: 39 d3 cmp %edx,%ebx 10dd50: 77 52 ja 10dda4 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10dd52: 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 ) 10dd57: 85 f6 test %esi,%esi 10dd59: 74 49 je 10dda4 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10dd5b: 51 push %ecx 10dd5c: 51 push %ecx 10dd5d: 8d 45 f4 lea -0xc(%ebp),%eax 10dd60: 50 push %eax 10dd61: ff 75 08 pushl 0x8(%ebp) 10dd64: e8 fb 1d 00 00 call 10fb64 <_Thread_Get> switch ( location ) { 10dd69: 83 c4 10 add $0x10,%esp 10dd6c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10dd70: 75 2d jne 10dd9f case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10dd72: 8b 50 14 mov 0x14(%eax),%edx 10dd75: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10dd77: 85 db test %ebx,%ebx 10dd79: 74 1b je 10dd96 the_thread->real_priority = new_priority; 10dd7b: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10dd7e: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10dd82: 74 05 je 10dd89 10dd84: 39 58 14 cmp %ebx,0x14(%eax) 10dd87: 76 0d jbe 10dd96 <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10dd89: 52 push %edx 10dd8a: 6a 00 push $0x0 10dd8c: 53 push %ebx 10dd8d: 50 push %eax 10dd8e: e8 69 19 00 00 call 10f6fc <_Thread_Change_priority> 10dd93: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10dd96: e8 a7 1d 00 00 call 10fb42 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10dd9b: 31 c0 xor %eax,%eax 10dd9d: eb 05 jmp 10dda4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10dd9f: b8 04 00 00 00 mov $0x4,%eax } 10dda4: 8d 65 f8 lea -0x8(%ebp),%esp 10dda7: 5b pop %ebx 10dda8: 5e pop %esi 10dda9: c9 leave 10ddaa: c3 ret =============================================================================== 001163a0 : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 1163a0: 55 push %ebp 1163a1: 89 e5 mov %esp,%ebp 1163a3: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 1163a6: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 1163a9: 50 push %eax 1163aa: ff 75 08 pushl 0x8(%ebp) 1163ad: 68 5c f0 13 00 push $0x13f05c 1163b2: e8 39 27 00 00 call 118af0 <_Objects_Get> switch ( location ) { 1163b7: 83 c4 10 add $0x10,%esp 1163ba: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 1163be: 75 1e jne 1163de case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 1163c0: 83 78 38 04 cmpl $0x4,0x38(%eax) 1163c4: 74 0f je 1163d5 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 1163c6: 83 ec 0c sub $0xc,%esp 1163c9: 83 c0 10 add $0x10,%eax 1163cc: 50 push %eax 1163cd: e8 32 41 00 00 call 11a504 <_Watchdog_Remove> 1163d2: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 1163d5: e8 f4 30 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1163da: 31 c0 xor %eax,%eax 1163dc: eb 05 jmp 1163e3 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1163de: b8 04 00 00 00 mov $0x4,%eax } 1163e3: c9 leave 1163e4: c3 ret =============================================================================== 00116800 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 116800: 55 push %ebp 116801: 89 e5 mov %esp,%ebp 116803: 57 push %edi 116804: 56 push %esi 116805: 53 push %ebx 116806: 83 ec 1c sub $0x1c,%esp 116809: 8b 7d 0c mov 0xc(%ebp),%edi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 11680c: 8b 35 9c f0 13 00 mov 0x13f09c,%esi if ( !timer_server ) return RTEMS_INCORRECT_STATE; 116812: 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 ) 116817: 85 f6 test %esi,%esi 116819: 0f 84 b1 00 00 00 je 1168d0 return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 11681f: b3 0b mov $0xb,%bl Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 116821: 80 3d 08 e7 13 00 00 cmpb $0x0,0x13e708 116828: 0f 84 a2 00 00 00 je 1168d0 <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 11682e: b3 09 mov $0x9,%bl return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 116830: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 116834: 0f 84 96 00 00 00 je 1168d0 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 11683a: 83 ec 0c sub $0xc,%esp 11683d: 57 push %edi 11683e: e8 ad d6 ff ff call 113ef0 <_TOD_Validate> 116843: 83 c4 10 add $0x10,%esp return RTEMS_INVALID_CLOCK; 116846: b3 14 mov $0x14,%bl return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 116848: 84 c0 test %al,%al 11684a: 0f 84 80 00 00 00 je 1168d0 return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 116850: 83 ec 0c sub $0xc,%esp 116853: 57 push %edi 116854: e8 2f d6 ff ff call 113e88 <_TOD_To_seconds> 116859: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 11685b: 83 c4 10 add $0x10,%esp 11685e: 3b 05 a0 e7 13 00 cmp 0x13e7a0,%eax 116864: 76 6a jbe 1168d0 116866: 51 push %ecx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 116867: 8d 45 e4 lea -0x1c(%ebp),%eax 11686a: 50 push %eax 11686b: ff 75 08 pushl 0x8(%ebp) 11686e: 68 5c f0 13 00 push $0x13f05c 116873: e8 78 22 00 00 call 118af0 <_Objects_Get> 116878: 89 c3 mov %eax,%ebx switch ( location ) { 11687a: 83 c4 10 add $0x10,%esp 11687d: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 116881: 75 48 jne 1168cb case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 116883: 83 ec 0c sub $0xc,%esp 116886: 8d 40 10 lea 0x10(%eax),%eax 116889: 50 push %eax 11688a: e8 75 3c 00 00 call 11a504 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 11688f: 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; 116896: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) the_watchdog->routine = routine; 11689d: 8b 45 10 mov 0x10(%ebp),%eax 1168a0: 89 43 2c mov %eax,0x2c(%ebx) the_watchdog->id = id; 1168a3: 8b 45 08 mov 0x8(%ebp),%eax 1168a6: 89 43 30 mov %eax,0x30(%ebx) the_watchdog->user_data = user_data; 1168a9: 8b 45 14 mov 0x14(%ebp),%eax 1168ac: 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(); 1168af: 2b 3d a0 e7 13 00 sub 0x13e7a0,%edi 1168b5: 89 7b 1c mov %edi,0x1c(%ebx) (*timer_server->schedule_operation)( timer_server, the_timer ); 1168b8: 58 pop %eax 1168b9: 5a pop %edx 1168ba: 53 push %ebx 1168bb: 56 push %esi 1168bc: ff 56 04 call *0x4(%esi) _Thread_Enable_dispatch(); 1168bf: e8 0a 2c 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1168c4: 83 c4 10 add $0x10,%esp 1168c7: 31 db xor %ebx,%ebx 1168c9: eb 05 jmp 1168d0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1168cb: bb 04 00 00 00 mov $0x4,%ebx } 1168d0: 89 d8 mov %ebx,%eax 1168d2: 8d 65 f4 lea -0xc(%ebp),%esp 1168d5: 5b pop %ebx 1168d6: 5e pop %esi 1168d7: 5f pop %edi 1168d8: c9 leave 1168d9: c3 ret =============================================================================== 0010a8f4 : #include int sched_get_priority_max( int policy ) { 10a8f4: 55 push %ebp 10a8f5: 89 e5 mov %esp,%ebp 10a8f7: 83 ec 08 sub $0x8,%esp 10a8fa: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a8fd: 83 f9 04 cmp $0x4,%ecx 10a900: 77 0b ja 10a90d 10a902: b8 01 00 00 00 mov $0x1,%eax 10a907: d3 e0 shl %cl,%eax 10a909: a8 17 test $0x17,%al 10a90b: 75 10 jne 10a91d <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a90d: e8 5a 74 00 00 call 111d6c <__errno> 10a912: c7 00 16 00 00 00 movl $0x16,(%eax) 10a918: 83 c8 ff or $0xffffffff,%eax 10a91b: eb 08 jmp 10a925 } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 10a91d: 0f b6 05 18 12 12 00 movzbl 0x121218,%eax 10a924: 48 dec %eax } 10a925: c9 leave 10a926: c3 ret =============================================================================== 0010a928 : #include int sched_get_priority_min( int policy ) { 10a928: 55 push %ebp 10a929: 89 e5 mov %esp,%ebp 10a92b: 83 ec 08 sub $0x8,%esp 10a92e: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a931: 83 f9 04 cmp $0x4,%ecx 10a934: 77 11 ja 10a947 10a936: ba 01 00 00 00 mov $0x1,%edx 10a93b: d3 e2 shl %cl,%edx default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; 10a93d: b8 01 00 00 00 mov $0x1,%eax int sched_get_priority_min( int policy ) { switch ( policy ) { 10a942: 80 e2 17 and $0x17,%dl 10a945: 75 0e jne 10a955 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a947: e8 20 74 00 00 call 111d6c <__errno> 10a94c: c7 00 16 00 00 00 movl $0x16,(%eax) 10a952: 83 c8 ff or $0xffffffff,%eax } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10a955: c9 leave 10a956: c3 ret =============================================================================== 0010a958 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10a958: 55 push %ebp 10a959: 89 e5 mov %esp,%ebp 10a95b: 56 push %esi 10a95c: 53 push %ebx 10a95d: 8b 75 08 mov 0x8(%ebp),%esi 10a960: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10a963: 85 f6 test %esi,%esi 10a965: 74 16 je 10a97d <== NEVER TAKEN 10a967: e8 b4 d0 ff ff call 107a20 10a96c: 39 c6 cmp %eax,%esi 10a96e: 74 0d je 10a97d rtems_set_errno_and_return_minus_one( ESRCH ); 10a970: e8 f7 73 00 00 call 111d6c <__errno> 10a975: c7 00 03 00 00 00 movl $0x3,(%eax) 10a97b: eb 0f jmp 10a98c if ( !interval ) 10a97d: 85 db test %ebx,%ebx 10a97f: 75 10 jne 10a991 rtems_set_errno_and_return_minus_one( EINVAL ); 10a981: e8 e6 73 00 00 call 111d6c <__errno> 10a986: c7 00 16 00 00 00 movl $0x16,(%eax) 10a98c: 83 c8 ff or $0xffffffff,%eax 10a98f: eb 13 jmp 10a9a4 _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10a991: 50 push %eax 10a992: 50 push %eax 10a993: 53 push %ebx 10a994: ff 35 a0 52 12 00 pushl 0x1252a0 10a99a: e8 81 30 00 00 call 10da20 <_Timespec_From_ticks> return 0; 10a99f: 83 c4 10 add $0x10,%esp 10a9a2: 31 c0 xor %eax,%eax } 10a9a4: 8d 65 f8 lea -0x8(%ebp),%esp 10a9a7: 5b pop %ebx 10a9a8: 5e pop %esi 10a9a9: c9 leave 10a9aa: c3 ret =============================================================================== 0010cff0 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 10cff0: 55 push %ebp 10cff1: 89 e5 mov %esp,%ebp 10cff3: 53 push %ebx 10cff4: 83 ec 14 sub $0x14,%esp 10cff7: 8b 5d 08 mov 0x8(%ebp),%ebx int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 10cffa: 85 db test %ebx,%ebx 10cffc: 75 10 jne 10d00e <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10cffe: e8 65 80 00 00 call 115068 <__errno> 10d003: c7 00 16 00 00 00 movl $0x16,(%eax) 10d009: 83 c8 ff or $0xffffffff,%eax 10d00c: eb 21 jmp 10d02f status = _POSIX_Semaphore_Create_support( 10d00e: 8d 45 f4 lea -0xc(%ebp),%eax 10d011: 50 push %eax 10d012: ff 75 10 pushl 0x10(%ebp) 10d015: ff 75 0c pushl 0xc(%ebp) 10d018: 6a 00 push $0x0 10d01a: e8 8d 58 00 00 call 1128ac <_POSIX_Semaphore_Create_support> pshared, value, &the_semaphore ); if ( status != -1 ) 10d01f: 83 c4 10 add $0x10,%esp 10d022: 83 f8 ff cmp $0xffffffff,%eax 10d025: 74 08 je 10d02f *sem = the_semaphore->Object.id; 10d027: 8b 55 f4 mov -0xc(%ebp),%edx 10d02a: 8b 52 08 mov 0x8(%edx),%edx 10d02d: 89 13 mov %edx,(%ebx) return status; } 10d02f: 8b 5d fc mov -0x4(%ebp),%ebx 10d032: c9 leave 10d033: c3 ret =============================================================================== 0010d034 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10d034: 55 push %ebp 10d035: 89 e5 mov %esp,%ebp 10d037: 57 push %edi 10d038: 56 push %esi 10d039: 53 push %ebx 10d03a: 83 ec 2c sub $0x2c,%esp 10d03d: 8b 75 08 mov 0x8(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10d040: a1 c8 a4 12 00 mov 0x12a4c8,%eax 10d045: 40 inc %eax 10d046: a3 c8 a4 12 00 mov %eax,0x12a4c8 va_list arg; mode_t mode; unsigned int value = 0; 10d04b: 31 ff xor %edi,%edi POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10d04d: 8b 45 0c mov 0xc(%ebp),%eax 10d050: 25 00 02 00 00 and $0x200,%eax 10d055: 89 45 d4 mov %eax,-0x2c(%ebp) 10d058: 74 03 je 10d05d va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10d05a: 8b 7d 14 mov 0x14(%ebp),%edi va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10d05d: 52 push %edx 10d05e: 52 push %edx 10d05f: 8d 45 e4 lea -0x1c(%ebp),%eax 10d062: 50 push %eax 10d063: 56 push %esi 10d064: e8 77 59 00 00 call 1129e0 <_POSIX_Semaphore_Name_to_id> 10d069: 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 ) { 10d06b: 83 c4 10 add $0x10,%esp 10d06e: 85 c0 test %eax,%eax 10d070: 74 19 je 10d08b /* * 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) ) ) { 10d072: 83 f8 02 cmp $0x2,%eax 10d075: 75 06 jne 10d07d <== NEVER TAKEN 10d077: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10d07b: 75 59 jne 10d0d6 _Thread_Enable_dispatch(); 10d07d: e8 6c 27 00 00 call 10f7ee <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10d082: e8 e1 7f 00 00 call 115068 <__errno> 10d087: 89 18 mov %ebx,(%eax) 10d089: eb 1f jmp 10d0aa /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10d08b: 8b 45 0c mov 0xc(%ebp),%eax 10d08e: 25 00 0a 00 00 and $0xa00,%eax 10d093: 3d 00 0a 00 00 cmp $0xa00,%eax 10d098: 75 15 jne 10d0af _Thread_Enable_dispatch(); 10d09a: e8 4f 27 00 00 call 10f7ee <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10d09f: e8 c4 7f 00 00 call 115068 <__errno> 10d0a4: c7 00 11 00 00 00 movl $0x11,(%eax) 10d0aa: 83 c8 ff or $0xffffffff,%eax 10d0ad: eb 4a jmp 10d0f9 10d0af: 50 push %eax } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10d0b0: 8d 45 dc lea -0x24(%ebp),%eax 10d0b3: 50 push %eax 10d0b4: ff 75 e4 pushl -0x1c(%ebp) 10d0b7: 68 8c a7 12 00 push $0x12a78c 10d0bc: e8 db 1c 00 00 call 10ed9c <_Objects_Get> 10d0c1: 89 45 e0 mov %eax,-0x20(%ebp) the_semaphore->open_count += 1; 10d0c4: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10d0c7: e8 22 27 00 00 call 10f7ee <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10d0cc: e8 1d 27 00 00 call 10f7ee <_Thread_Enable_dispatch> goto return_id; 10d0d1: 83 c4 10 add $0x10,%esp 10d0d4: eb 1d jmp 10d0f3 /* * 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( 10d0d6: 8d 45 e0 lea -0x20(%ebp),%eax 10d0d9: 50 push %eax 10d0da: 57 push %edi 10d0db: 6a 00 push $0x0 10d0dd: 56 push %esi 10d0de: e8 c9 57 00 00 call 1128ac <_POSIX_Semaphore_Create_support> 10d0e3: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10d0e5: e8 04 27 00 00 call 10f7ee <_Thread_Enable_dispatch> if ( status == -1 ) 10d0ea: 83 c4 10 add $0x10,%esp return SEM_FAILED; 10d0ed: 83 c8 ff or $0xffffffff,%eax * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 10d0f0: 43 inc %ebx 10d0f1: 74 06 je 10d0f9 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; 10d0f3: 8b 45 e0 mov -0x20(%ebp),%eax 10d0f6: 83 c0 08 add $0x8,%eax #endif return id; } 10d0f9: 8d 65 f4 lea -0xc(%ebp),%esp 10d0fc: 5b pop %ebx 10d0fd: 5e pop %esi 10d0fe: 5f pop %edi 10d0ff: c9 leave 10d100: c3 ret =============================================================================== 0010a7dc : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10a7dc: 55 push %ebp 10a7dd: 89 e5 mov %esp,%ebp 10a7df: 57 push %edi 10a7e0: 56 push %esi 10a7e1: 53 push %ebx 10a7e2: 83 ec 1c sub $0x1c,%esp 10a7e5: 8b 5d 08 mov 0x8(%ebp),%ebx 10a7e8: 8b 55 0c mov 0xc(%ebp),%edx 10a7eb: 8b 45 10 mov 0x10(%ebp),%eax ISR_Level level; if ( oact ) 10a7ee: 85 c0 test %eax,%eax 10a7f0: 74 12 je 10a804 *oact = _POSIX_signals_Vectors[ sig ]; 10a7f2: 6b f3 0c imul $0xc,%ebx,%esi 10a7f5: 81 c6 9c 68 12 00 add $0x12689c,%esi 10a7fb: b9 03 00 00 00 mov $0x3,%ecx 10a800: 89 c7 mov %eax,%edi 10a802: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10a804: 85 db test %ebx,%ebx 10a806: 74 0d je 10a815 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a808: 8d 43 ff lea -0x1(%ebx),%eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10a80b: 83 f8 1f cmp $0x1f,%eax 10a80e: 77 05 ja 10a815 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10a810: 83 fb 09 cmp $0x9,%ebx 10a813: 75 10 jne 10a825 rtems_set_errno_and_return_minus_one( EINVAL ); 10a815: e8 d6 77 00 00 call 111ff0 <__errno> 10a81a: c7 00 16 00 00 00 movl $0x16,(%eax) 10a820: 83 c8 ff or $0xffffffff,%eax 10a823: eb 57 jmp 10a87c * 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; 10a825: 31 c0 xor %eax,%eax /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10a827: 85 d2 test %edx,%edx 10a829: 74 51 je 10a87c <== 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 ); 10a82b: 9c pushf 10a82c: fa cli 10a82d: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10a830: 83 7a 08 00 cmpl $0x0,0x8(%edx) 10a834: 75 1a jne 10a850 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10a836: 6b f3 0c imul $0xc,%ebx,%esi 10a839: 8d 86 9c 68 12 00 lea 0x12689c(%esi),%eax 10a83f: 81 c6 9c 09 12 00 add $0x12099c,%esi 10a845: b9 03 00 00 00 mov $0x3,%ecx 10a84a: 89 c7 mov %eax,%edi 10a84c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a84e: eb 26 jmp 10a876 } else { _POSIX_signals_Clear_process_signals( sig ); 10a850: 83 ec 0c sub $0xc,%esp 10a853: 53 push %ebx 10a854: 89 55 e0 mov %edx,-0x20(%ebp) 10a857: e8 70 4e 00 00 call 10f6cc <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10a85c: 6b db 0c imul $0xc,%ebx,%ebx 10a85f: 81 c3 9c 68 12 00 add $0x12689c,%ebx 10a865: b9 03 00 00 00 mov $0x3,%ecx 10a86a: 8b 55 e0 mov -0x20(%ebp),%edx 10a86d: 89 df mov %ebx,%edi 10a86f: 89 d6 mov %edx,%esi 10a871: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a873: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10a876: ff 75 e4 pushl -0x1c(%ebp) 10a879: 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; 10a87a: 31 c0 xor %eax,%eax } 10a87c: 8d 65 f4 lea -0xc(%ebp),%esp 10a87f: 5b pop %ebx 10a880: 5e pop %esi 10a881: 5f pop %edi 10a882: c9 leave 10a883: c3 ret =============================================================================== 0010ab97 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10ab97: 55 push %ebp 10ab98: 89 e5 mov %esp,%ebp 10ab9a: 57 push %edi 10ab9b: 56 push %esi 10ab9c: 53 push %ebx 10ab9d: 83 ec 3c sub $0x3c,%esp 10aba0: 8b 75 08 mov 0x8(%ebp),%esi 10aba3: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10aba6: 85 f6 test %esi,%esi 10aba8: 74 24 je 10abce /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10abaa: 85 db test %ebx,%ebx 10abac: 74 30 je 10abde if ( !_Timespec_Is_valid( timeout ) ) 10abae: 83 ec 0c sub $0xc,%esp 10abb1: 53 push %ebx 10abb2: e8 1d 31 00 00 call 10dcd4 <_Timespec_Is_valid> 10abb7: 83 c4 10 add $0x10,%esp 10abba: 84 c0 test %al,%al 10abbc: 74 10 je 10abce rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10abbe: 83 ec 0c sub $0xc,%esp 10abc1: 53 push %ebx 10abc2: e8 65 31 00 00 call 10dd2c <_Timespec_To_ticks> if ( !interval ) 10abc7: 83 c4 10 add $0x10,%esp 10abca: 85 c0 test %eax,%eax 10abcc: 75 12 jne 10abe0 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10abce: e8 b5 79 00 00 call 112588 <__errno> 10abd3: c7 00 16 00 00 00 movl $0x16,(%eax) 10abd9: e9 39 01 00 00 jmp 10ad17 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; 10abde: 31 c0 xor %eax,%eax /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10abe0: 8b 7d 0c mov 0xc(%ebp),%edi 10abe3: 85 ff test %edi,%edi 10abe5: 75 03 jne 10abea 10abe7: 8d 7d dc lea -0x24(%ebp),%edi the_thread = _Thread_Executing; 10abea: 8b 15 68 68 12 00 mov 0x126868,%edx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10abf0: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx 10abf6: 89 4d d4 mov %ecx,-0x2c(%ebp) * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10abf9: 9c pushf 10abfa: fa cli 10abfb: 8f 45 d0 popl -0x30(%ebp) if ( *set & api->signals_pending ) { 10abfe: 8b 1e mov (%esi),%ebx 10ac00: 89 5d c4 mov %ebx,-0x3c(%ebp) 10ac03: 8b 5d d4 mov -0x2c(%ebp),%ebx 10ac06: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx 10ac0c: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac0f: 74 32 je 10ac43 /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10ac11: 83 ec 0c sub $0xc,%esp 10ac14: 51 push %ecx 10ac15: e8 3e ff ff ff call 10ab58 <_POSIX_signals_Get_lowest> 10ac1a: 89 07 mov %eax,(%edi) _POSIX_signals_Clear_signals( 10ac1c: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac23: 6a 00 push $0x0 10ac25: 57 push %edi 10ac26: 50 push %eax 10ac27: 53 push %ebx 10ac28: e8 db 50 00 00 call 10fd08 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10ac2d: ff 75 d0 pushl -0x30(%ebp) 10ac30: 9d popf the_info->si_code = SI_USER; 10ac31: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac38: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return the_info->si_signo; 10ac3f: 8b 1f mov (%edi),%ebx 10ac41: eb 3d jmp 10ac80 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10ac43: 8b 0d 90 6a 12 00 mov 0x126a90,%ecx 10ac49: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac4c: 74 3a je 10ac88 signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 10ac4e: 83 ec 0c sub $0xc,%esp 10ac51: 51 push %ecx 10ac52: e8 01 ff ff ff call 10ab58 <_POSIX_signals_Get_lowest> 10ac57: 89 c3 mov %eax,%ebx _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10ac59: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac60: 6a 01 push $0x1 10ac62: 57 push %edi 10ac63: 50 push %eax 10ac64: ff 75 d4 pushl -0x2c(%ebp) 10ac67: e8 9c 50 00 00 call 10fd08 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 10ac6c: ff 75 d0 pushl -0x30(%ebp) 10ac6f: 9d popf the_info->si_signo = signo; 10ac70: 89 1f mov %ebx,(%edi) the_info->si_code = SI_USER; 10ac72: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac79: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return signo; 10ac80: 83 c4 20 add $0x20,%esp 10ac83: e9 92 00 00 00 jmp 10ad1a } the_info->si_signo = -1; 10ac88: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10ac8e: 8b 0d 20 63 12 00 mov 0x126320,%ecx 10ac94: 41 inc %ecx 10ac95: 89 0d 20 63 12 00 mov %ecx,0x126320 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10ac9b: c7 42 44 28 6a 12 00 movl $0x126a28,0x44(%edx) the_thread->Wait.return_code = EINTR; 10aca2: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) the_thread->Wait.option = *set; 10aca9: 8b 0e mov (%esi),%ecx 10acab: 89 4a 30 mov %ecx,0x30(%edx) the_thread->Wait.return_argument = the_info; 10acae: 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; 10acb1: c7 05 58 6a 12 00 01 movl $0x1,0x126a58 10acb8: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10acbb: ff 75 d0 pushl -0x30(%ebp) 10acbe: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10acbf: 52 push %edx 10acc0: 68 f8 d9 10 00 push $0x10d9f8 10acc5: 50 push %eax 10acc6: 68 28 6a 12 00 push $0x126a28 10accb: e8 4c 2a 00 00 call 10d71c <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10acd0: e8 c5 25 00 00 call 10d29a <_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 ); 10acd5: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10acdc: 6a 00 push $0x0 10acde: 57 push %edi 10acdf: ff 37 pushl (%edi) 10ace1: ff 75 d4 pushl -0x2c(%ebp) 10ace4: e8 1f 50 00 00 call 10fd08 <_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) 10ace9: 83 c4 20 add $0x20,%esp 10acec: a1 68 68 12 00 mov 0x126868,%eax 10acf1: 83 78 34 04 cmpl $0x4,0x34(%eax) 10acf5: 75 10 jne 10ad07 || !(*set & signo_to_mask( the_info->si_signo )) ) { 10acf7: 8b 1f mov (%edi),%ebx 10acf9: 8d 4b ff lea -0x1(%ebx),%ecx 10acfc: b8 01 00 00 00 mov $0x1,%eax 10ad01: d3 e0 shl %cl,%eax 10ad03: 85 06 test %eax,(%esi) 10ad05: 75 13 jne 10ad1a errno = _Thread_Executing->Wait.return_code; 10ad07: e8 7c 78 00 00 call 112588 <__errno> 10ad0c: 8b 15 68 68 12 00 mov 0x126868,%edx 10ad12: 8b 52 34 mov 0x34(%edx),%edx 10ad15: 89 10 mov %edx,(%eax) return -1; 10ad17: 83 cb ff or $0xffffffff,%ebx } return the_info->si_signo; } 10ad1a: 89 d8 mov %ebx,%eax 10ad1c: 8d 65 f4 lea -0xc(%ebp),%esp 10ad1f: 5b pop %ebx 10ad20: 5e pop %esi 10ad21: 5f pop %edi 10ad22: c9 leave 10ad23: c3 ret =============================================================================== 0010ca18 : int sigwait( const sigset_t *set, int *sig ) { 10ca18: 55 push %ebp 10ca19: 89 e5 mov %esp,%ebp 10ca1b: 53 push %ebx 10ca1c: 83 ec 08 sub $0x8,%esp 10ca1f: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10ca22: 6a 00 push $0x0 10ca24: 6a 00 push $0x0 10ca26: ff 75 08 pushl 0x8(%ebp) 10ca29: e8 45 fe ff ff call 10c873 10ca2e: 89 c2 mov %eax,%edx if ( status != -1 ) { 10ca30: 83 c4 10 add $0x10,%esp 10ca33: 83 f8 ff cmp $0xffffffff,%eax 10ca36: 74 0a je 10ca42 if ( sig ) *sig = status; return 0; 10ca38: 31 c0 xor %eax,%eax int status; status = sigtimedwait( set, NULL, NULL ); if ( status != -1 ) { if ( sig ) 10ca3a: 85 db test %ebx,%ebx 10ca3c: 74 0b je 10ca49 <== NEVER TAKEN *sig = status; 10ca3e: 89 13 mov %edx,(%ebx) 10ca40: eb 07 jmp 10ca49 return 0; } return errno; 10ca42: e8 79 73 00 00 call 113dc0 <__errno> 10ca47: 8b 00 mov (%eax),%eax } 10ca49: 8b 5d fc mov -0x4(%ebp),%ebx 10ca4c: c9 leave 10ca4d: c3 ret =============================================================================== 0010a030 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10a030: 55 push %ebp 10a031: 89 e5 mov %esp,%ebp 10a033: 56 push %esi 10a034: 53 push %ebx 10a035: 8b 5d 0c mov 0xc(%ebp),%ebx 10a038: 8b 75 10 mov 0x10(%ebp),%esi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10a03b: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10a03f: 75 1d jne 10a05e rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10a041: 85 f6 test %esi,%esi 10a043: 74 19 je 10a05e /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10a045: 85 db test %ebx,%ebx 10a047: 74 22 je 10a06b /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10a049: 8b 03 mov (%ebx),%eax 10a04b: 48 dec %eax 10a04c: 83 f8 01 cmp $0x1,%eax 10a04f: 77 0d ja 10a05e <== 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 ) 10a051: 8b 43 04 mov 0x4(%ebx),%eax 10a054: 85 c0 test %eax,%eax 10a056: 74 06 je 10a05e <== NEVER TAKEN static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a058: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10a059: 83 f8 1f cmp $0x1f,%eax 10a05c: 76 0d jbe 10a06b <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10a05e: e8 19 7d 00 00 call 111d7c <__errno> 10a063: c7 00 16 00 00 00 movl $0x16,(%eax) 10a069: eb 2f jmp 10a09a rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a06b: a1 34 63 12 00 mov 0x126334,%eax 10a070: 40 inc %eax 10a071: a3 34 63 12 00 mov %eax,0x126334 * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void ) { return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information ); 10a076: 83 ec 0c sub $0xc,%esp 10a079: 68 38 66 12 00 push $0x126638 10a07e: e8 75 1b 00 00 call 10bbf8 <_Objects_Allocate> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10a083: 83 c4 10 add $0x10,%esp 10a086: 85 c0 test %eax,%eax 10a088: 75 18 jne 10a0a2 _Thread_Enable_dispatch(); 10a08a: e8 77 29 00 00 call 10ca06 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10a08f: e8 e8 7c 00 00 call 111d7c <__errno> 10a094: c7 00 0b 00 00 00 movl $0xb,(%eax) 10a09a: 83 c8 ff or $0xffffffff,%eax 10a09d: e9 83 00 00 00 jmp 10a125 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10a0a2: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10a0a6: 8b 15 7c 68 12 00 mov 0x12687c,%edx 10a0ac: 8b 52 08 mov 0x8(%edx),%edx 10a0af: 89 50 38 mov %edx,0x38(%eax) if ( evp != NULL ) { 10a0b2: 85 db test %ebx,%ebx 10a0b4: 74 11 je 10a0c7 ptimer->inf.sigev_notify = evp->sigev_notify; 10a0b6: 8b 13 mov (%ebx),%edx 10a0b8: 89 50 40 mov %edx,0x40(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10a0bb: 8b 53 04 mov 0x4(%ebx),%edx 10a0be: 89 50 44 mov %edx,0x44(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10a0c1: 8b 53 08 mov 0x8(%ebx),%edx 10a0c4: 89 50 48 mov %edx,0x48(%eax) } ptimer->overrun = 0; 10a0c7: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) ptimer->timer_data.it_value.tv_sec = 0; 10a0ce: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10a0d5: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10a0dc: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10a0e3: 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; 10a0ea: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10a0f1: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10a0f8: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10a0ff: 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 ), 10a106: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a109: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a10c: 8b 0d 54 66 12 00 mov 0x126654,%ecx 10a112: 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; 10a115: 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; 10a11c: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10a11e: e8 e3 28 00 00 call 10ca06 <_Thread_Enable_dispatch> return 0; 10a123: 31 c0 xor %eax,%eax } 10a125: 8d 65 f8 lea -0x8(%ebp),%esp 10a128: 5b pop %ebx 10a129: 5e pop %esi 10a12a: c9 leave 10a12b: c3 ret =============================================================================== 0010a12c : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10a12c: 55 push %ebp 10a12d: 89 e5 mov %esp,%ebp 10a12f: 57 push %edi 10a130: 56 push %esi 10a131: 53 push %ebx 10a132: 83 ec 2c sub $0x2c,%esp 10a135: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10a138: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a13c: 0f 84 58 01 00 00 je 10a29a <== 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) ) ) { 10a142: 83 ec 0c sub $0xc,%esp 10a145: 8b 45 10 mov 0x10(%ebp),%eax 10a148: 83 c0 08 add $0x8,%eax 10a14b: 50 push %eax 10a14c: e8 13 33 00 00 call 10d464 <_Timespec_Is_valid> 10a151: 83 c4 10 add $0x10,%esp 10a154: 84 c0 test %al,%al 10a156: 0f 84 3e 01 00 00 je 10a29a rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 10a15c: 83 ec 0c sub $0xc,%esp 10a15f: ff 75 10 pushl 0x10(%ebp) 10a162: e8 fd 32 00 00 call 10d464 <_Timespec_Is_valid> 10a167: 83 c4 10 add $0x10,%esp 10a16a: 84 c0 test %al,%al 10a16c: 0f 84 28 01 00 00 je 10a29a <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10a172: 85 db test %ebx,%ebx 10a174: 74 09 je 10a17f 10a176: 83 fb 04 cmp $0x4,%ebx 10a179: 0f 85 1b 01 00 00 jne 10a29a rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10a17f: 8d 7d cc lea -0x34(%ebp),%edi 10a182: b9 04 00 00 00 mov $0x4,%ecx 10a187: 8b 75 10 mov 0x10(%ebp),%esi 10a18a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 10a18c: 83 fb 04 cmp $0x4,%ebx 10a18f: 75 2f jne 10a1c0 struct timespec now; _TOD_Get( &now ); 10a191: 83 ec 0c sub $0xc,%esp 10a194: 8d 5d dc lea -0x24(%ebp),%ebx 10a197: 53 push %ebx 10a198: e8 b3 15 00 00 call 10b750 <_TOD_Get> /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 10a19d: 59 pop %ecx 10a19e: 5e pop %esi 10a19f: 8d 75 d4 lea -0x2c(%ebp),%esi 10a1a2: 56 push %esi 10a1a3: 53 push %ebx 10a1a4: e8 97 32 00 00 call 10d440 <_Timespec_Greater_than> 10a1a9: 83 c4 10 add $0x10,%esp 10a1ac: 84 c0 test %al,%al 10a1ae: 0f 85 e6 00 00 00 jne 10a29a rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 10a1b4: 52 push %edx 10a1b5: 56 push %esi 10a1b6: 56 push %esi 10a1b7: 53 push %ebx 10a1b8: e8 cb 32 00 00 call 10d488 <_Timespec_Subtract> 10a1bd: 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 ); 10a1c0: 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 ); 10a1c1: 8d 45 e4 lea -0x1c(%ebp),%eax 10a1c4: 50 push %eax 10a1c5: ff 75 08 pushl 0x8(%ebp) 10a1c8: 68 38 66 12 00 push $0x126638 10a1cd: e8 56 1e 00 00 call 10c028 <_Objects_Get> 10a1d2: 89 c3 mov %eax,%ebx switch ( location ) { 10a1d4: 83 c4 10 add $0x10,%esp 10a1d7: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10a1db: 0f 85 b9 00 00 00 jne 10a29a 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 ) { 10a1e1: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10a1e5: 75 3b jne 10a222 10a1e7: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10a1eb: 75 35 jne 10a222 /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10a1ed: 83 ec 0c sub $0xc,%esp 10a1f0: 8d 40 10 lea 0x10(%eax),%eax 10a1f3: 50 push %eax 10a1f4: e8 5b 36 00 00 call 10d854 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 10a1f9: 83 c4 10 add $0x10,%esp 10a1fc: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a200: 74 0d je 10a20f *ovalue = ptimer->timer_data; 10a202: 8d 73 54 lea 0x54(%ebx),%esi 10a205: b9 04 00 00 00 mov $0x4,%ecx 10a20a: 8b 7d 14 mov 0x14(%ebp),%edi 10a20d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* The new data are set */ ptimer->timer_data = normalize; 10a20f: 8d 7b 54 lea 0x54(%ebx),%edi 10a212: 8d 75 cc lea -0x34(%ebp),%esi 10a215: b9 04 00 00 00 mov $0x4,%ecx 10a21a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a21c: c6 43 3c 04 movb $0x4,0x3c(%ebx) 10a220: eb 35 jmp 10a257 _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10a222: 83 ec 0c sub $0xc,%esp 10a225: ff 75 10 pushl 0x10(%ebp) 10a228: e8 8f 32 00 00 call 10d4bc <_Timespec_To_ticks> 10a22d: 89 43 64 mov %eax,0x64(%ebx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 10a230: 8d 45 d4 lea -0x2c(%ebp),%eax 10a233: 89 04 24 mov %eax,(%esp) 10a236: e8 81 32 00 00 call 10d4bc <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 10a23b: 89 1c 24 mov %ebx,(%esp) 10a23e: 68 b0 a2 10 00 push $0x10a2b0 10a243: ff 73 08 pushl 0x8(%ebx) 10a246: 50 push %eax 10a247: 8d 43 10 lea 0x10(%ebx),%eax 10a24a: 50 push %eax 10a24b: e8 40 57 00 00 call 10f990 <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10a250: 83 c4 20 add $0x20,%esp 10a253: 84 c0 test %al,%al 10a255: 75 07 jne 10a25e _Thread_Enable_dispatch(); 10a257: e8 aa 27 00 00 call 10ca06 <_Thread_Enable_dispatch> 10a25c: eb 38 jmp 10a296 /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10a25e: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a262: 74 0d je 10a271 *ovalue = ptimer->timer_data; 10a264: 8d 73 54 lea 0x54(%ebx),%esi 10a267: b9 04 00 00 00 mov $0x4,%ecx 10a26c: 8b 7d 14 mov 0x14(%ebp),%edi 10a26f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 10a271: 8d 7b 54 lea 0x54(%ebx),%edi 10a274: 8d 75 cc lea -0x34(%ebp),%esi 10a277: b9 04 00 00 00 mov $0x4,%ecx 10a27c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a27e: c6 43 3c 03 movb $0x3,0x3c(%ebx) _TOD_Get( &ptimer->time ); 10a282: 83 ec 0c sub $0xc,%esp 10a285: 83 c3 6c add $0x6c,%ebx 10a288: 53 push %ebx 10a289: e8 c2 14 00 00 call 10b750 <_TOD_Get> _Thread_Enable_dispatch(); 10a28e: e8 73 27 00 00 call 10ca06 <_Thread_Enable_dispatch> return 0; 10a293: 83 c4 10 add $0x10,%esp 10a296: 31 c0 xor %eax,%eax 10a298: eb 0e jmp 10a2a8 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a29a: e8 dd 7a 00 00 call 111d7c <__errno> 10a29f: c7 00 16 00 00 00 movl $0x16,(%eax) 10a2a5: 83 c8 ff or $0xffffffff,%eax } 10a2a8: 8d 65 f4 lea -0xc(%ebp),%esp 10a2ab: 5b pop %ebx 10a2ac: 5e pop %esi 10a2ad: 5f pop %edi 10a2ae: c9 leave 10a2af: c3 ret =============================================================================== 00109f6c : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 109f6c: 55 push %ebp 109f6d: 89 e5 mov %esp,%ebp 109f6f: 57 push %edi 109f70: 56 push %esi 109f71: 53 push %ebx 109f72: 83 ec 1c sub $0x1c,%esp 109f75: 8b 75 08 mov 0x8(%ebp),%esi /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 109f78: 83 3d 40 6c 12 00 00 cmpl $0x0,0x126c40 109f7f: 75 2c jne 109fad Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 109f81: c7 05 2c 6c 12 00 00 movl $0x0,0x126c2c 109f88: 00 00 00 the_watchdog->routine = routine; 109f8b: c7 05 40 6c 12 00 34 movl $0x109f34,0x126c40 109f92: 9f 10 00 the_watchdog->id = id; 109f95: c7 05 44 6c 12 00 00 movl $0x0,0x126c44 109f9c: 00 00 00 the_watchdog->user_data = user_data; 109f9f: c7 05 48 6c 12 00 00 movl $0x0,0x126c48 109fa6: 00 00 00 useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109fa9: 31 db xor %ebx,%ebx 109fab: eb 4f jmp 109ffc if ( !the_timer->routine ) { _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 109fad: 83 ec 0c sub $0xc,%esp 109fb0: 68 24 6c 12 00 push $0x126c24 109fb5: e8 82 34 00 00 call 10d43c <_Watchdog_Remove> if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 109fba: 83 e8 02 sub $0x2,%eax 109fbd: 83 c4 10 add $0x10,%esp useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109fc0: 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) ) { 109fc2: 83 f8 01 cmp $0x1,%eax 109fc5: 77 35 ja 109ffc <== 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); 109fc7: a1 38 6c 12 00 mov 0x126c38,%eax 109fcc: 03 05 30 6c 12 00 add 0x126c30,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fd2: 57 push %edi 109fd3: 57 push %edi 109fd4: 8d 55 e0 lea -0x20(%ebp),%edx 109fd7: 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); 109fd8: 2b 05 3c 6c 12 00 sub 0x126c3c,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fde: 50 push %eax 109fdf: e8 f8 2f 00 00 call 10cfdc <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 109fe4: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx remaining += tp.tv_nsec / 1000; 109feb: 8b 45 e4 mov -0x1c(%ebp),%eax 109fee: bf e8 03 00 00 mov $0x3e8,%edi 109ff3: 99 cltd 109ff4: f7 ff idiv %edi 109ff6: 8d 1c 08 lea (%eax,%ecx,1),%ebx 109ff9: 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 ) { 109ffc: 85 f6 test %esi,%esi 109ffe: 74 44 je 10a044 Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 10a000: b9 40 42 0f 00 mov $0xf4240,%ecx 10a005: 89 f0 mov %esi,%eax 10a007: 31 d2 xor %edx,%edx 10a009: f7 f1 div %ecx 10a00b: 89 45 e0 mov %eax,-0x20(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10a00e: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx 10a014: 89 55 e4 mov %edx,-0x1c(%ebp) ticks = _Timespec_To_ticks( &tp ); 10a017: 83 ec 0c sub $0xc,%esp 10a01a: 8d 75 e0 lea -0x20(%ebp),%esi 10a01d: 56 push %esi 10a01e: e8 15 30 00 00 call 10d038 <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 10a023: 89 34 24 mov %esi,(%esp) 10a026: e8 0d 30 00 00 call 10d038 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a02b: a3 30 6c 12 00 mov %eax,0x126c30 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a030: 59 pop %ecx 10a031: 5e pop %esi 10a032: 68 24 6c 12 00 push $0x126c24 10a037: 68 14 64 12 00 push $0x126414 10a03c: e8 db 32 00 00 call 10d31c <_Watchdog_Insert> 10a041: 83 c4 10 add $0x10,%esp } return remaining; } 10a044: 89 d8 mov %ebx,%eax 10a046: 8d 65 f4 lea -0xc(%ebp),%esp 10a049: 5b pop %ebx 10a04a: 5e pop %esi 10a04b: 5f pop %edi 10a04c: c9 leave 10a04d: c3 ret